1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
25 "bar" -> String -> Lyric -> Music
31 \repeat .. \alternative
34 \repeat { \repeat .. \alternative }
38 \repeat { \repeat } \alternative
50 * The rules for who is protecting what are very shady. Uniformise
53 * There are too many lexical modes.
60 #include "translator-def.hh"
61 #include "lily-guile.hh"
63 #include "my-lily-lexer.hh"
64 #include "paper-def.hh"
65 #include "midi-def.hh"
67 #include "file-path.hh"
69 #include "dimensions.hh"
70 #include "my-lily-parser.hh"
72 #include "input-file-results.hh"
74 #include "lilypond-input-version.hh"
75 #include "scm-hash.hh"
76 #include "auto-change-iterator.hh"
78 #include "ly-modules.hh"
79 #include "music-sequence.hh"
80 #include "input-smob.hh"
82 #include "text-item.hh"
85 regular_identifier_b (SCM id)
87 String str = ly_scm2string (id);
88 char const *s = str.to_str0 () ;
93 v = v && isalpha (*s);
100 make_simple_markup (SCM a)
104 simple = scm_c_eval_string ("simple-markup");
106 return scm_list_n (simple, a, SCM_UNDEFINED);
111 is_duration_b (int t)
113 return t && t == 1 << intlog2 (t);
117 set_music_properties (Music *p, SCM a)
119 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
121 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
127 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
130 set_property_music (SCM sym, SCM value)
132 Music * p = MY_MAKE_MUSIC("PropertySet");
133 p->set_mus_property ("symbol", sym);
134 p->set_mus_property ("value", value);
139 // needed for bison.simple's malloc () and free ()
141 // #include <malloc.h>
146 #define YYERROR_VERBOSE 1
148 My_lily_parser* my_lily_parser;
149 #define YYPARSE_PARAM my_lily_parser
150 #define YYLEX_PARAM my_lily_parser
152 ((My_lily_parser *) my_lily_parser)
154 #define yyerror THIS->parser_error
158 /* We use SCMs to do strings, because it saves us the trouble of
159 deleting them. Let's hope that a stack overflow doesnt trigger a move
160 of the parse stack onto the heap. */
167 Music_output_def * outputdef;
174 yylex (YYSTYPE *s, void * v)
176 My_lily_parser *pars = (My_lily_parser*) v;
177 My_lily_lexer * lex = pars->lexer_;
179 lex->lexval = (void*) s;
180 lex->prepare_for_next_token();
181 return lex->yylex ();
189 /* tokens which are not keywords */
198 %token CHORDMODIFIERS
204 %token GROBDESCRIPTIONS
209 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
210 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
218 %token MULTI_MEASURE_REST
229 %token OVERRIDE SET REVERT
239 %token COMMANDSPANREQUEST
241 %token OUTPUTPROPERTY
256 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
257 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
259 %token <i> E_UNSIGNED
260 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
263 %type <i> exclamations questions dots optional_rest
264 %type <i> bass_number bass_mod
265 %type <scm> br_bass_figure bass_figure figure_list figure_spec
267 %token <scm> NOTENAME_PITCH
268 %token <scm> TONICNAME_PITCH
269 %token <scm> CHORDMODIFIER_PITCH
270 %token <scm> DURATION_IDENTIFIER
271 %token <scm> FRACTION
272 %token <id> IDENTIFIER
275 %token <scm> SCORE_IDENTIFIER
276 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
277 %token <scm> NUMBER_IDENTIFIER
278 %token <scm> EVENT_IDENTIFIER
279 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
280 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
281 %token <scm> RESTNAME
288 %token <scm> MARKUP_HEAD_MARKUP0
289 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
290 %token <scm> MARKUP_HEAD_SCM0
291 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
292 %token <scm> MARKUP_HEAD_SCM0_SCM1
293 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
295 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
296 %type <scm> markup markup_line markup_list markup_list_body full_markup
298 %type <outputdef> output_def
299 %type <scm> lilypond_header lilypond_header_body
300 %type <music> open_event_parens close_event_parens open_event close_event
301 %type <music> event_with_dir event_that_take_dir verbose_event
302 %type <i> sub_quotes sup_quotes
303 %type <music> simple_element event_chord command_element Simple_music Composite_music
304 %type <music> Repeated_music
305 %type <scm> Alternative_music
306 %type <i> tremolo_type
307 %type <i> bare_int bare_unsigned
309 %type <scm> identifier_init
311 %type <music> note_chord_element chord_body chord_body_element
312 %type <scm> chord_body_elements
313 %type <scm> steno_duration optional_notemode_duration multiplied_duration
314 %type <scm> verbose_duration
316 %type <scm> pre_events post_events
317 %type <music> gen_text_def
318 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
319 %type <scm> explicit_pitch steno_tonic_pitch
321 %type <scm> chord_additions chord_subtractions chord_notes chord_step
323 %type <scm> chord_note chord_inversion chord_bass
324 %type <scm> duration_length fraction
326 %type <scm> embedded_scm scalar
327 %type <music> Music Sequential_music Simultaneous_music
328 %type <music> relative_music re_rhythmed_music part_combined_music
329 %type <music> property_def translator_change simple_property_def
330 %type <scm> Music_list
331 %type <outputdef> music_output_def_body
332 %type <music> shorthand_command_req
333 %type <music> post_event
334 %type <music> command_req verbose_command_req
335 %type <music> extender_req
336 %type <music> hyphen_req
337 %type <music> string_event
338 %type <scm> string bare_number number_expression number_term number_factor
339 %type <score> score_block score_body
341 %type <scm> translator_spec_block translator_spec_body
342 %type <music> tempo_event
343 %type <scm> notenames_body notenames_block chordmodifiers_block
344 %type <scm> script_abbreviation
350 /* We don't assign precedence to / and *, because we might need varied
351 prec levels in different prods */
357 lilypond: /* empty */
358 | lilypond toplevel_expression {}
359 | lilypond assignment { }
361 THIS->error_level_ = 1;
364 THIS->error_level_ = 1;
370 THIS->lexer_->pitchname_tab_ = $1;
372 | chordmodifiers_block {
373 THIS->lexer_->chordmodifier_tab_ = $1;
376 THIS->input_file_->header_ = $1;
379 THIS->input_file_->scores_.push ($1);
382 if (dynamic_cast<Paper_def*> ($1))
383 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
384 else if (dynamic_cast<Midi_def*> ($1))
385 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
395 chordmodifiers_block:
396 CHORDMODIFIERS notenames_body { $$ = $2; }
400 PITCHNAMES notenames_body { $$ = $2; }
405 int i = scm_ilength ($1);
407 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
408 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
409 SCM pt = ly_cdar (s);
410 if (!unsmob_pitch (pt))
411 THIS->parser_error ("Need pitch object.");
413 scm_hashq_set_x (tab, ly_caar (s), pt);
420 lilypond_header_body:
422 $$ = ly_make_anonymous_module ();
423 THIS->lexer_->add_scope ($$);
425 | lilypond_header_body assignment {
431 HEADER '{' lilypond_header_body '}' {
432 $$ = THIS->lexer_-> remove_scope();
444 /* cont */ '=' identifier_init {
447 Should find generic way of associating input with objects.
449 Input ip = THIS->pop_spot ();
451 if (! regular_identifier_b ($1))
453 ip.warning (_ ("Identifier should have alphabetic characters only"));
456 THIS->lexer_->set_identifier ($1, $4);
459 TODO: devise standard for protection in parser.
461 The parser stack lives on the C-stack, which means that
462 all objects can be unprotected as soon as they're here.
473 $$ = $1->self_scm ();
474 scm_gc_unprotect_object ($$);
480 $$ = $1->self_scm ();
481 scm_gc_unprotect_object ($$);
483 | translator_spec_block {
487 $$ = $1->self_scm ();
488 scm_gc_unprotect_object ($$);
491 $$ = $1->self_scm ();
492 scm_gc_unprotect_object ($$);
497 | number_expression {
508 translator_spec_block:
509 TRANSLATOR '{' translator_spec_body '}'
515 translator_spec_body:
516 TRANSLATOR_IDENTIFIER {
518 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
521 $$ = Translator_def::make_scm ();
522 Translator_def*td = unsmob_translator_def ($$);
523 td->translator_group_type_ = $2;
524 td->set_spot (THIS->here_input ());
526 | translator_spec_body STRING '=' embedded_scm {
527 unsmob_translator_def ($$)->add_property_assign ($2, $4);
529 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
530 unsmob_translator_def ($$)
531 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
533 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
534 unsmob_translator_def ($$)
535 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
537 | translator_spec_body STRING REVERT embedded_scm {
538 unsmob_translator_def ($$)->add_pop_property (
539 scm_string_to_symbol ($2), $4);
541 | translator_spec_body NAME STRING {
542 unsmob_translator_def ($$)->type_name_ = $3;
544 | translator_spec_body CONSISTS STRING {
545 unsmob_translator_def ($$)->add_element ($3);
547 | translator_spec_body ALIAS STRING {
548 Translator_def*td = unsmob_translator_def ($$);
549 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
551 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
552 Translator_def*td = unsmob_translator_def($$);
553 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
554 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
555 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
557 | translator_spec_body CONSISTSEND STRING {
558 unsmob_translator_def ($$)->add_last_element ( $3);
560 | translator_spec_body ACCEPTS STRING {
561 unsmob_translator_def ($$)->set_acceptor ($3,true);
563 | translator_spec_body DENIES STRING {
564 unsmob_translator_def ($$)->set_acceptor ($3,false);
566 | translator_spec_body REMOVE STRING {
567 unsmob_translator_def ($$)->remove_element ($3);
578 /*cont*/ '{' score_body '}' {
581 if (!$$->defs_.size ())
583 Music_output_def *id =
584 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
585 $$->add_output (id ? id->clone () : new Paper_def );
594 $$->set_spot (THIS->here_input ());
595 SCM m = $1->self_scm ();
596 scm_gc_unprotect_object (m);
601 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
602 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
603 m = gh_call1 (gh_car (check_funcs), m);
608 $$ = unsmob_score ($1);
609 $$->set_spot (THIS->here_input ());
611 | score_body lilypond_header {
614 | score_body output_def {
627 music_output_def_body '}' {
629 THIS-> lexer_-> remove_scope ();
633 music_output_def_body:
635 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
640 p = dynamic_cast<Midi_def*> (id->clone ());
645 THIS->lexer_->add_scope (p->scope_);
648 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
651 p = dynamic_cast<Paper_def*> (id->clone ());
655 THIS->lexer_->add_scope (p->scope_);
658 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
659 Music_output_def * o = unsmob_music_output_def ($3);
662 THIS->lexer_->add_scope (o->scope_);
664 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
665 Music_output_def * o = unsmob_music_output_def ($3);
668 THIS->lexer_->add_scope (o->scope_);
670 | music_output_def_body assignment {
673 | music_output_def_body translator_spec_block {
674 $$->assign_translator ($2);
676 | music_output_def_body tempo_event {
678 junk this ? there already is tempo stuff in
681 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
682 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
683 Midi_def * md = dynamic_cast<Midi_def*> ($$);
685 md->set_tempo (d->get_length (), m);
687 | music_output_def_body error {
693 TEMPO steno_duration '=' bare_unsigned {
694 $$ = MY_MAKE_MUSIC("TempoEvent");
695 $$->set_mus_property ("tempo-unit", $2);
696 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
701 The representation of a list is the
705 to have efficient append.
709 $$ = scm_cons (SCM_EOL, SCM_EOL);
713 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
714 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
715 if (gh_pair_p (ly_cdr (s)))
716 gh_set_cdr_x (ly_cdr (s), c); /* append */
718 gh_set_car_x (s, c); /* set first cons */
719 gh_set_cdr_x (s, c) ; /* remember last cell */
735 | ALTERNATIVE '{' Music_list '}' {
741 REPEAT string bare_unsigned Music Alternative_music
745 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
746 if (times < scm_ilength (alts)) {
747 unsmob_music (gh_car (alts))
748 ->origin ()->warning (
749 _("More alternatives than repeats. Junking excess alternatives."));
750 alts = ly_truncate_list (times, alts);
756 proc = scm_c_eval_string ("make-repeated-music");
758 SCM mus = scm_call_1 (proc, $2);
759 scm_gc_protect_object (mus); // UGH.
760 Music *r =unsmob_music (mus);
763 r-> set_mus_property ("element", beg->self_scm ());
764 scm_gc_unprotect_object (beg->self_scm ());
766 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
768 r-> set_mus_property ("elements",alts);
769 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
772 we can not get durations and other stuff correct down the line, so we have to
773 add to the duration log here.
775 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
777 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
779 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
781 r->set_spot (*$4->origin ());
788 SEQUENTIAL '{' Music_list '}' {
789 $$ = MY_MAKE_MUSIC("SequentialMusic");
790 $$->set_mus_property ("elements", ly_car ($3));
791 $$->set_spot(THIS->here_input());
793 | '{' Music_list '}' {
794 $$ = MY_MAKE_MUSIC("SequentialMusic");
795 $$->set_mus_property ("elements", ly_car ($2));
796 $$->set_spot(THIS->here_input());
801 SIMULTANEOUS '{' Music_list '}'{
802 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
803 $$->set_mus_property ("elements", ly_car ($3));
804 $$->set_spot(THIS->here_input());
807 | '<' Music_list '>' {
808 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
809 $$->set_mus_property ("elements", ly_car ($2));
810 $$->set_spot(THIS->here_input());
815 event_chord { $$ = $1; }
816 | APPLYCONTEXT embedded_scm {
817 if (!gh_procedure_p ($2))
818 THIS->parser_error (_ ("\applycontext takes function argument"));
819 $$ = MY_MAKE_MUSIC ("ApplyContext");
820 $$->set_mus_property ("procedure", $2);
821 $$->set_spot (THIS->here_input());
823 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
825 if (!gh_symbol_p ($3))
827 THIS->parser_error (_ ("Second argument must be a symbol"));
829 /* Should check # args */
830 if (!gh_procedure_p (pred))
832 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
835 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
836 m->set_mus_property ("predicate", pred);
837 m->set_mus_property ("grob-property", $3);
838 m->set_mus_property ("grob-value", $5);
843 $$ = unsmob_music ($1);
851 CONTEXT STRING Music {
852 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
854 csm->set_mus_property ("element", $3->self_scm ());
855 scm_gc_unprotect_object ($3->self_scm ());
857 csm->set_mus_property ("context-type",$2);
858 csm->set_mus_property ("context-id", scm_makfrom0str (""));
862 | AUTOCHANGE STRING Music {
863 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
864 chm->set_mus_property ("element", $3->self_scm ());
865 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
867 scm_gc_unprotect_object ($3->self_scm ());
868 chm->set_mus_property ("what", $2);
871 chm->set_spot (*$3->origin ());
876 The other version is for easier debugging of
877 Sequential_music_iterator in combination with grace notes.
880 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
881 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
882 Music *startm = unsmob_music (start);
883 Music *stopm = unsmob_music (stop);
887 stopm = stopm->clone ();
888 ms = scm_cons (stopm->self_scm (), ms);
889 scm_gc_unprotect_object (stopm->self_scm ());
891 ms = scm_cons ($2->self_scm (), ms);
892 scm_gc_unprotect_object ($2->self_scm());
894 startm = startm->clone ();
895 ms = scm_cons (startm->self_scm () , ms);
896 scm_gc_unprotect_object (startm->self_scm ());
900 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
901 seq->set_mus_property ("elements", ms);
904 $$ = MY_MAKE_MUSIC("GraceMusic");
905 $$->set_mus_property ("element", seq->self_scm ());
906 scm_gc_unprotect_object (seq->self_scm ());
908 $$ = MY_MAKE_MUSIC("GraceMusic");
909 $$->set_mus_property ("element", $2->self_scm ());
910 scm_gc_unprotect_object ($2->self_scm ());
913 | CONTEXT string '=' string Music {
914 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
916 csm->set_mus_property ("element", $5->self_scm ());
917 scm_gc_unprotect_object ($5->self_scm ());
919 csm->set_mus_property ("context-type", $2);
920 csm->set_mus_property ("context-id", $4);
931 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
933 $$= MY_MAKE_MUSIC("TimeScaledMusic");
934 $$->set_spot (THIS->pop_spot ());
937 $$->set_mus_property ("element", mp->self_scm ());
938 scm_gc_unprotect_object (mp->self_scm ());
939 $$->set_mus_property ("numerator", gh_int2scm (n));
940 $$->set_mus_property ("denominator", gh_int2scm (d));
941 $$->compress (Moment (Rational (n,d)));
944 | Repeated_music { $$ = $1; }
945 | Simultaneous_music { $$ = $1; }
946 | Sequential_music { $$ = $1; }
947 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
948 $$ = MY_MAKE_MUSIC("TransposedMusic");
950 Pitch from = *unsmob_pitch ($2);
951 Pitch to = *unsmob_pitch ($3);
953 p->transpose (interval (from, to));
954 $$->set_mus_property ("element", p->self_scm ());
955 scm_gc_unprotect_object (p->self_scm ());
957 | APPLY embedded_scm Music {
958 SCM ret = gh_call1 ($2, $3->self_scm ());
959 Music *m = unsmob_music (ret);
961 THIS->parser_error ("\\apply must return a Music");
962 m = MY_MAKE_MUSIC("Music");
967 { THIS->lexer_->push_note_state (); }
970 THIS->lexer_->pop_state ();
973 { THIS->lexer_->push_figuredbass_state (); }
976 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
977 chm->set_mus_property ("element", $3->self_scm ());
979 scm_gc_unprotect_object ($3->self_scm());
981 THIS->lexer_->pop_state ();
984 { THIS->lexer_->push_chord_state (); }
987 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
988 chm->set_mus_property ("element", $3->self_scm ());
989 scm_gc_unprotect_object ($3->self_scm());
992 THIS->lexer_->pop_state ();
995 { THIS->lexer_->push_lyric_state (); }
999 THIS->lexer_->pop_state ();
1001 | relative_music { $$ = $1; }
1002 | re_rhythmed_music { $$ = $1; }
1003 | part_combined_music { $$ = $1; }
1007 RELATIVE absolute_pitch Music {
1009 Pitch pit = *unsmob_pitch ($2);
1010 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1012 $$->set_mus_property ("element", p->self_scm ());
1013 scm_gc_unprotect_object (p->self_scm ());
1015 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1021 ADDLYRICS Music Music {
1022 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1023 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1024 scm_gc_unprotect_object ($3->self_scm ());
1025 scm_gc_unprotect_object ($2->self_scm ());
1030 part_combined_music:
1031 PARTCOMBINE STRING Music Music {
1032 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1033 p->set_mus_property ("what", $2);
1034 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1036 scm_gc_unprotect_object ($3->self_scm ());
1037 scm_gc_unprotect_object ($4->self_scm ());
1044 TRANSLATOR STRING '=' STRING {
1045 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1046 t-> set_mus_property ("change-to-type", $2);
1047 t-> set_mus_property ("change-to-id", $4);
1050 $$->set_spot (THIS->here_input ());
1056 | ONCE simple_property_def {
1058 SCM e = $2->get_mus_property ("element");
1059 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1063 simple_property_def:
1064 PROPERTY STRING '.' STRING '=' scalar {
1065 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1066 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1068 csm->set_mus_property ("element", t->self_scm ());
1069 scm_gc_unprotect_object (t->self_scm ());
1072 $$->set_spot (THIS->here_input ());
1074 csm-> set_mus_property ("context-type", $2);
1076 | PROPERTY STRING '.' STRING UNSET {
1078 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1079 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1081 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1082 csm->set_mus_property ("element", t->self_scm ());
1083 scm_gc_unprotect_object (t->self_scm ());
1086 $$->set_spot (THIS->here_input ());
1088 csm-> set_mus_property ("context-type", $2);
1090 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1092 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1093 bool itc = internal_type_checking_global_b;
1094 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1095 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1096 t->set_mus_property ("pop-first", SCM_BOOL_T);
1098 internal_type_checking_global_b = false;
1099 t->set_mus_property ("grob-property", $6);
1101 internal_type_checking_global_b = itc;
1102 t->set_mus_property ("grob-value", $8);
1104 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1105 csm->set_mus_property ("element", t->self_scm ());
1106 scm_gc_unprotect_object (t->self_scm ());
1108 $$->set_spot (THIS->here_input ());
1110 csm-> set_mus_property ("context-type", $2);
1112 | PROPERTY STRING '.' STRING OVERRIDE
1113 embedded_scm '=' embedded_scm
1119 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1120 bool itc = internal_type_checking_global_b;
1122 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1123 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1125 internal_type_checking_global_b = false;
1126 t->set_mus_property ("grob-property", $6);
1127 t->set_mus_property ("grob-value", $8);
1129 internal_type_checking_global_b = itc;
1131 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1132 csm->set_mus_property ("element", t->self_scm ());
1133 scm_gc_unprotect_object (t->self_scm ());
1136 $$->set_spot (THIS->here_input ());
1138 csm-> set_mus_property ("context-type", $2);
1141 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1142 Music *t = MY_MAKE_MUSIC("RevertProperty");
1144 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1145 bool itc = internal_type_checking_global_b;
1147 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1149 internal_type_checking_global_b = false;
1150 t->set_mus_property ("grob-property", $6);
1152 internal_type_checking_global_b = itc;
1154 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1155 csm->set_mus_property ("element", t->self_scm ());
1156 scm_gc_unprotect_object (t->self_scm ());
1159 $$->set_spot (THIS->here_input ());
1161 csm-> set_mus_property ("context-type", $2);
1168 | bare_int { $$ = gh_int2scm ($1); }
1169 | embedded_scm { $$ = $1; }
1176 } /*cont */ simple_element post_events {
1177 SCM elts = $3-> get_mus_property ("elements");
1179 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1180 scm_reverse_x ($4, SCM_EOL));
1182 $3-> set_mus_property ("elements", elts);
1186 | note_chord_element
1191 chord_body optional_notemode_duration post_events
1193 SCM dur = unsmob_duration ($2)->smobbed_copy();
1194 SCM es = $1->get_mus_property ("elements");
1195 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1197 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1198 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1199 es = gh_append2 (es, postevs);
1201 $1-> set_mus_property ("elements", es);
1207 CHORD_OPEN chord_body_elements CHORD_CLOSE
1209 $$ = MY_MAKE_MUSIC("EventChord");
1210 $$->set_mus_property ("elements",
1211 scm_reverse_x ($2, SCM_EOL));
1215 chord_body_elements:
1216 /* empty */ { $$ = SCM_EOL; }
1217 | chord_body_elements chord_body_element {
1218 $$ = gh_cons ($2->self_scm(), $1);
1219 scm_gc_unprotect_object ($2->self_scm());
1224 pitch exclamations questions post_events
1226 Music * n = MY_MAKE_MUSIC("NoteEvent");
1227 n->set_mus_property ("pitch", $1);
1229 n->set_mus_property ("cautionary", SCM_BOOL_T);
1230 if ($2 % 2 || $3 % 2)
1231 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1233 SCM arts = scm_reverse_x ($4, SCM_EOL);
1234 n->set_mus_property ("articulations", arts);
1242 $$ = MY_MAKE_MUSIC("EventChord");
1243 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1244 scm_gc_unprotect_object ($1->self_scm());
1246 $$-> set_spot (THIS->here_input ());
1247 $1-> set_spot (THIS->here_input ());
1250 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1251 l->set_mus_property ("span-direction", gh_int2scm (START));
1252 l->set_spot (THIS->here_input ());
1254 $$ = MY_MAKE_MUSIC("EventChord");
1255 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1256 scm_gc_unprotect_object (l->self_scm());
1257 $$->set_spot (THIS->here_input ());
1260 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1261 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1262 l->set_spot (THIS->here_input ());
1264 $$ = MY_MAKE_MUSIC("EventChord");
1265 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1266 $$->set_spot (THIS->here_input ());
1267 scm_gc_unprotect_object (l->self_scm());
1270 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1271 $$->set_spot (THIS->here_input ());
1275 $$ = MY_MAKE_MUSIC("BarCheck");
1276 $$->set_spot (THIS->here_input ());
1279 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1281 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1282 csm->set_mus_property ("element", t->self_scm ());
1283 scm_gc_unprotect_object (t->self_scm ());
1286 $$->set_spot (THIS->here_input ());
1288 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1290 | PARTIAL duration_length {
1291 Moment m = - unsmob_duration ($2)->get_length ();
1292 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1294 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1295 sp->set_mus_property ("element", p->self_scm ());
1296 scm_gc_unprotect_object (p->self_scm ());
1299 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1304 proc = scm_c_eval_string ("make-clef-set");
1306 SCM result = scm_call_1 (proc, $2);
1307 scm_gc_protect_object (result);
1308 $$ = unsmob_music (result);
1313 proc = scm_c_eval_string ("make-time-signature-set");
1315 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1316 scm_gc_protect_object (result);
1317 $$ = unsmob_music (result);
1322 shorthand_command_req { $$ = $1; }
1323 | verbose_command_req { $$ = $1; }
1326 shorthand_command_req:
1334 $$ = MY_MAKE_MUSIC("TieEvent");
1337 Music *b= MY_MAKE_MUSIC("BeamEvent");
1338 b->set_mus_property ("span-direction", gh_int2scm (START));
1341 THIS->last_beam_start_ = b->self_scm ();
1344 Music *b= MY_MAKE_MUSIC("BeamEvent");
1345 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1349 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1352 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1356 verbose_command_req:
1358 Music * m = MY_MAKE_MUSIC("MarkEvent");
1362 Music *m = MY_MAKE_MUSIC("MarkEvent");
1363 m->set_mus_property ("label", $2);
1366 | SKIP duration_length {
1367 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1368 skip->set_mus_property ("duration", $2);
1376 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1379 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1380 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1382 key->set_mus_property ("pitch-alist", $3);
1383 ((Music*)key)->transpose (* unsmob_pitch ($2));
1392 | post_events post_event {
1393 $2->set_spot (THIS->here_input ());
1394 $$ = gh_cons ($2->self_scm(), $$);
1395 scm_gc_unprotect_object ($2->self_scm());
1408 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1409 s->set_mus_property ("string-number", gh_int2scm($1));
1410 s->set_spot (THIS->here_input ());
1416 event_that_take_dir:
1422 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1423 m->set_spot (THIS->here_input());
1424 m->set_mus_property ("span-direction" , gh_int2scm (START));
1428 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1429 m->set_spot (THIS->here_input());
1430 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1434 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1435 m->set_spot (THIS->here_input());
1438 | script_abbreviation {
1439 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1440 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1441 if (gh_string_p (s))
1442 a->set_mus_property ("articulation-type", s);
1443 else THIS->parser_error (_ ("Expecting string as script definition"));
1449 script_dir event_that_take_dir {
1450 $2->set_mus_property ("direction", gh_int2scm ($1));
1457 $$ = unsmob_music ($1);
1460 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1461 a->set_spot (THIS->here_input ());
1462 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1489 | NOTENAME_PITCH sup_quotes {
1490 Pitch p = *unsmob_pitch ($1);
1492 $$ = p.smobbed_copy ();
1494 | NOTENAME_PITCH sub_quotes {
1495 Pitch p =* unsmob_pitch ($1);
1498 $$ = p.smobbed_copy ();
1511 | TONICNAME_PITCH sup_quotes {
1512 Pitch p = *unsmob_pitch ($1);
1514 $$ = p.smobbed_copy ();
1516 | TONICNAME_PITCH sub_quotes {
1517 Pitch p =* unsmob_pitch ($1);
1520 $$ = p.smobbed_copy ();
1534 pitch_also_in_chords:
1540 PITCH embedded_scm {
1542 if (!unsmob_pitch ($2)) {
1543 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1544 $$ = Pitch ().smobbed_copy ();
1550 DURATION embedded_scm {
1552 if (!unsmob_duration ($2))
1554 THIS->parser_error (_ ("Must have duration object"));
1555 $$ = Duration ().smobbed_copy ();
1562 if (!THIS->lexer_->lyric_state_b ())
1563 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1564 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1570 if (!THIS->lexer_->lyric_state_b ())
1571 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1572 $$ = MY_MAKE_MUSIC("HyphenEvent");
1577 close_event_parens {
1579 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1586 Music * s= MY_MAKE_MUSIC("SlurEvent");
1588 s->set_spot (THIS->here_input());
1591 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1593 s->set_spot (THIS->here_input());
1596 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1598 s->set_spot (THIS->here_input());
1601 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1603 s->set_spot (THIS->here_input());
1611 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1618 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1619 s->set_spot (THIS->here_input());
1624 Music * s= MY_MAKE_MUSIC("SlurEvent");
1626 s->set_spot (THIS->here_input());
1630 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1632 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1633 s->set_spot (THIS->here_input());
1639 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1640 t->set_mus_property ("text", $1);
1641 t->set_spot (THIS->here_input ());
1645 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1646 t->set_mus_property ("text", $1);
1647 t->set_spot (THIS->here_input ());
1651 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1652 t->set_mus_property ("text", make_simple_markup ($1));
1653 t->set_spot (THIS->here_input ());
1658 Music * t = MY_MAKE_MUSIC("FingerEvent");
1659 t->set_mus_property ("digit", gh_int2scm ($1));
1660 t->set_spot (THIS->here_input ());
1665 script_abbreviation:
1667 $$ = scm_makfrom0str ("Hat");
1670 $$ = scm_makfrom0str ("Plus");
1673 $$ = scm_makfrom0str ("Dash");
1676 $$ = scm_makfrom0str ("Bar");
1679 $$ = scm_makfrom0str ("Larger");
1682 $$ = scm_makfrom0str ("Dot");
1685 $$ = scm_makfrom0str ("Underscore");
1692 | '-' { $$ = CENTER; }
1699 | pre_events open_event {
1700 $$ = gh_cons ($2->self_scm(), $$);
1701 scm_gc_unprotect_object ($2->self_scm());
1712 multiplied_duration {
1715 | verbose_duration {
1720 optional_notemode_duration:
1722 Duration dd = THIS->default_duration_;
1723 $$ = dd.smobbed_copy ();
1725 THIS->beam_check ($$);
1727 | multiplied_duration {
1729 THIS->default_duration_ = *unsmob_duration ($$);
1731 THIS->beam_check ($$);
1733 | verbose_duration {
1735 THIS->default_duration_ = *unsmob_duration ($$);
1740 bare_unsigned dots {
1742 if (!is_duration_b ($1))
1743 THIS->parser_error (_f ("not a duration: %d", $1));
1747 $$ = Duration (l, $2).smobbed_copy ();
1749 | DURATION_IDENTIFIER dots {
1750 Duration *d =unsmob_duration ($1);
1751 Duration k (d->duration_log (),d->dot_count () + $2);
1761 multiplied_duration:
1765 | multiplied_duration '*' bare_unsigned {
1766 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1768 | multiplied_duration '*' FRACTION {
1769 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1771 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1776 FRACTION { $$ = $1; }
1777 | UNSIGNED '/' UNSIGNED {
1778 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1796 | ':' bare_unsigned {
1797 if (!is_duration_b ($2))
1798 THIS->parser_error (_f ("not a duration: %d", $2));
1805 /*****************************************************************
1807 *****************************************************************/
1821 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1822 $$ = bfr->self_scm();
1823 scm_gc_unprotect_object ($$);
1826 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1827 $$ = bfr->self_scm();
1829 bfr->set_mus_property ("figure", gh_int2scm ($1));
1831 scm_gc_unprotect_object ($$);
1833 | bass_figure bass_mod {
1834 Music *m = unsmob_music ($1);
1836 SCM salter =m->get_mus_property ("alteration");
1837 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1838 m->set_mus_property ("alteration",
1839 gh_int2scm (alter + $2));
1841 m->set_mus_property ("alteration", gh_int2scm (0));
1849 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1854 | br_bass_figure ']' {
1856 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1864 | figure_list br_bass_figure {
1865 $$ = scm_cons ($2, $1);
1870 FIGURE_OPEN figure_list FIGURE_CLOSE {
1871 Music * m = MY_MAKE_MUSIC("EventChord");
1872 $2 = scm_reverse_x ($2, SCM_EOL);
1873 m->set_mus_property ("elements", $2);
1874 $$ = m->self_scm ();
1885 pitch exclamations questions optional_notemode_duration optional_rest {
1887 Input i = THIS->pop_spot ();
1888 if (!THIS->lexer_->note_state_b ())
1889 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1893 n = MY_MAKE_MUSIC("RestEvent");
1895 n = MY_MAKE_MUSIC("NoteEvent");
1897 n->set_mus_property ("pitch", $1);
1898 n->set_mus_property ("duration", $4);
1902 n->set_mus_property ("cautionary", SCM_BOOL_T);
1903 if ($2 % 2 || $3 % 2)
1904 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1906 Music *v = MY_MAKE_MUSIC("EventChord");
1907 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1908 scm_gc_unprotect_object (n->self_scm());
1914 | figure_spec optional_notemode_duration {
1915 Music * m = unsmob_music ($1);
1916 Input i = THIS->pop_spot ();
1918 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1920 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1924 | RESTNAME optional_notemode_duration {
1926 Input i = THIS->pop_spot ();
1928 if (ly_scm2string ($1) =="s") {
1930 ev = MY_MAKE_MUSIC("SkipEvent");
1933 ev = MY_MAKE_MUSIC("RestEvent");
1936 ev->set_mus_property ("duration" ,$2);
1938 Music * velt = MY_MAKE_MUSIC("EventChord");
1939 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1944 | MULTI_MEASURE_REST optional_notemode_duration {
1949 proc = scm_c_eval_string ("make-multi-measure-rest");
1951 SCM mus = scm_call_2 (proc, $2,
1952 make_input (THIS->here_input()));
1953 scm_gc_protect_object (mus);
1954 $$ = unsmob_music (mus);
1956 | STRING optional_notemode_duration {
1957 Input i = THIS->pop_spot ();
1959 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1960 lreq->set_mus_property ("text", $1);
1961 lreq->set_mus_property ("duration",$2);
1963 Music * velt = MY_MAKE_MUSIC("EventChord");
1964 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1971 if (!THIS->lexer_->chord_state_b ())
1972 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1979 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1980 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1981 $$->set_spot (THIS->here_input ());
1988 | CHORD_COLON chord_notes {
1997 | chord_notes '.' chord_step {
1998 $$ = gh_append2 ($$, $3);
2006 | CHORD_CARET chord_notes {
2016 | CHORD_SLASH steno_tonic_pitch {
2025 | CHORD_BASS steno_tonic_pitch {
2032 $$ = scm_cons ($1, SCM_EOL);
2034 | CHORDMODIFIER_PITCH {
2035 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2037 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2038 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2046 m.notename_ = ($1 - 1) % 7;
2047 m.octave_ = $1 > 7 ? 1 : 0;
2050 $$ = m.smobbed_copy ();
2052 | bare_unsigned '+' {
2054 m.notename_ = ($1 - 1) % 7;
2055 m.octave_ = $1 > 7 ? 1 : 0;
2059 $$ = m.smobbed_copy ();
2061 | bare_unsigned CHORD_MINUS {
2063 m.notename_ = ($1 - 1) % 7;
2064 m.octave_ = $1 > 7 ? 1 : 0;
2067 $$ = m.smobbed_copy ();
2075 number_expression '+' number_term {
2076 $$ = scm_sum ($1, $3);
2078 | number_expression '-' number_term {
2079 $$ = scm_difference ($1, $3);
2088 | number_factor '*' number_factor {
2089 $$ = scm_product ($1, $3);
2091 | number_factor '/' number_factor {
2092 $$ = scm_divide ($1, $3);
2097 '-' number_factor { /* %prec UNARY_MINUS */
2098 $$ = scm_difference ($2, SCM_UNDEFINED);
2106 $$ = gh_int2scm ($1);
2111 | NUMBER_IDENTIFIER {
2114 | REAL NUMBER_IDENTIFIER {
2115 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2117 | UNSIGNED NUMBER_IDENTIFIER {
2118 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2134 if (scm_integer_p ($1) == SCM_BOOL_T)
2136 int k = gh_scm2int ($1);
2140 THIS->parser_error (_ ("need integer number arg"));
2154 | STRING_IDENTIFIER {
2157 | string '+' string {
2158 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2165 | exclamations '!' { $$ ++; }
2170 | questions '?' { $$ ++; }
2180 { THIS->lexer_->push_markup_state (); }
2183 THIS->lexer_->pop_state ();
2189 $$ = make_simple_markup ($1);
2191 | MARKUP_HEAD_MARKUP0 markup {
2192 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2194 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2195 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2197 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2198 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2203 | MARKUP_HEAD_LIST0 markup_list {
2204 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2206 | MARKUP_HEAD_SCM0 embedded_scm {
2207 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2209 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2210 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2212 | MARKUP_IDENTIFIER {
2219 '<' markup_list_body '>' { $$ = scm_reverse_x ($2, SCM_EOL); }
2223 '{' markup_list_body '}' {
2226 line = scm_c_eval_string ("line-markup");
2228 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2233 /**/ { $$ = SCM_EOL; }
2234 | markup_list_body markup {
2235 $$ = gh_cons ($2, $1) ;
2243 My_lily_parser::set_yydebug (bool )
2250 extern My_lily_parser * current_parser;
2253 My_lily_parser::do_yyparse ()
2255 current_parser = this;;
2256 yyparse ((void*)this);
2261 Should make this optional? It will also complain when you do
2265 which is entirely legitimate.
2267 Or we can scrap it. Barchecks should detect wrong durations, and
2268 skipTypesetting speeds it up a lot.
2272 My_lily_parser::beam_check (SCM dur)
2274 Duration *d = unsmob_duration (dur);
2275 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2277 Music * m = unsmob_music (last_beam_start_);
2278 m->origin ()->warning (_("Suspect duration found following this beam"));
2280 last_beam_start_ = SCM_EOL;
2288 return gh_pair_p (x)
2289 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2292 It is a little strange, to have this function in this file, but
2293 otherwise, we have to import music classes into the lexer.
2297 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2299 if (gh_string_p (sid)) {
2301 return STRING_IDENTIFIER;
2302 } else if (gh_number_p (sid)) {
2304 return NUMBER_IDENTIFIER;
2305 } else if (unsmob_translator_def (sid)) {
2306 *destination = unsmob_translator_def (sid)->clone_scm();
2307 return TRANSLATOR_IDENTIFIER;
2308 } else if (unsmob_score (sid)) {
2309 Score *sc = new Score (*unsmob_score (sid));
2310 *destination =sc->self_scm ();
2311 return SCORE_IDENTIFIER;
2312 } else if (Music * mus =unsmob_music (sid)) {
2313 *destination = unsmob_music (sid)->clone ()->self_scm();
2314 unsmob_music (*destination)->
2315 set_mus_property ("origin", make_input (last_input_));
2316 return dynamic_cast<Event*> (mus)
2317 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2318 } else if (unsmob_duration (sid)) {
2319 *destination = unsmob_duration (sid)->smobbed_copy();
2320 return DURATION_IDENTIFIER;
2321 } else if (unsmob_music_output_def (sid)) {
2322 Music_output_def *p = unsmob_music_output_def (sid);
2325 *destination = p->self_scm();
2326 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2327 } else if (new_markup_p (sid)) {
2329 return MARKUP_IDENTIFIER;