1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
17 "bar" -> String -> Lyric -> Music -> music-assignment
19 "bar" -> String -> string-assignment
23 \repeat .. \alternative
26 \repeat { \repeat .. \alternative }
30 \repeat { \repeat } \alternative
42 * The rules for who is protecting what are very shady. Uniformise
45 * There are too many lexical modes?
52 #include "translator-def.hh"
53 #include "lily-guile.hh"
55 #include "my-lily-lexer.hh"
56 #include "paper-def.hh"
57 #include "midi-def.hh"
59 #include "file-path.hh"
61 #include "dimensions.hh"
62 #include "my-lily-parser.hh"
64 #include "input-file-results.hh"
66 #include "lilypond-input-version.hh"
67 #include "scm-hash.hh"
68 #include "auto-change-iterator.hh"
69 #include "ly-modules.hh"
70 #include "music-sequence.hh"
71 #include "input-smob.hh"
73 #include "text-item.hh"
77 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
81 #define YYERROR_VERBOSE 1
83 My_lily_parser* my_lily_parser;
84 #define YYPARSE_PARAM my_lily_parser
85 #define YYLEX_PARAM my_lily_parser
87 ((My_lily_parser *) my_lily_parser)
89 #define yyerror THIS->parser_error
96 regular_identifier_b (SCM id)
98 String str = ly_scm2string (id);
99 char const *s = str.to_str0 () ;
104 v = v && isalpha (*s);
111 make_simple_markup (SCM a)
115 simple = scm_c_eval_string ("simple-markup");
117 return scm_list_n (simple, a, SCM_UNDEFINED);
122 is_duration_b (int t)
124 return t && t == 1 << intlog2 (t);
128 set_music_properties (Music *p, SCM a)
130 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
132 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
138 make_chord_step (int step, int alter)
143 /* ugh: fucks up above 13 */
144 Pitch m(step > 7 ? 1 : 0,(step - 1) % 7, alter);
145 return m.smobbed_copy ();
150 make_chord (SCM pitch, SCM dur, SCM modification_list)
152 static SCM chord_ctor;
154 chord_ctor= scm_c_eval_string ("construct-chord");
155 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
156 scm_gc_protect_object (ch);
163 set_property_music (SCM sym, SCM value)
165 Music * p = MY_MAKE_MUSIC("PropertySet");
166 p->set_mus_property ("symbol", sym);
167 p->set_mus_property ("value", value);
173 /* We use SCMs to do strings, because it saves us the trouble of
174 deleting them. Let's hope that a stack overflow doesnt trigger a move
175 of the parse stack onto the heap. */
182 Music_output_def * outputdef;
189 yylex (YYSTYPE *s, void * v)
191 My_lily_parser *pars = (My_lily_parser*) v;
192 My_lily_lexer * lex = pars->lexer_;
194 lex->lexval = (void*) s;
195 lex->prepare_for_next_token();
196 return lex->yylex ();
204 /* tokens which are not keywords */
214 %token CHORDMODIFIERS
220 %token GROBDESCRIPTIONS
225 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
226 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
234 %token MULTI_MEASURE_REST
245 %token OVERRIDE SET REVERT
255 %token COMMANDSPANREQUEST
257 %token OUTPUTPROPERTY
272 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
273 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
275 %token <i> E_UNSIGNED
276 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
279 %type <i> exclamations questions dots optional_rest
280 %type <i> bass_number bass_mod
281 %type <scm> br_bass_figure bass_figure figure_list figure_spec
283 %token <scm> NOTENAME_PITCH
284 %token <scm> TONICNAME_PITCH
285 %token <scm> CHORDMODIFIER_PITCH
286 %token <scm> DURATION_IDENTIFIER
287 %token <scm> FRACTION
288 %token <id> IDENTIFIER
289 %token <scm> CHORDNAMES CHORDNAMES_IDENTIFIER
291 %token <scm> CHORD_MODIFIER
293 %token <scm> SCORE_IDENTIFIER
294 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
295 %token <scm> NUMBER_IDENTIFIER
296 %token <scm> EVENT_IDENTIFIER
297 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
298 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
299 %token <scm> RESTNAME
306 %token <scm> MARKUP_HEAD_MARKUP0
307 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
308 %token <scm> MARKUP_HEAD_SCM0
309 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
310 %token <scm> MARKUP_HEAD_SCM0_SCM1
311 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
313 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
314 %type <scm> markup markup_line markup_list markup_list_body full_markup
316 %type <outputdef> output_def
317 %type <scm> lilypond_header lilypond_header_body
318 %type <music> open_event_parens close_event_parens open_event close_event
319 %type <music> event_with_dir event_that_take_dir verbose_event
320 %type <i> sub_quotes sup_quotes
321 %type <music> simple_element event_chord command_element Simple_music Composite_music
322 %type <music> Repeated_music
323 %type <scm> Alternative_music
324 %type <i> tremolo_type
325 %type <i> bare_int bare_unsigned
327 %type <scm> identifier_init
329 %type <music> note_chord_element chord_body chord_body_element
330 %type <scm> chord_body_elements
331 %type <scm> steno_duration optional_notemode_duration multiplied_duration
332 %type <scm> verbose_duration
334 %type <scm> pre_events post_events
335 %type <music> gen_text_def
336 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
337 %type <scm> explicit_pitch steno_tonic_pitch
339 /* %type <scm> chord_additions chord_subtractions chord_notes chord_step */
340 /* %type <music> chord */
341 /* %type <scm> chord_note chord_inversion chord_bass */
342 %type <scm> duration_length fraction
344 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
346 %type <scm> embedded_scm scalar
347 %type <music> Music Sequential_music Simultaneous_music
348 %type <music> relative_music re_rhythmed_music part_combined_music
349 %type <music> property_def translator_change simple_property_def
350 %type <scm> Music_list
351 %type <outputdef> music_output_def_body
352 %type <music> shorthand_command_req
353 %type <music> post_event
354 %type <music> command_req verbose_command_req
355 %type <music> extender_req
356 %type <music> hyphen_req
357 %type <music> string_event
358 %type <scm> string bare_number number_expression number_term number_factor
359 %type <score> score_block score_body
361 %type <scm> translator_spec_block translator_spec_body
362 %type <music> tempo_event
363 %type <scm> notenames_body notenames_block chordmodifiers_block
364 %type <scm> script_abbreviation
370 /* We don't assign precedence to / and *, because we might need varied
371 prec levels in different prods */
377 lilypond: /* empty */
378 | lilypond toplevel_expression {}
379 | lilypond assignment { }
381 THIS->error_level_ = 1;
384 THIS->error_level_ = 1;
390 THIS->lexer_->pitchname_tab_ = $1;
392 | chordmodifiers_block {
393 THIS->lexer_->chordmodifier_tab_ = $1;
396 THIS->input_file_->header_ = $1;
399 THIS->input_file_->scores_.push ($1);
402 if (dynamic_cast<Paper_def*> ($1))
403 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
404 else if (dynamic_cast<Midi_def*> ($1))
405 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
415 chordmodifiers_block:
416 CHORDMODIFIERS notenames_body { $$ = $2; }
420 PITCHNAMES notenames_body { $$ = $2; }
425 int i = scm_ilength ($1);
427 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
428 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
429 SCM pt = ly_cdar (s);
430 scm_hashq_set_x (tab, ly_caar (s), pt);
436 lilypond_header_body:
438 $$ = ly_make_anonymous_module ();
439 THIS->lexer_->add_scope ($$);
441 | lilypond_header_body assignment {
447 HEADER '{' lilypond_header_body '}' {
448 $$ = THIS->lexer_-> remove_scope();
460 /* cont */ '=' identifier_init {
463 Should find generic way of associating input with objects.
465 Input ip = THIS->pop_spot ();
467 if (! regular_identifier_b ($1))
469 ip.warning (_ ("Identifier should have alphabetic characters only"));
472 THIS->lexer_->set_identifier ($1, $4);
475 TODO: devise standard for protection in parser.
477 The parser stack lives on the C-stack, which means that
478 all objects can be unprotected as soon as they're here.
489 $$ = $1->self_scm ();
490 scm_gc_unprotect_object ($$);
496 $$ = $1->self_scm ();
497 scm_gc_unprotect_object ($$);
499 | translator_spec_block {
503 $$ = $1->self_scm ();
504 scm_gc_unprotect_object ($$);
507 $$ = $1->self_scm ();
508 scm_gc_unprotect_object ($$);
513 | number_expression {
524 translator_spec_block:
525 TRANSLATOR '{' translator_spec_body '}'
531 translator_spec_body:
532 TRANSLATOR_IDENTIFIER {
534 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
537 $$ = Translator_def::make_scm ();
538 Translator_def*td = unsmob_translator_def ($$);
539 td->translator_group_type_ = $2;
540 td->set_spot (THIS->here_input ());
542 | translator_spec_body STRING '=' embedded_scm {
543 unsmob_translator_def ($$)->add_property_assign ($2, $4);
545 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
546 unsmob_translator_def ($$)
547 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
549 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
550 unsmob_translator_def ($$)
551 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
553 | translator_spec_body STRING REVERT embedded_scm {
554 unsmob_translator_def ($$)->add_pop_property (
555 scm_string_to_symbol ($2), $4);
557 | translator_spec_body NAME STRING {
558 unsmob_translator_def ($$)->type_name_ = $3;
560 | translator_spec_body CONSISTS STRING {
561 unsmob_translator_def ($$)->add_element ($3);
563 | translator_spec_body ALIAS STRING {
564 Translator_def*td = unsmob_translator_def ($$);
565 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
567 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
568 Translator_def*td = unsmob_translator_def($$);
569 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
570 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
571 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
573 | translator_spec_body CONSISTSEND STRING {
574 unsmob_translator_def ($$)->add_last_element ( $3);
576 | translator_spec_body ACCEPTS STRING {
577 unsmob_translator_def ($$)->set_acceptor ($3,true);
579 | translator_spec_body DENIES STRING {
580 unsmob_translator_def ($$)->set_acceptor ($3,false);
582 | translator_spec_body REMOVE STRING {
583 unsmob_translator_def ($$)->remove_element ($3);
594 /*cont*/ '{' score_body '}' {
597 if (!$$->defs_.size ())
599 Music_output_def *id =
600 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
601 $$->add_output (id ? id->clone () : new Paper_def );
610 $$->set_spot (THIS->here_input ());
611 SCM m = $1->self_scm ();
612 scm_gc_unprotect_object (m);
617 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
618 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
619 m = gh_call1 (gh_car (check_funcs), m);
624 $$ = unsmob_score ($1);
625 $$->set_spot (THIS->here_input ());
627 | score_body lilypond_header {
630 | score_body output_def {
643 music_output_def_body '}' {
645 THIS-> lexer_-> remove_scope ();
649 music_output_def_body:
651 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
656 p = dynamic_cast<Midi_def*> (id->clone ());
661 THIS->lexer_->add_scope (p->scope_);
664 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
667 p = dynamic_cast<Paper_def*> (id->clone ());
671 THIS->lexer_->add_scope (p->scope_);
674 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
675 Music_output_def * o = unsmob_music_output_def ($3);
678 THIS->lexer_->add_scope (o->scope_);
680 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
681 Music_output_def * o = unsmob_music_output_def ($3);
684 THIS->lexer_->add_scope (o->scope_);
686 | music_output_def_body assignment {
689 | music_output_def_body translator_spec_block {
690 $$->assign_translator ($2);
692 | music_output_def_body tempo_event {
694 junk this ? there already is tempo stuff in
697 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
698 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
699 Midi_def * md = dynamic_cast<Midi_def*> ($$);
701 md->set_tempo (d->get_length (), m);
703 | music_output_def_body error {
709 TEMPO steno_duration '=' bare_unsigned {
710 $$ = MY_MAKE_MUSIC("TempoEvent");
711 $$->set_mus_property ("tempo-unit", $2);
712 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
717 The representation of a list is the
721 to have efficient append.
725 $$ = scm_cons (SCM_EOL, SCM_EOL);
729 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
730 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
731 if (gh_pair_p (ly_cdr (s)))
732 gh_set_cdr_x (ly_cdr (s), c); /* append */
734 gh_set_car_x (s, c); /* set first cons */
735 gh_set_cdr_x (s, c) ; /* remember last cell */
751 | ALTERNATIVE '{' Music_list '}' {
757 REPEAT string bare_unsigned Music Alternative_music
761 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
762 if (times < scm_ilength (alts)) {
763 unsmob_music (gh_car (alts))
764 ->origin ()->warning (
765 _("More alternatives than repeats. Junking excess alternatives."));
766 alts = ly_truncate_list (times, alts);
772 proc = scm_c_eval_string ("make-repeated-music");
774 SCM mus = scm_call_1 (proc, $2);
775 scm_gc_protect_object (mus); // UGH.
776 Music *r =unsmob_music (mus);
779 r-> set_mus_property ("element", beg->self_scm ());
780 scm_gc_unprotect_object (beg->self_scm ());
782 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
784 r-> set_mus_property ("elements",alts);
785 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
788 we can not get durations and other stuff correct down the line, so we have to
789 add to the duration log here.
791 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
793 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
795 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
797 r->set_spot (*$4->origin ());
804 SEQUENTIAL '{' Music_list '}' {
805 $$ = MY_MAKE_MUSIC("SequentialMusic");
806 $$->set_mus_property ("elements", ly_car ($3));
807 $$->set_spot(THIS->here_input());
809 | '{' Music_list '}' {
810 $$ = MY_MAKE_MUSIC("SequentialMusic");
811 $$->set_mus_property ("elements", ly_car ($2));
812 $$->set_spot(THIS->here_input());
817 SIMULTANEOUS '{' Music_list '}'{
818 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
819 $$->set_mus_property ("elements", ly_car ($3));
820 $$->set_spot(THIS->here_input());
823 | '<' Music_list '>' {
824 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
825 $$->set_mus_property ("elements", ly_car ($2));
826 $$->set_spot(THIS->here_input());
831 event_chord { $$ = $1; }
832 | APPLYOUTPUT embedded_scm {
833 if (!gh_procedure_p ($2))
834 THIS->parser_error (_ ("\applycontext takes function argument"));
835 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
836 $$->set_mus_property ("procedure", $2);
837 $$->set_spot (THIS->here_input());
839 | APPLYCONTEXT embedded_scm {
840 if (!gh_procedure_p ($2))
841 THIS->parser_error (_ ("\applycontext takes function argument"));
842 $$ = MY_MAKE_MUSIC ("ApplyContext");
843 $$->set_mus_property ("procedure", $2);
844 $$->set_spot (THIS->here_input());
846 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
848 if (!gh_symbol_p ($3))
850 THIS->parser_error (_ ("Second argument must be a symbol"));
852 /* Should check # args */
853 if (!gh_procedure_p (pred))
855 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
858 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
859 m->set_mus_property ("predicate", pred);
860 m->set_mus_property ("grob-property", $3);
861 m->set_mus_property ("grob-value", $5);
866 $$ = unsmob_music ($1);
874 CONTEXT STRING Music {
875 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
877 csm->set_mus_property ("element", $3->self_scm ());
878 scm_gc_unprotect_object ($3->self_scm ());
880 csm->set_mus_property ("context-type",$2);
881 csm->set_mus_property ("context-id", scm_makfrom0str (""));
885 | AUTOCHANGE STRING Music {
886 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
887 chm->set_mus_property ("element", $3->self_scm ());
888 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
890 scm_gc_unprotect_object ($3->self_scm ());
891 chm->set_mus_property ("what", $2);
894 chm->set_spot (*$3->origin ());
899 The other version is for easier debugging of
900 Sequential_music_iterator in combination with grace notes.
903 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
904 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
905 Music *startm = unsmob_music (start);
906 Music *stopm = unsmob_music (stop);
910 stopm = stopm->clone ();
911 ms = scm_cons (stopm->self_scm (), ms);
912 scm_gc_unprotect_object (stopm->self_scm ());
914 ms = scm_cons ($2->self_scm (), ms);
915 scm_gc_unprotect_object ($2->self_scm());
917 startm = startm->clone ();
918 ms = scm_cons (startm->self_scm () , ms);
919 scm_gc_unprotect_object (startm->self_scm ());
923 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
924 seq->set_mus_property ("elements", ms);
927 $$ = MY_MAKE_MUSIC("GraceMusic");
928 $$->set_mus_property ("element", seq->self_scm ());
929 scm_gc_unprotect_object (seq->self_scm ());
931 $$ = MY_MAKE_MUSIC("GraceMusic");
932 $$->set_mus_property ("element", $2->self_scm ());
933 scm_gc_unprotect_object ($2->self_scm ());
936 | CONTEXT string '=' string Music {
937 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
939 csm->set_mus_property ("element", $5->self_scm ());
940 scm_gc_unprotect_object ($5->self_scm ());
942 csm->set_mus_property ("context-type", $2);
943 csm->set_mus_property ("context-id", $4);
954 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
956 $$= MY_MAKE_MUSIC("TimeScaledMusic");
957 $$->set_spot (THIS->pop_spot ());
960 $$->set_mus_property ("element", mp->self_scm ());
961 scm_gc_unprotect_object (mp->self_scm ());
962 $$->set_mus_property ("numerator", gh_int2scm (n));
963 $$->set_mus_property ("denominator", gh_int2scm (d));
964 $$->compress (Moment (Rational (n,d)));
967 | Repeated_music { $$ = $1; }
968 | Simultaneous_music { $$ = $1; }
969 | Sequential_music { $$ = $1; }
970 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
971 $$ = MY_MAKE_MUSIC("TransposedMusic");
973 Pitch from = *unsmob_pitch ($2);
974 Pitch to = *unsmob_pitch ($3);
976 p->transpose (interval (from, to));
977 $$->set_mus_property ("element", p->self_scm ());
978 scm_gc_unprotect_object (p->self_scm ());
980 | APPLY embedded_scm Music {
981 SCM ret = gh_call1 ($2, $3->self_scm ());
982 Music *m = unsmob_music (ret);
984 THIS->parser_error ("\\apply must return a Music");
985 m = MY_MAKE_MUSIC("Music");
990 { THIS->lexer_->push_note_state (); }
993 THIS->lexer_->pop_state ();
996 { THIS->lexer_->push_figuredbass_state (); }
999 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1000 chm->set_mus_property ("element", $3->self_scm ());
1002 scm_gc_unprotect_object ($3->self_scm());
1004 THIS->lexer_->pop_state ();
1007 { THIS->lexer_->push_chord_state (); }
1010 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1011 chm->set_mus_property ("element", $3->self_scm ());
1012 scm_gc_unprotect_object ($3->self_scm());
1015 THIS->lexer_->pop_state ();
1018 { THIS->lexer_->push_lyric_state (); }
1022 THIS->lexer_->pop_state ();
1024 | relative_music { $$ = $1; }
1025 | re_rhythmed_music { $$ = $1; }
1026 | part_combined_music { $$ = $1; }
1030 RELATIVE absolute_pitch Music {
1032 Pitch pit = *unsmob_pitch ($2);
1033 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1035 $$->set_mus_property ("element", p->self_scm ());
1036 scm_gc_unprotect_object (p->self_scm ());
1039 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1045 ADDLYRICS Music Music {
1046 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1047 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1048 scm_gc_unprotect_object ($3->self_scm ());
1049 scm_gc_unprotect_object ($2->self_scm ());
1054 part_combined_music:
1055 PARTCOMBINE STRING Music Music {
1056 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1057 p->set_mus_property ("what", $2);
1058 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1060 scm_gc_unprotect_object ($3->self_scm ());
1061 scm_gc_unprotect_object ($4->self_scm ());
1068 TRANSLATOR STRING '=' STRING {
1069 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1070 t-> set_mus_property ("change-to-type", $2);
1071 t-> set_mus_property ("change-to-id", $4);
1074 $$->set_spot (THIS->here_input ());
1080 | ONCE simple_property_def {
1082 SCM e = $2->get_mus_property ("element");
1083 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1087 simple_property_def:
1088 PROPERTY STRING '.' STRING '=' scalar {
1089 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1090 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1092 csm->set_mus_property ("element", t->self_scm ());
1093 scm_gc_unprotect_object (t->self_scm ());
1096 $$->set_spot (THIS->here_input ());
1098 csm-> set_mus_property ("context-type", $2);
1100 | PROPERTY STRING '.' STRING UNSET {
1102 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1103 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1105 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1106 csm->set_mus_property ("element", t->self_scm ());
1107 scm_gc_unprotect_object (t->self_scm ());
1110 $$->set_spot (THIS->here_input ());
1112 csm-> set_mus_property ("context-type", $2);
1114 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1116 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1117 bool itc = internal_type_checking_global_b;
1118 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1119 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1120 t->set_mus_property ("pop-first", SCM_BOOL_T);
1122 internal_type_checking_global_b = false;
1123 t->set_mus_property ("grob-property", $6);
1125 internal_type_checking_global_b = itc;
1126 t->set_mus_property ("grob-value", $8);
1128 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1129 csm->set_mus_property ("element", t->self_scm ());
1130 scm_gc_unprotect_object (t->self_scm ());
1132 $$->set_spot (THIS->here_input ());
1134 csm-> set_mus_property ("context-type", $2);
1136 | PROPERTY STRING '.' STRING OVERRIDE
1137 embedded_scm '=' embedded_scm
1143 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1144 bool itc = internal_type_checking_global_b;
1146 Music *t = MY_MAKE_MUSIC("OverrideProperty");
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);
1151 t->set_mus_property ("grob-value", $8);
1153 internal_type_checking_global_b = itc;
1155 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1156 csm->set_mus_property ("element", t->self_scm ());
1157 scm_gc_unprotect_object (t->self_scm ());
1160 $$->set_spot (THIS->here_input ());
1162 csm-> set_mus_property ("context-type", $2);
1165 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1166 Music *t = MY_MAKE_MUSIC("RevertProperty");
1168 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1169 bool itc = internal_type_checking_global_b;
1171 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1173 internal_type_checking_global_b = false;
1174 t->set_mus_property ("grob-property", $6);
1176 internal_type_checking_global_b = itc;
1178 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1179 csm->set_mus_property ("element", t->self_scm ());
1180 scm_gc_unprotect_object (t->self_scm ());
1183 $$->set_spot (THIS->here_input ());
1185 csm-> set_mus_property ("context-type", $2);
1192 | bare_int { $$ = gh_int2scm ($1); }
1193 | embedded_scm { $$ = $1; }
1194 | full_markup { $$ = $1; }
1195 | DIGIT { $$ = gh_int2scm ($1); }
1202 } /*cont */ simple_element post_events {
1203 SCM elts = $3-> get_mus_property ("elements");
1205 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1206 scm_reverse_x ($4, SCM_EOL));
1208 $3-> set_mus_property ("elements", elts);
1212 | note_chord_element
1217 chord_body optional_notemode_duration post_events
1219 SCM dur = unsmob_duration ($2)->smobbed_copy();
1220 SCM es = $1->get_mus_property ("elements");
1221 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1223 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1224 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1225 es = gh_append2 (es, postevs);
1227 $1-> set_mus_property ("elements", es);
1233 CHORD_OPEN chord_body_elements CHORD_CLOSE
1235 $$ = MY_MAKE_MUSIC("EventChord");
1236 $$->set_mus_property ("elements",
1237 scm_reverse_x ($2, SCM_EOL));
1241 chord_body_elements:
1242 /* empty */ { $$ = SCM_EOL; }
1243 | chord_body_elements chord_body_element {
1244 $$ = gh_cons ($2->self_scm(), $1);
1245 scm_gc_unprotect_object ($2->self_scm());
1250 pitch exclamations questions post_events
1252 Music * n = MY_MAKE_MUSIC("NoteEvent");
1253 n->set_mus_property ("pitch", $1);
1255 n->set_mus_property ("cautionary", SCM_BOOL_T);
1256 if ($2 % 2 || $3 % 2)
1257 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1259 SCM arts = scm_reverse_x ($4, SCM_EOL);
1260 n->set_mus_property ("articulations", arts);
1268 $$ = MY_MAKE_MUSIC("EventChord");
1269 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1270 scm_gc_unprotect_object ($1->self_scm());
1272 $$-> set_spot (THIS->here_input ());
1273 $1-> set_spot (THIS->here_input ());
1276 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1277 l->set_mus_property ("span-direction", gh_int2scm (START));
1278 l->set_spot (THIS->here_input ());
1280 $$ = MY_MAKE_MUSIC("EventChord");
1281 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1282 scm_gc_unprotect_object (l->self_scm());
1283 $$->set_spot (THIS->here_input ());
1286 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1287 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1288 l->set_spot (THIS->here_input ());
1290 $$ = MY_MAKE_MUSIC("EventChord");
1291 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1292 $$->set_spot (THIS->here_input ());
1293 scm_gc_unprotect_object (l->self_scm());
1296 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1297 $$->set_spot (THIS->here_input ());
1301 $$ = MY_MAKE_MUSIC("BarCheck");
1302 $$->set_spot (THIS->here_input ());
1305 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1307 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1308 csm->set_mus_property ("element", t->self_scm ());
1309 scm_gc_unprotect_object (t->self_scm ());
1312 $$->set_spot (THIS->here_input ());
1314 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1316 | PARTIAL duration_length {
1317 Moment m = - unsmob_duration ($2)->get_length ();
1318 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1320 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1321 sp->set_mus_property ("element", p->self_scm ());
1322 scm_gc_unprotect_object (p->self_scm ());
1325 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1330 proc = scm_c_eval_string ("make-clef-set");
1332 SCM result = scm_call_1 (proc, $2);
1333 scm_gc_protect_object (result);
1334 $$ = unsmob_music (result);
1339 proc = scm_c_eval_string ("make-time-signature-set");
1341 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1342 scm_gc_protect_object (result);
1343 $$ = unsmob_music (result);
1348 shorthand_command_req { $$ = $1; }
1349 | verbose_command_req { $$ = $1; }
1352 shorthand_command_req:
1360 $$ = MY_MAKE_MUSIC("TieEvent");
1363 Music *b= MY_MAKE_MUSIC("BeamEvent");
1364 b->set_mus_property ("span-direction", gh_int2scm (START));
1367 THIS->last_beam_start_ = b->self_scm ();
1370 Music *b= MY_MAKE_MUSIC("BeamEvent");
1371 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1375 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1378 $$ = MY_MAKE_MUSIC("PesOrFlexaEvent");
1382 verbose_command_req:
1384 Music * m = MY_MAKE_MUSIC("MarkEvent");
1388 Music *m = MY_MAKE_MUSIC("MarkEvent");
1389 m->set_mus_property ("label", $2);
1392 | SKIP duration_length {
1393 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1394 skip->set_mus_property ("duration", $2);
1402 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1405 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1406 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1408 key->set_mus_property ("pitch-alist", $3);
1409 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1410 ((Music*)key)->transpose (* unsmob_pitch ($2));
1420 | post_events post_event {
1421 $2->set_spot (THIS->here_input ());
1422 $$ = gh_cons ($2->self_scm(), $$);
1423 scm_gc_unprotect_object ($2->self_scm());
1436 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1437 s->set_mus_property ("string-number", gh_int2scm($1));
1438 s->set_spot (THIS->here_input ());
1444 event_that_take_dir:
1450 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1451 m->set_spot (THIS->here_input());
1452 m->set_mus_property ("span-direction" , gh_int2scm (START));
1456 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1457 m->set_spot (THIS->here_input());
1458 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1462 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1463 m->set_spot (THIS->here_input());
1466 | script_abbreviation {
1467 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1468 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1469 if (gh_string_p (s))
1470 a->set_mus_property ("articulation-type", s);
1471 else THIS->parser_error (_ ("Expecting string as script definition"));
1477 script_dir event_that_take_dir {
1478 $2->set_mus_property ("direction", gh_int2scm ($1));
1485 $$ = unsmob_music ($1);
1488 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1489 a->set_spot (THIS->here_input ());
1490 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1517 | NOTENAME_PITCH sup_quotes {
1518 Pitch p = *unsmob_pitch ($1);
1519 p = p.transposed (Pitch ($2,0,0));
1520 $$ = p.smobbed_copy ();
1522 | NOTENAME_PITCH sub_quotes {
1523 Pitch p =* unsmob_pitch ($1);
1524 p = p.transposed (Pitch (-$2,0,0));
1525 $$ = p.smobbed_copy ();
1537 | TONICNAME_PITCH sup_quotes {
1538 Pitch p = *unsmob_pitch ($1);
1539 p = p.transposed (Pitch ($2,0,0));
1540 $$ = p.smobbed_copy ();
1542 | TONICNAME_PITCH sub_quotes {
1543 Pitch p =* unsmob_pitch ($1);
1545 p = p.transposed (Pitch (-$2,0,0));
1546 $$ = p.smobbed_copy ();
1559 pitch_also_in_chords:
1565 PITCH embedded_scm {
1567 if (!unsmob_pitch ($2)) {
1568 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1569 $$ = Pitch ().smobbed_copy ();
1575 DURATION embedded_scm {
1577 if (!unsmob_duration ($2))
1579 THIS->parser_error (_ ("Must have duration object"));
1580 $$ = Duration ().smobbed_copy ();
1587 if (!THIS->lexer_->lyric_state_b ())
1588 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1589 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1595 if (!THIS->lexer_->lyric_state_b ())
1596 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1597 $$ = MY_MAKE_MUSIC("HyphenEvent");
1602 close_event_parens {
1604 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1611 Music * s= MY_MAKE_MUSIC("SlurEvent");
1613 s->set_spot (THIS->here_input());
1616 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1618 s->set_spot (THIS->here_input());
1621 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1623 s->set_spot (THIS->here_input());
1626 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1628 s->set_spot (THIS->here_input());
1636 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1643 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1644 s->set_spot (THIS->here_input());
1649 Music * s= MY_MAKE_MUSIC("SlurEvent");
1651 s->set_spot (THIS->here_input());
1655 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1657 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1658 s->set_spot (THIS->here_input());
1664 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1665 t->set_mus_property ("text", $1);
1666 t->set_spot (THIS->here_input ());
1670 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1671 t->set_mus_property ("text", $1);
1672 t->set_spot (THIS->here_input ());
1676 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1677 t->set_mus_property ("text", make_simple_markup ($1));
1678 t->set_spot (THIS->here_input ());
1683 Music * t = MY_MAKE_MUSIC("FingerEvent");
1684 t->set_mus_property ("digit", gh_int2scm ($1));
1685 t->set_spot (THIS->here_input ());
1690 script_abbreviation:
1692 $$ = scm_makfrom0str ("Hat");
1695 $$ = scm_makfrom0str ("Plus");
1698 $$ = scm_makfrom0str ("Dash");
1701 $$ = scm_makfrom0str ("Bar");
1704 $$ = scm_makfrom0str ("Larger");
1707 $$ = scm_makfrom0str ("Dot");
1710 $$ = scm_makfrom0str ("Underscore");
1717 | '-' { $$ = CENTER; }
1724 | pre_events open_event {
1725 $$ = gh_cons ($2->self_scm(), $$);
1726 scm_gc_unprotect_object ($2->self_scm());
1737 multiplied_duration {
1740 | verbose_duration {
1745 optional_notemode_duration:
1747 Duration dd = THIS->default_duration_;
1748 $$ = dd.smobbed_copy ();
1750 THIS->beam_check ($$);
1752 | multiplied_duration {
1754 THIS->default_duration_ = *unsmob_duration ($$);
1756 THIS->beam_check ($$);
1758 | verbose_duration {
1760 THIS->default_duration_ = *unsmob_duration ($$);
1765 bare_unsigned dots {
1767 if (!is_duration_b ($1))
1768 THIS->parser_error (_f ("not a duration: %d", $1));
1772 $$ = Duration (l, $2).smobbed_copy ();
1774 | DURATION_IDENTIFIER dots {
1775 Duration *d =unsmob_duration ($1);
1776 Duration k (d->duration_log (),d->dot_count () + $2);
1786 multiplied_duration:
1790 | multiplied_duration '*' bare_unsigned {
1791 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1793 | multiplied_duration '*' FRACTION {
1794 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1796 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1801 FRACTION { $$ = $1; }
1802 | UNSIGNED '/' UNSIGNED {
1803 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1821 | ':' bare_unsigned {
1822 if (!is_duration_b ($2))
1823 THIS->parser_error (_f ("not a duration: %d", $2));
1830 /*****************************************************************
1832 *****************************************************************/
1846 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1847 $$ = bfr->self_scm();
1848 scm_gc_unprotect_object ($$);
1851 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1852 $$ = bfr->self_scm();
1854 bfr->set_mus_property ("figure", gh_int2scm ($1));
1856 scm_gc_unprotect_object ($$);
1858 | bass_figure bass_mod {
1859 Music *m = unsmob_music ($1);
1861 SCM salter =m->get_mus_property ("alteration");
1862 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1863 m->set_mus_property ("alteration",
1864 gh_int2scm (alter + $2));
1866 m->set_mus_property ("alteration", gh_int2scm (0));
1874 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1879 | br_bass_figure ']' {
1881 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1889 | figure_list br_bass_figure {
1890 $$ = scm_cons ($2, $1);
1895 FIGURE_OPEN figure_list FIGURE_CLOSE {
1896 Music * m = MY_MAKE_MUSIC("EventChord");
1897 $2 = scm_reverse_x ($2, SCM_EOL);
1898 m->set_mus_property ("elements", $2);
1899 $$ = m->self_scm ();
1910 pitch exclamations questions optional_notemode_duration optional_rest {
1912 Input i = THIS->pop_spot ();
1913 if (!THIS->lexer_->note_state_b ())
1914 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1918 n = MY_MAKE_MUSIC("RestEvent");
1920 n = MY_MAKE_MUSIC("NoteEvent");
1922 n->set_mus_property ("pitch", $1);
1923 n->set_mus_property ("duration", $4);
1927 n->set_mus_property ("cautionary", SCM_BOOL_T);
1928 if ($2 % 2 || $3 % 2)
1929 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1931 Music *v = MY_MAKE_MUSIC("EventChord");
1932 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1933 scm_gc_unprotect_object (n->self_scm());
1939 | figure_spec optional_notemode_duration {
1940 Music * m = unsmob_music ($1);
1941 Input i = THIS->pop_spot ();
1943 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1945 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1949 | RESTNAME optional_notemode_duration {
1951 Input i = THIS->pop_spot ();
1953 if (ly_scm2string ($1) =="s") {
1955 ev = MY_MAKE_MUSIC("SkipEvent");
1958 ev = MY_MAKE_MUSIC("RestEvent");
1961 ev->set_mus_property ("duration" ,$2);
1963 Music * velt = MY_MAKE_MUSIC("EventChord");
1964 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1969 | MULTI_MEASURE_REST optional_notemode_duration {
1974 proc = scm_c_eval_string ("make-multi-measure-rest");
1976 SCM mus = scm_call_2 (proc, $2,
1977 make_input (THIS->here_input()));
1978 scm_gc_protect_object (mus);
1979 $$ = unsmob_music (mus);
1981 | STRING optional_notemode_duration {
1982 Input i = THIS->pop_spot ();
1984 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1985 lreq->set_mus_property ("text", $1);
1986 lreq->set_mus_property ("duration",$2);
1988 Music * velt = MY_MAKE_MUSIC("EventChord");
1989 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1996 if (!THIS->lexer_->chord_state_b ())
1997 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1998 $$ = unsmob_music ($1);
2003 steno_tonic_pitch optional_notemode_duration {
2004 $$ = make_chord ($1, $2, SCM_EOL);
2006 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2007 SCM its = scm_reverse_x ($4, SCM_EOL);
2008 $$ = make_chord ($1, $2, gh_cons ($3, its));
2016 | chord_items chord_item {
2017 $$ = gh_cons ($2, $$);
2023 $$ = ly_symbol2scm ("chord-colon");
2026 $$ = ly_symbol2scm ("chord-caret");
2028 | CHORD_SLASH steno_tonic_pitch {
2029 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2031 | CHORD_BASS steno_tonic_pitch {
2032 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2041 $$ = scm_reverse_x ($1, SCM_EOL);
2049 step_number { $$ = gh_cons ($1, SCM_EOL); }
2050 | step_numbers '.' step_number {
2051 $$ = gh_cons ($3, $$);
2057 $$ = make_chord_step ($1, 0);
2059 | bare_unsigned '+' {
2060 $$ = make_chord_step ($1, 1);
2062 | bare_unsigned CHORD_MINUS {
2063 $$ = make_chord_step ($1,-1);
2071 number_expression '+' number_term {
2072 $$ = scm_sum ($1, $3);
2074 | number_expression '-' number_term {
2075 $$ = scm_difference ($1, $3);
2084 | number_factor '*' number_factor {
2085 $$ = scm_product ($1, $3);
2087 | number_factor '/' number_factor {
2088 $$ = scm_divide ($1, $3);
2093 '-' number_factor { /* %prec UNARY_MINUS */
2094 $$ = scm_difference ($2, SCM_UNDEFINED);
2102 $$ = gh_int2scm ($1);
2107 | NUMBER_IDENTIFIER {
2110 | REAL NUMBER_IDENTIFIER {
2111 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2113 | UNSIGNED NUMBER_IDENTIFIER {
2114 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2130 if (scm_integer_p ($1) == SCM_BOOL_T)
2132 int k = gh_scm2int ($1);
2136 THIS->parser_error (_ ("need integer number arg"));
2150 | STRING_IDENTIFIER {
2153 | string '+' string {
2154 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2161 | exclamations '!' { $$ ++; }
2166 | questions '?' { $$ ++; }
2176 { THIS->lexer_->push_markup_state (); }
2179 THIS->lexer_->pop_state ();
2185 $$ = make_simple_markup ($1);
2187 | MARKUP_HEAD_MARKUP0 markup {
2188 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2190 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2191 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2193 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2194 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2199 | MARKUP_HEAD_LIST0 markup_list {
2200 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2202 | MARKUP_HEAD_SCM0 embedded_scm {
2203 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2205 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2206 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2208 | MARKUP_IDENTIFIER {
2215 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2219 '{' markup_list_body '}' {
2222 line = scm_c_eval_string ("line-markup");
2224 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2229 /**/ { $$ = SCM_EOL; }
2230 | markup_list_body markup {
2231 $$ = gh_cons ($2, $1) ;
2239 My_lily_parser::set_yydebug (bool )
2246 extern My_lily_parser * current_parser;
2249 My_lily_parser::do_yyparse ()
2251 current_parser = this;;
2252 yyparse ((void*)this);
2257 Should make this optional? It will also complain when you do
2261 which is entirely legitimate.
2263 Or we can scrap it. Barchecks should detect wrong durations, and
2264 skipTypesetting speeds it up a lot.
2268 My_lily_parser::beam_check (SCM dur)
2270 Duration *d = unsmob_duration (dur);
2271 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2273 Music * m = unsmob_music (last_beam_start_);
2274 m->origin ()->warning (_("Suspect duration found following this beam"));
2276 last_beam_start_ = SCM_EOL;
2284 return gh_pair_p (x)
2285 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2288 It is a little strange, to have this function in this file, but
2289 otherwise, we have to import music classes into the lexer.
2293 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2295 if (gh_string_p (sid)) {
2297 return STRING_IDENTIFIER;
2298 } else if (gh_number_p (sid)) {
2300 return NUMBER_IDENTIFIER;
2301 } else if (unsmob_translator_def (sid)) {
2302 *destination = unsmob_translator_def (sid)->clone_scm();
2303 return TRANSLATOR_IDENTIFIER;
2304 } else if (unsmob_score (sid)) {
2305 Score *sc = new Score (*unsmob_score (sid));
2306 *destination =sc->self_scm ();
2307 return SCORE_IDENTIFIER;
2308 } else if (Music * mus =unsmob_music (sid)) {
2309 *destination = unsmob_music (sid)->clone ()->self_scm();
2310 unsmob_music (*destination)->
2311 set_mus_property ("origin", make_input (last_input_));
2312 return dynamic_cast<Event*> (mus)
2313 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2314 } else if (unsmob_duration (sid)) {
2315 *destination = unsmob_duration (sid)->smobbed_copy();
2316 return DURATION_IDENTIFIER;
2317 } else if (unsmob_music_output_def (sid)) {
2318 Music_output_def *p = unsmob_music_output_def (sid);
2321 *destination = p->self_scm();
2322 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2323 } else if (new_markup_p (sid)) {
2325 return MARKUP_IDENTIFIER;