1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
20 the rules for who is protecting what are very shady. TODO: uniformise
29 #include "translator-def.hh"
30 #include "lily-guile.hh"
31 #include "change-iterator.hh"
33 #include "my-lily-lexer.hh"
34 #include "paper-def.hh"
35 #include "midi-def.hh"
37 #include "file-path.hh"
39 #include "dimensions.hh"
42 #include "my-lily-parser.hh"
43 #include "context-specced-music.hh"
45 #include "music-list.hh"
46 #include "output-property-music-iterator.hh"
47 #include "property-iterator.hh"
48 #include "input-file-results.hh"
50 #include "relative-music.hh"
51 #include "lyric-combine-music.hh"
52 #include "transposed-music.hh"
53 #include "time-scaled-music.hh"
54 #include "repeated-music.hh"
55 #include "untransposable-music.hh"
56 #include "lilypond-input-version.hh"
57 #include "grace-music.hh"
58 #include "part-combine-music.hh"
59 #include "scm-hash.hh"
60 #include "auto-change-iterator.hh"
61 #include "un-relativable-music.hh"
63 #include "ly-modules.hh"
66 regular_identifier_b (SCM id)
68 String str = ly_scm2string (id);
69 char const *s = str.to_str0 () ;
74 v = v && isalpha (*s);
84 return t && t == 1 << intlog2 (t);
88 set_music_properties (Music *p, SCM a)
90 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
92 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
98 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
101 set_property_music (SCM sym, SCM value)
103 Music * p = MY_MAKE_MUSIC("PropertySet");
104 p->set_mus_property ("symbol", sym);
105 p->set_mus_property ("value", value);
110 make_span_req (SCM name)
114 proc = scm_c_eval_string ("old-span-request->event");
115 SCM m = scm_call_1 (proc, name);
116 scm_gc_protect_object (m);
117 return unsmob_music (m);
120 // needed for bison.simple's malloc () and free ()
122 // #include <malloc.h>
127 #define YYERROR_VERBOSE 1
129 #define YYPARSE_PARAM my_lily_parser
130 #define YYLEX_PARAM my_lily_parser
132 ((My_lily_parser *) my_lily_parser)
134 #define yyerror THIS->parser_error
138 /* We use SCMs to do strings, because it saves us the trouble of
139 deleting them. Let's hope that a stack overflow doesnt trigger a move
140 of the parse stack onto the heap. */
145 Link_array<Music> *reqvec;
147 String *string; // needed by the lexer as temporary scratch area.
150 Scheme_hash_table *scmhash;
151 Music_output_def * outputdef;
158 yylex (YYSTYPE *s, void * v)
160 My_lily_parser *pars = (My_lily_parser*) v;
161 My_lily_lexer * lex = pars->lexer_;
163 lex->lexval = (void*) s;
164 return lex->yylex ();
172 /* tokens which are not keywords */
182 %token CHORDMODIFIERS
190 %token GROBDESCRIPTIONS
196 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
197 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
207 %token MULTI_MEASURE_REST
220 %token OVERRIDE SET REVERT
233 %token COMMANDSPANREQUEST
235 %token OUTPUTPROPERTY
246 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
247 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
249 %token <i> E_UNSIGNED
250 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
253 %type <i> exclamations questions dots optional_rest
254 %type <i> bass_number bass_mod
255 %type <scm> br_bass_figure bass_figure figure_list figure_spec
257 %token <scm> NOTENAME_PITCH
258 %token <scm> TONICNAME_PITCH
259 %token <scm> CHORDMODIFIER_PITCH
260 %token <scm> DURATION_IDENTIFIER
261 %token <scm> FRACTION
262 %token <id> IDENTIFIER
265 %token <scm> SCORE_IDENTIFIER
266 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
268 %token <scm> NUMBER_IDENTIFIER
269 %token <scm> REQUEST_IDENTIFIER
270 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
271 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
272 %token <scm> RESTNAME
278 %type <outputdef> output_def
279 %type <scm> lilypond_header lilypond_header_body
280 %type <music> open_request_parens close_request_parens open_request close_request
281 %type <music> request_with_dir request_that_take_dir verbose_request
282 %type <i> sub_quotes sup_quotes
283 %type <music> simple_element request_chord command_element Simple_music Composite_music
284 %type <music> Repeated_music
285 %type <scm> Alternative_music
286 %type <i> tremolo_type
287 %type <i> bare_int bare_unsigned
289 %type <scm> identifier_init
291 %type <scm> steno_duration optional_notemode_duration multiplied_duration
292 %type <scm> verbose_duration
294 %type <reqvec> pre_requests post_requests
295 %type <music> gen_text_def
296 %type <scm> steno_pitch pitch absolute_pitch
297 %type <scm> explicit_pitch steno_tonic_pitch
299 %type <scm> chord_additions chord_subtractions chord_notes chord_step
301 %type <scm> chord_note chord_inversion chord_bass
302 %type <scm> duration_length fraction
304 %type <scm> embedded_scm scalar
305 %type <music> Music Sequential_music Simultaneous_music
306 %type <music> relative_music re_rhythmed_music part_combined_music
307 %type <music> property_def translator_change simple_property_def
308 %type <scm> Music_list
309 %type <outputdef> music_output_def_body
310 %type <music> shorthand_command_req
311 %type <music> post_request
312 %type <music> command_req verbose_command_req
313 %type <music> extender_req
314 %type <music> hyphen_req
315 %type <music> string_request
316 %type <scm> string bare_number number_expression number_term number_factor
318 %type <score> score_block score_body
320 %type <scm> translator_spec_block translator_spec_body
321 %type <music> tempo_request
322 %type <scm> notenames_body notenames_block chordmodifiers_block
323 %type <scm> script_abbreviation
329 /* We don't assign precedence to / and *, because we might need varied
330 prec levels in different prods */
336 lilypond: /* empty */
337 | lilypond toplevel_expression {}
338 | lilypond assignment { }
340 THIS->error_level_ = 1;
343 THIS->error_level_ = 1;
349 THIS->lexer_->pitchname_tab_ = $1;
351 | chordmodifiers_block {
352 THIS->lexer_->chordmodifier_tab_ = $1;
355 THIS->input_file_->header_ = $1;
358 THIS->input_file_->scores_.push ($1);
361 if (dynamic_cast<Paper_def*> ($1))
362 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
363 else if (dynamic_cast<Midi_def*> ($1))
364 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
377 chordmodifiers_block:
378 CHORDMODIFIERS notenames_body { $$ = $2; }
382 PITCHNAMES notenames_body { $$ = $2; }
387 int i = scm_ilength ($1);
389 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
390 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
391 SCM pt = ly_cdar (s);
392 if (!unsmob_pitch (pt))
393 THIS->parser_error ("Need pitch object.");
395 scm_hashq_set_x (tab, ly_caar (s), pt);
402 lilypond_header_body:
404 $$ = ly_make_anonymous_module ();
405 THIS->lexer_->add_scope ($$);
407 | lilypond_header_body assignment {
413 HEADER '{' lilypond_header_body '}' {
414 $$ = THIS->lexer_-> remove_scope();
426 /* cont */ '=' identifier_init {
429 Should find generic way of associating input with objects.
431 Input ip = THIS->pop_spot ();
433 if (! regular_identifier_b ($1))
435 ip.warning (_ ("Identifier should have alphabetic characters only"));
438 THIS->lexer_->set_identifier ($1, $4);
441 TODO: devise standard for protection in parser.
443 The parser stack lives on the C-stack, which means that
444 all objects can be unprotected as soon as they're here.
454 $$ = $1->self_scm ();
455 scm_gc_unprotect_object ($$);
458 $$ = $1->self_scm ();
459 scm_gc_unprotect_object ($$);
461 | translator_spec_block {
465 $$ = $1->self_scm ();
466 scm_gc_unprotect_object ($$);
469 $$ = $1->self_scm ();
470 scm_gc_unprotect_object ($$);
475 | number_expression {
486 translator_spec_block:
487 TRANSLATOR '{' translator_spec_body '}'
493 translator_spec_body:
494 TRANSLATOR_IDENTIFIER {
495 $$ = unsmob_translator_def ($1)->clone_scm ();
496 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
499 $$ = Translator_def::make_scm ();
500 Translator_def*td = unsmob_translator_def ($$);
501 td->translator_group_type_ = $2;
502 td->set_spot (THIS->here_input ());
504 | translator_spec_body STRING '=' embedded_scm {
505 unsmob_translator_def ($$)->add_property_assign ($2, $4);
507 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
508 unsmob_translator_def ($$)
509 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
511 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
512 unsmob_translator_def ($$)
513 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
515 | translator_spec_body STRING REVERT embedded_scm {
516 unsmob_translator_def ($$)->add_pop_property (
517 scm_string_to_symbol ($2), $4);
519 | translator_spec_body NAME STRING {
520 unsmob_translator_def ($$)->type_name_ = $3;
522 | translator_spec_body CONSISTS STRING {
523 unsmob_translator_def ($$)->add_element ($3);
525 | translator_spec_body ALIAS STRING {
526 Translator_def*td = unsmob_translator_def ($$);
527 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
529 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
530 Translator_def*td = unsmob_translator_def($$);
531 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
532 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
533 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
535 | translator_spec_body CONSISTSEND STRING {
536 unsmob_translator_def ($$)->add_last_element ( $3);
538 | translator_spec_body ACCEPTS STRING {
539 unsmob_translator_def ($$)->set_acceptor ($3,true);
541 | translator_spec_body DENIES STRING {
542 unsmob_translator_def ($$)->set_acceptor ($3,false);
544 | translator_spec_body REMOVE STRING {
545 unsmob_translator_def ($$)->remove_element ($3);
556 /*cont*/ '{' score_body '}' {
559 if (!$$->defs_.size ())
561 Music_output_def *id =
562 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
563 $$->add_output (id ? id->clone () : new Paper_def );
572 $$->set_spot (THIS->here_input ());
573 SCM m = $1->self_scm ();
574 scm_gc_unprotect_object (m);
579 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
580 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
581 m = gh_call1 (gh_car (check_funcs), m);
586 $$ = new Score (*unsmob_score ($1));
587 $$->set_spot (THIS->here_input ());
589 | score_body lilypond_header {
592 | score_body output_def {
605 music_output_def_body '}' {
607 THIS-> lexer_-> remove_scope ();
611 music_output_def_body:
613 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
618 p = dynamic_cast<Midi_def*> (id->clone ());
623 THIS->lexer_->add_scope (p->scope_);
626 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
629 p = dynamic_cast<Paper_def*> (id->clone ());
632 THIS-> lexer_->add_scope (p->scope_);
635 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
636 Music_output_def *p = unsmob_music_output_def ($3);
638 THIS->lexer_->add_scope (p->scope_);
641 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
642 Music_output_def *p = unsmob_music_output_def ($3);
645 THIS->lexer_->add_scope (p->scope_);
648 | music_output_def_body assignment {
651 | music_output_def_body translator_spec_block {
652 $$->assign_translator ($2);
654 | music_output_def_body STYLESHEET embedded_scm {
655 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
657 | music_output_def_body tempo_request {
659 junk this ? there already is tempo stuff in
662 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
663 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
664 Midi_def * md = dynamic_cast<Midi_def*> ($$);
666 md->set_tempo (d->length_mom (), m);
668 | music_output_def_body error {
674 TEMPO steno_duration '=' bare_unsigned {
675 $$ = MY_MAKE_MUSIC("TempoEvent");
676 $$->set_mus_property ("duration", $2);
677 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
682 The representation of a list is the
686 to have efficient append.
688 Music_list: /* empty */ {
689 $$ = scm_cons (SCM_EOL, SCM_EOL);
693 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
694 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
695 if (gh_pair_p (ly_cdr (s)))
696 gh_set_cdr_x (ly_cdr (s), c); /* append */
698 gh_set_car_x (s, c); /* set first cons */
699 gh_set_cdr_x (s, c) ; /* remember last cell */
715 | ALTERNATIVE '{' Music_list '}' {
721 REPEAT string bare_unsigned Music Alternative_music
725 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
726 if (times < scm_ilength (alts)) {
727 unsmob_music (gh_car (alts))
728 ->origin ()->warning (
729 _("More alternatives than repeats. Junking excess alternatives."));
730 alts = ly_truncate_list (times, alts);
736 proc = scm_c_eval_string ("make-repeated-music");
738 SCM mus = scm_call_1 (proc, $2);
739 scm_gc_protect_object (mus); // UGH.
740 Music *r =unsmob_music (mus);
743 r-> set_mus_property ("element", beg->self_scm ());
744 scm_gc_unprotect_object (beg->self_scm ());
746 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
748 r-> set_mus_property ("elements",alts);
749 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
752 we can not get durations and other stuff correct down the line, so we have to
753 add to the duration log here.
755 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
757 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
759 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
761 r->set_spot (*$4->origin ());
768 SEQUENTIAL '{' Music_list '}' {
769 $$ = MY_MAKE_MUSIC("SequentialMusic");
770 $$->set_mus_property ("elements", ly_car ($3));
771 $$->set_spot(THIS->here_input());
773 | '{' Music_list '}' {
774 $$ = MY_MAKE_MUSIC("SequentialMusic");
775 $$->set_mus_property ("elements", ly_car ($2));
776 $$->set_spot(THIS->here_input());
781 SIMULTANEOUS '{' Music_list '}'{
782 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
783 $$->set_mus_property ("elements", ly_car ($3));
784 $$->set_spot(THIS->here_input());
787 | '<' Music_list '>' {
788 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
789 $$->set_mus_property ("elements", ly_car ($2));
790 $$->set_spot(THIS->here_input());
795 request_chord { $$ = $1; }
796 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
798 if (!gh_symbol_p ($3))
800 THIS->parser_error (_ ("Second argument must be a symbol"));
802 /* Should check # args */
803 if (!gh_procedure_p (pred))
805 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
808 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
809 m->set_mus_property ("predicate", pred);
810 m->set_mus_property ("grob-property", $3);
811 m->set_mus_property ("grob-value", $5);
816 $$ = unsmob_music ($1)->clone ();
818 $$->set_spot (THIS->here_input());
826 CONTEXT STRING Music {
827 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
829 csm->set_mus_property ("element", $3->self_scm ());
830 scm_gc_unprotect_object ($3->self_scm ());
832 csm->set_mus_property ("context-type",$2);
833 csm->set_mus_property ("context-id", scm_makfrom0str (""));
837 | AUTOCHANGE STRING Music {
838 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
839 chm->set_mus_property ("element", $3->self_scm ());
841 scm_gc_unprotect_object ($3->self_scm ());
842 chm->set_mus_property ("what", $2);
845 chm->set_spot (*$3->origin ());
850 The other version is for easier debugging of
851 Sequential_music_iterator in combination with grace notes.
854 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
855 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
856 Music *startm = unsmob_music (start);
857 Music *stopm = unsmob_music (stop);
861 stopm = stopm->clone ();
862 ms = scm_cons (stopm->self_scm (), ms);
863 scm_gc_unprotect_object (stopm->self_scm ());
865 ms = scm_cons ($2->self_scm (), ms);
866 scm_gc_unprotect_object ($2->self_scm());
868 startm = startm->clone ();
869 ms = scm_cons (startm->self_scm () , ms);
870 scm_gc_unprotect_object (startm->self_scm ());
874 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
875 seq->set_mus_property ("elements", ms);
878 $$ = MY_MAKE_MUSIC("GraceMusic");
879 $$->set_mus_property ("element", seq->self_scm ());
880 scm_gc_unprotect_object (seq->self_scm ());
882 $$ = MY_MAKE_MUSIC("GraceMusic");
883 $$->set_mus_property ("element", $2->self_scm ());
884 scm_gc_unprotect_object ($2->self_scm ());
887 | CONTEXT string '=' string Music {
888 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
890 csm->set_mus_property ("element", $5->self_scm ());
891 scm_gc_unprotect_object ($5->self_scm ());
893 csm->set_mus_property ("context-type", $2);
894 csm->set_mus_property ("context-id", $4);
905 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
907 $$= MY_MAKE_MUSIC("TimeScaledMusic");
908 $$->set_spot (THIS->pop_spot ());
911 $$->set_mus_property ("element", mp->self_scm ());
912 scm_gc_unprotect_object (mp->self_scm ());
913 $$->set_mus_property ("numerator", gh_int2scm (n));
914 $$->set_mus_property ("denominator", gh_int2scm (d));
915 $$->compress (Moment (Rational (n,d)));
918 | Repeated_music { $$ = $1; }
919 | Simultaneous_music { $$ = $1; }
920 | Sequential_music { $$ = $1; }
921 | TRANSPOSE pitch Music {
922 $$ = MY_MAKE_MUSIC("TransposedMusic");
924 Pitch pit = *unsmob_pitch ($2);
927 $$->set_mus_property ("element", p->self_scm ());
928 scm_gc_unprotect_object (p->self_scm ());
930 | TRANSPOSE steno_tonic_pitch Music {
931 $$ = MY_MAKE_MUSIC("TransposedMusic");
933 Pitch pit = *unsmob_pitch ($2);
936 $$->set_mus_property ("element", p->self_scm ());
937 scm_gc_unprotect_object (p->self_scm ());
940 | APPLY embedded_scm Music {
941 SCM ret = gh_call1 ($2, $3->self_scm ());
942 Music *m = unsmob_music (ret);
944 THIS->parser_error ("\\apply must return a Music");
945 m = MY_MAKE_MUSIC("Music");
950 { THIS->lexer_->push_note_state (); }
953 THIS->lexer_->pop_state ();
956 { THIS->lexer_->push_figuredbass_state (); }
959 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
960 chm->set_mus_property ("element", $3->self_scm ());
962 scm_gc_unprotect_object ($3->self_scm());
964 THIS->lexer_->pop_state ();
967 { THIS->lexer_->push_chord_state (); }
970 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
971 chm->set_mus_property ("element", $3->self_scm ());
972 scm_gc_unprotect_object ($3->self_scm());
975 THIS->lexer_->pop_state ();
978 { THIS->lexer_->push_lyric_state (); }
982 THIS->lexer_->pop_state ();
984 | relative_music { $$ = $1; }
985 | re_rhythmed_music { $$ = $1; }
986 | part_combined_music { $$ = $1; }
990 RELATIVE absolute_pitch Music {
992 Pitch pit = *unsmob_pitch ($2);
993 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
995 $$->set_mus_property ("element", p->self_scm ());
996 scm_gc_unprotect_object (p->self_scm ());
998 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1004 ADDLYRICS Music Music {
1005 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1006 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1007 scm_gc_unprotect_object ($3->self_scm ());
1008 scm_gc_unprotect_object ($2->self_scm ());
1013 part_combined_music:
1014 PARTCOMBINE STRING Music Music {
1015 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1016 p->set_mus_property ("what", $2);
1017 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1019 scm_gc_unprotect_object ($3->self_scm ());
1020 scm_gc_unprotect_object ($4->self_scm ());
1027 TRANSLATOR STRING '=' STRING {
1028 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1029 t-> set_mus_property ("change-to-type", $2);
1030 t-> set_mus_property ("change-to-id", $4);
1033 $$->set_spot (THIS->here_input ());
1039 | ONCE simple_property_def {
1041 SCM e = $2->get_mus_property ("element");
1042 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1046 simple_property_def:
1047 PROPERTY STRING '.' STRING '=' scalar {
1048 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1049 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1051 csm->set_mus_property ("element", t->self_scm ());
1052 scm_gc_unprotect_object (t->self_scm ());
1055 $$->set_spot (THIS->here_input ());
1057 csm-> set_mus_property ("context-type", $2);
1059 | PROPERTY STRING '.' STRING UNSET {
1061 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1062 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1064 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1065 csm->set_mus_property ("element", t->self_scm ());
1066 scm_gc_unprotect_object (t->self_scm ());
1069 $$->set_spot (THIS->here_input ());
1071 csm-> set_mus_property ("context-type", $2);
1073 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1075 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1076 bool itc = internal_type_checking_global_b;
1077 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1079 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1080 t->set_mus_property ("pop-first", SCM_BOOL_T);
1082 internal_type_checking_global_b = false;
1083 t->set_mus_property ("grob-property", $6);
1085 internal_type_checking_global_b = itc;
1086 t->set_mus_property ("grob-value", $8);
1088 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1089 csm->set_mus_property ("element", t->self_scm ());
1090 scm_gc_unprotect_object (t->self_scm ());
1092 $$->set_spot (THIS->here_input ());
1094 csm-> set_mus_property ("context-type", $2);
1096 | PROPERTY STRING '.' STRING OVERRIDE
1097 embedded_scm '=' embedded_scm
1103 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1104 bool itc = internal_type_checking_global_b;
1106 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1107 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1109 internal_type_checking_global_b = false;
1110 t->set_mus_property ("grob-property", $6);
1111 t->set_mus_property ("grob-value", $8);
1113 internal_type_checking_global_b = itc;
1115 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1116 csm->set_mus_property ("element", t->self_scm ());
1117 scm_gc_unprotect_object (t->self_scm ());
1120 $$->set_spot (THIS->here_input ());
1122 csm-> set_mus_property ("context-type", $2);
1125 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1126 Music *t = MY_MAKE_MUSIC("RevertProperty");
1128 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1129 bool itc = internal_type_checking_global_b;
1131 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1133 internal_type_checking_global_b = false;
1134 t->set_mus_property ("grob-property", $6);
1136 internal_type_checking_global_b = itc;
1138 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1139 csm->set_mus_property ("element", t->self_scm ());
1140 scm_gc_unprotect_object (t->self_scm ());
1143 $$->set_spot (THIS->here_input ());
1145 csm-> set_mus_property ("context-type", $2);
1152 | bare_int { $$ = gh_int2scm ($1); }
1153 | embedded_scm { $$ = $1; }
1160 } /*cont */ simple_element post_requests {
1161 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1164 for (int i=0; i < $1->size (); i++) {
1165 Music * m = $1->elem (i);
1166 l->append_music (m);
1178 $$ = MY_MAKE_MUSIC("RequestChord");
1179 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1180 scm_gc_unprotect_object ($1->self_scm());
1182 $$-> set_spot (THIS->here_input ());
1183 $1-> set_spot (THIS->here_input ());
1186 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1187 l->set_mus_property ("span-direction", gh_int2scm (START));
1188 l->set_spot (THIS->here_input ());
1190 $$ = MY_MAKE_MUSIC("RequestChord");
1191 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1192 scm_gc_unprotect_object (l->self_scm());
1193 $$->set_spot (THIS->here_input ());
1196 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1197 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1198 l->set_spot (THIS->here_input ());
1200 $$ = MY_MAKE_MUSIC("RequestChord");
1201 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1202 $$->set_spot (THIS->here_input ());
1203 scm_gc_unprotect_object (l->self_scm());
1207 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1208 $$->set_spot (THIS->here_input ());
1212 $$ = MY_MAKE_MUSIC("BarCheck");
1213 $$->set_spot (THIS->here_input ());
1216 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1218 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1219 csm->set_mus_property ("element", t->self_scm ());
1220 scm_gc_unprotect_object (t->self_scm ());
1223 $$->set_spot (THIS->here_input ());
1225 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1227 | PARTIAL duration_length {
1228 Moment m = - unsmob_duration ($2)->length_mom ();
1229 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1231 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1232 sp->set_mus_property ("element", p->self_scm ());
1233 scm_gc_unprotect_object (p->self_scm ());
1236 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1239 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1240 SCM result = gh_call1 (func, $2);
1243 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1244 Music * p = MY_MAKE_MUSIC("Music");
1245 set_music_properties (p, ly_car (s));
1246 l = scm_cons (p->self_scm (), l);
1247 scm_gc_unprotect_object (p->self_scm ());
1249 Music * seq = MY_MAKE_MUSIC("SequentialMusic");
1250 seq->set_mus_property ("elements", l);
1252 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1253 sp->set_mus_property ("element", seq->self_scm ());
1254 scm_gc_unprotect_object (seq->self_scm ());
1257 sp-> set_mus_property ("context-type", scm_makfrom0str ("Staff"));
1260 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1262 int l = gh_scm2int (ly_car ($2));
1263 int o = gh_scm2int (ly_cdr ($2));
1265 Moment one_beat = Moment (1)/Moment (o);
1266 Moment len = Moment (l) * one_beat;
1269 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1270 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1272 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1273 Music *seq = MY_MAKE_MUSIC("SequentialMusic");
1274 seq->set_mus_property ("elements", list);
1277 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1278 sp->set_mus_property ("element", seq->self_scm ());
1280 scm_gc_unprotect_object (p3->self_scm ());
1281 scm_gc_unprotect_object (p2->self_scm ());
1282 scm_gc_unprotect_object (p1->self_scm ());
1283 scm_gc_unprotect_object (seq->self_scm ());
1287 sp-> set_mus_property ("context-type", scm_makfrom0str ( "Timing"));
1292 shorthand_command_req { $$ = $1; }
1293 | verbose_command_req { $$ = $1; }
1296 shorthand_command_req:
1304 $$ = MY_MAKE_MUSIC("TieEvent");
1307 Music *b= MY_MAKE_MUSIC("BeamEvent");
1308 b->set_mus_property ("span-direction", gh_int2scm (START))
1313 THIS->last_beam_start_ = b->self_scm ();
1316 Music *b= MY_MAKE_MUSIC("BeamEvent");
1317 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1321 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1324 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1328 verbose_command_req:
1329 COMMANDSPANREQUEST bare_int STRING {
1330 Music *sp = make_span_req ($3);
1331 sp->set_mus_property ("span-direction", gh_int2scm (Direction ($2)));
1332 sp->set_spot (THIS->here_input ());
1336 Music * m = MY_MAKE_MUSIC("MarkEvent");
1340 Music *m = MY_MAKE_MUSIC("MarkEvent");
1341 m->set_mus_property ("label", $2);
1345 Music * b = MY_MAKE_MUSIC("BreakEvent");
1347 if (!gh_number_p (s))
1350 b->set_mus_property ("penalty", s);
1351 b->set_spot (THIS->here_input ());
1354 | SKIP duration_length {
1355 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1356 skip->set_mus_property ("duration", $2);
1364 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1367 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1368 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1370 key->set_mus_property ("pitch-alist", $3);
1371 ((Music*)key)->transpose (* unsmob_pitch ($2));
1378 $$ = new Link_array<Music>;
1380 | post_requests post_request {
1381 $2->set_spot (THIS->here_input ());
1396 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1397 s->set_mus_property ("string-number", gh_int2scm($1));
1398 s->set_spot (THIS->here_input ());
1404 request_that_take_dir:
1407 | script_abbreviation {
1408 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1409 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1410 if (gh_string_p (s))
1411 a->set_mus_property ("articulation-type", s);
1412 else THIS->parser_error (_ ("Expecting string as script definition"));
1418 script_dir request_that_take_dir {
1419 $2->set_mus_property ("direction", gh_int2scm ($1));
1425 REQUEST_IDENTIFIER {
1426 $$ = unsmob_music ($1)->clone ();
1427 $$->set_spot (THIS->here_input ());
1429 | DYNAMICSCRIPT embedded_scm {
1431 TODO: junkme, use text-type == dynamic
1433 Music *d = MY_MAKE_MUSIC("TextScriptEvent");
1434 SCM dyn = ly_symbol2scm ("dynamic");
1435 d->set_mus_property ("text-type" , dyn);
1436 d->set_mus_property ("text", $2);
1437 d->set_spot (THIS->here_input ());
1440 | SPANREQUEST bare_int STRING {
1442 Music * sp = make_span_req ($3);
1443 sp->set_mus_property ("span-direction", gh_int2scm ( $2));
1444 sp->set_spot (THIS->here_input ());
1448 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1449 a->set_spot (THIS->here_input ());
1450 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1454 Music * a = MY_MAKE_MUSIC("ArticulationEvent");
1455 a->set_mus_property ("articulation-type", $2);
1456 a->set_spot (THIS->here_input ());
1461 duh, junk this syntax from the parser, if possible.
1464 Music *a = MY_MAKE_MUSIC("ArpeggioEvent");
1465 a->set_spot (THIS->here_input ());
1469 Music *g = MY_MAKE_MUSIC("GlissandoEvent");
1470 g->set_spot /* No pun intended */ (THIS->here_input ());
1497 | NOTENAME_PITCH sup_quotes {
1498 Pitch p = *unsmob_pitch ($1);
1500 $$ = p.smobbed_copy ();
1502 | NOTENAME_PITCH sub_quotes {
1503 Pitch p =* unsmob_pitch ($1);
1506 $$ = p.smobbed_copy ();
1519 | TONICNAME_PITCH sup_quotes {
1520 Pitch p = *unsmob_pitch ($1);
1522 $$ = p.smobbed_copy ();
1524 | TONICNAME_PITCH sub_quotes {
1525 Pitch p =* unsmob_pitch ($1);
1528 $$ = p.smobbed_copy ();
1543 PITCH embedded_scm {
1545 if (!unsmob_pitch ($2)) {
1546 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1547 $$ = Pitch ().smobbed_copy ();
1553 DURATION embedded_scm {
1555 if (!unsmob_duration ($2))
1557 THIS->parser_error (_ ("Must have duration object"));
1558 $$ = Duration ().smobbed_copy ();
1565 if (!THIS->lexer_->lyric_state_b ())
1566 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1567 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1573 if (!THIS->lexer_->lyric_state_b ())
1574 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1575 $$ = MY_MAKE_MUSIC("HyphenEvent");
1580 close_request_parens {
1582 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1587 close_request_parens:
1589 Music * s= MY_MAKE_MUSIC("SlurEvent");
1591 s->set_spot (THIS->here_input());
1594 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1596 s->set_spot (THIS->here_input());
1599 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1601 s->set_spot (THIS->here_input());
1604 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1606 s->set_spot (THIS->here_input());
1612 open_request_parens {
1614 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1619 open_request_parens:
1621 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1622 s->set_spot (THIS->here_input());
1627 Music * s= MY_MAKE_MUSIC("SlurEvent");
1629 s->set_spot (THIS->here_input());
1633 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1635 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1636 s->set_spot (THIS->here_input());
1642 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1643 t->set_mus_property ("text", $1);
1644 t->set_spot (THIS->here_input ());
1648 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1649 t->set_mus_property ("text", $1);
1650 t->set_spot (THIS->here_input ());
1654 String ds = to_string ($1);
1655 Music * t = MY_MAKE_MUSIC("TextScriptEvent");
1656 SCM finger = ly_symbol2scm ("finger");
1657 t->set_mus_property ("text", scm_makfrom0str (ds.to_str0 ()));
1658 t->set_mus_property ("text-type" , finger);
1659 t->set_spot (THIS->here_input ());
1664 script_abbreviation:
1666 $$ = scm_makfrom0str ("Hat");
1669 $$ = scm_makfrom0str ("Plus");
1672 $$ = scm_makfrom0str ("Dash");
1675 $$ = scm_makfrom0str ("Bar");
1678 $$ = scm_makfrom0str ("Larger");
1681 $$ = scm_makfrom0str ("Dot");
1684 $$ = scm_makfrom0str ("Underscore");
1691 | '-' { $$ = CENTER; }
1696 $$ = new Link_array<Music>;
1698 | pre_requests open_request {
1710 multiplied_duration {
1713 | verbose_duration {
1718 optional_notemode_duration:
1720 Duration dd = THIS->default_duration_;
1721 $$ = dd.smobbed_copy ();
1723 THIS->beam_check ($$);
1725 | multiplied_duration {
1727 THIS->default_duration_ = *unsmob_duration ($$);
1729 THIS->beam_check ($$);
1731 | verbose_duration {
1733 THIS->default_duration_ = *unsmob_duration ($$);
1738 bare_unsigned dots {
1740 if (!is_duration_b ($1))
1741 THIS->parser_error (_f ("not a duration: %d", $1));
1745 $$ = Duration (l, $2).smobbed_copy ();
1747 | DURATION_IDENTIFIER dots {
1748 Duration *d =unsmob_duration ($1);
1749 Duration k (d->duration_log (),d->dot_count () + $2);
1750 $$ = k.smobbed_copy ();
1757 multiplied_duration:
1761 | multiplied_duration '*' bare_unsigned {
1762 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1764 | multiplied_duration '*' FRACTION {
1765 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1767 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1772 FRACTION { $$ = $1; }
1773 | UNSIGNED '/' UNSIGNED {
1774 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1792 | ':' bare_unsigned {
1793 if (!is_duration_b ($2))
1794 THIS->parser_error (_f ("not a duration: %d", $2));
1813 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1814 $$ = bfr->self_scm();
1815 scm_gc_unprotect_object ($$);
1818 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1819 $$ = bfr->self_scm();
1821 bfr->set_mus_property ("figure", gh_int2scm ($1));
1823 scm_gc_unprotect_object ($$);
1825 | bass_figure bass_mod {
1826 Music *m = unsmob_music ($1);
1828 SCM salter =m->get_mus_property ("alteration");
1829 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1830 m->set_mus_property ("alteration",
1831 gh_int2scm (alter + $2));
1833 m->set_mus_property ("alteration", gh_int2scm (0));
1841 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1846 | br_bass_figure ']' {
1848 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1856 | figure_list br_bass_figure {
1857 $$ = scm_cons ($2, $1);
1862 FIGURE_OPEN figure_list FIGURE_CLOSE {
1863 Music * m = MY_MAKE_MUSIC("RequestChord");
1864 $2 = scm_reverse_x ($2, SCM_EOL);
1865 m->set_mus_property ("elements", $2);
1866 $$ = m->self_scm ();
1877 pitch exclamations questions optional_notemode_duration optional_rest {
1879 Input i = THIS->pop_spot ();
1880 if (!THIS->lexer_->note_state_b ())
1881 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1885 n = MY_MAKE_MUSIC("RestEvent");
1887 n = MY_MAKE_MUSIC("NoteEvent");
1889 n->set_mus_property ("pitch", $1);
1890 n->set_mus_property ("duration", $4);
1894 n->set_mus_property ("cautionary", SCM_BOOL_T);
1895 if ($2 % 2 || $3 % 2)
1896 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1898 Music *v = MY_MAKE_MUSIC("RequestChord");
1899 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1900 scm_gc_unprotect_object (n->self_scm());
1906 | figure_spec optional_notemode_duration {
1907 Music * m = unsmob_music ($1);
1908 Input i = THIS->pop_spot ();
1910 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1912 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1916 | RESTNAME optional_notemode_duration {
1918 Input i = THIS->pop_spot ();
1919 SCM e = SCM_UNDEFINED;
1920 if (ly_scm2string ($1) =="s") {
1922 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1923 skip->set_mus_property ("duration" ,$2);
1925 e = skip->self_scm ();
1928 Music * rest_req = MY_MAKE_MUSIC("RestEvent");
1929 rest_req->set_mus_property ("duration", $2);
1930 rest_req->set_spot (i);
1931 e = rest_req->self_scm ();
1933 Music * velt = MY_MAKE_MUSIC("RequestChord");
1934 velt-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1939 | MULTI_MEASURE_REST optional_notemode_duration {
1942 Music * sk = MY_MAKE_MUSIC("SkipEvent");
1943 sk->set_mus_property ("duration", $2);
1944 Music *sp1 = MY_MAKE_MUSIC("MultiMeasureRestEvent");
1945 Music *sp2 = MY_MAKE_MUSIC("MultiMeasureRestEvent");
1946 sp1-> set_mus_property ("span-direction", gh_int2scm (START))
1948 sp2-> set_mus_property ("span-direction", gh_int2scm (STOP))
1950 Music *rqc1 = MY_MAKE_MUSIC("RequestChord");
1951 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1952 Music *rqc2 = MY_MAKE_MUSIC("RequestChord");
1953 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1954 Music *rqc3 = MY_MAKE_MUSIC("RequestChord");
1955 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1957 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1959 $$ = MY_MAKE_MUSIC("SequentialMusic");
1960 $$->set_mus_property ("elements", ms);
1962 | STRING optional_notemode_duration {
1963 Input i = THIS->pop_spot ();
1965 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1966 lreq->set_mus_property ("text", $1);
1967 lreq->set_mus_property ("duration",$2);
1969 Music * velt = MY_MAKE_MUSIC("RequestChord");
1970 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1977 if (!THIS->lexer_->chord_state_b ())
1978 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1985 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1986 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1987 $$->set_spot (THIS->here_input ());
1994 | CHORD_COLON chord_notes {
2003 | chord_notes '.' chord_step {
2004 $$ = gh_append2 ($$, $3);
2012 | CHORD_CARET chord_notes {
2022 | CHORD_SLASH steno_tonic_pitch {
2031 | CHORD_BASS steno_tonic_pitch {
2038 $$ = scm_cons ($1, SCM_EOL);
2040 | CHORDMODIFIER_PITCH {
2041 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2043 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2044 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2052 m.notename_ = ($1 - 1) % 7;
2053 m.octave_ = $1 > 7 ? 1 : 0;
2056 $$ = m.smobbed_copy ();
2058 | bare_unsigned '+' {
2060 m.notename_ = ($1 - 1) % 7;
2061 m.octave_ = $1 > 7 ? 1 : 0;
2065 $$ = m.smobbed_copy ();
2067 | bare_unsigned CHORD_MINUS {
2069 m.notename_ = ($1 - 1) % 7;
2070 m.octave_ = $1 > 7 ? 1 : 0;
2073 $$ = m.smobbed_copy ();
2081 number_expression '+' number_term {
2082 $$ = scm_sum ($1, $3);
2084 | number_expression '-' number_term {
2085 $$ = scm_difference ($1, $3);
2094 | number_factor '*' number_factor {
2095 $$ = scm_product ($1, $3);
2097 | number_factor '/' number_factor {
2098 $$ = scm_divide ($1, $3);
2103 '(' number_expression ')' {
2106 | '-' number_factor { /* %prec UNARY_MINUS */
2107 $$ = scm_difference ($2, SCM_UNDEFINED);
2115 $$ = gh_int2scm ($1);
2120 | NUMBER_IDENTIFIER {
2124 $$ = gh_double2scm (gh_scm2double ($1) CM );
2127 $$ = gh_double2scm (gh_scm2double ($1) PT);
2130 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2133 $$ = gh_double2scm (gh_scm2double ($1) MM);
2136 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2152 if (scm_integer_p ($1) == SCM_BOOL_T)
2154 int k = gh_scm2int ($1);
2158 THIS->parser_error (_ ("need integer number arg"));
2172 | STRING_IDENTIFIER {
2175 | string '+' string {
2176 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2183 | exclamations '!' { $$ ++; }
2188 | questions '?' { $$ ++; }
2195 My_lily_parser::set_yydebug (bool )
2202 extern My_lily_parser * current_parser;
2205 My_lily_parser::do_yyparse ()
2208 current_parser = this;;
2209 yyparse ((void*)this);
2214 Should make this optional? It will also complain when you do
2218 which is entirely legitimate.
2220 Or we can scrap it. Barchecks should detect wrong durations, and
2221 skipTypesetting speeds it up a lot.
2224 My_lily_parser::beam_check (SCM dur)
2226 Duration *d = unsmob_duration (dur);
2227 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2229 Music * m = unsmob_music (last_beam_start_);
2230 m->origin ()->warning (_("Suspect duration found following this beam"));
2232 last_beam_start_ = SCM_EOL;