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_SCM2
312 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
314 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
315 %type <scm> markup markup_line markup_list markup_list_body full_markup
317 %type <outputdef> output_def
318 %type <scm> lilypond_header lilypond_header_body
319 %type <music> open_event_parens close_event_parens open_event close_event
320 %type <music> event_with_dir event_that_take_dir verbose_event
321 %type <i> sub_quotes sup_quotes
322 %type <music> simple_element event_chord command_element Simple_music Composite_music
323 %type <music> Repeated_music
324 %type <scm> Alternative_music
325 %type <i> tremolo_type
326 %type <i> bare_int bare_unsigned
328 %type <scm> identifier_init
330 %type <music> note_chord_element chord_body chord_body_element
331 %type <scm> chord_body_elements
332 %type <scm> steno_duration optional_notemode_duration multiplied_duration
333 %type <scm> verbose_duration
335 %type <scm> pre_events post_events
336 %type <music> gen_text_def
337 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
338 %type <scm> explicit_pitch steno_tonic_pitch
340 /* %type <scm> chord_additions chord_subtractions chord_notes chord_step */
341 /* %type <music> chord */
342 /* %type <scm> chord_note chord_inversion chord_bass */
343 %type <scm> duration_length fraction
345 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
347 %type <scm> embedded_scm scalar
348 %type <music> Music Sequential_music Simultaneous_music
349 %type <music> relative_music re_rhythmed_music part_combined_music
350 %type <music> property_def translator_change simple_property_def
351 %type <scm> Music_list
352 %type <outputdef> music_output_def_body
353 %type <music> shorthand_command_req
354 %type <music> post_event
355 %type <music> command_req verbose_command_req
356 %type <music> extender_req
357 %type <music> hyphen_req
358 %type <music> string_event
359 %type <scm> string bare_number number_expression number_term number_factor
360 %type <score> score_block score_body
362 %type <scm> translator_spec_block translator_spec_body
363 %type <music> tempo_event
364 %type <scm> notenames_body notenames_block chordmodifiers_block
365 %type <scm> script_abbreviation
371 /* We don't assign precedence to / and *, because we might need varied
372 prec levels in different prods */
378 lilypond: /* empty */
379 | lilypond toplevel_expression {}
380 | lilypond assignment { }
382 THIS->error_level_ = 1;
385 THIS->error_level_ = 1;
391 THIS->lexer_->pitchname_tab_ = $1;
393 | chordmodifiers_block {
394 THIS->lexer_->chordmodifier_tab_ = $1;
397 THIS->input_file_->header_ = $1;
400 THIS->input_file_->scores_.push ($1);
403 if (dynamic_cast<Paper_def*> ($1))
404 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
405 else if (dynamic_cast<Midi_def*> ($1))
406 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
416 chordmodifiers_block:
417 CHORDMODIFIERS notenames_body { $$ = $2; }
421 PITCHNAMES notenames_body { $$ = $2; }
426 int i = scm_ilength ($1);
428 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
429 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
430 SCM pt = ly_cdar (s);
431 scm_hashq_set_x (tab, ly_caar (s), pt);
437 lilypond_header_body:
439 $$ = ly_make_anonymous_module ();
440 THIS->lexer_->add_scope ($$);
442 | lilypond_header_body assignment {
448 HEADER '{' lilypond_header_body '}' {
449 $$ = THIS->lexer_-> remove_scope();
461 /* cont */ '=' identifier_init {
464 Should find generic way of associating input with objects.
466 Input ip = THIS->pop_spot ();
468 if (! regular_identifier_b ($1))
470 ip.warning (_ ("Identifier should have alphabetic characters only"));
473 THIS->lexer_->set_identifier ($1, $4);
476 TODO: devise standard for protection in parser.
478 The parser stack lives on the C-stack, which means that
479 all objects can be unprotected as soon as they're here.
490 $$ = $1->self_scm ();
491 scm_gc_unprotect_object ($$);
497 $$ = $1->self_scm ();
498 scm_gc_unprotect_object ($$);
500 | translator_spec_block {
504 $$ = $1->self_scm ();
505 scm_gc_unprotect_object ($$);
508 $$ = $1->self_scm ();
509 scm_gc_unprotect_object ($$);
514 | number_expression {
525 translator_spec_block:
526 TRANSLATOR '{' translator_spec_body '}'
532 translator_spec_body:
533 TRANSLATOR_IDENTIFIER {
535 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
538 $$ = Translator_def::make_scm ();
539 Translator_def*td = unsmob_translator_def ($$);
540 td->translator_group_type_ = $2;
541 td->set_spot (THIS->here_input ());
543 | translator_spec_body STRING '=' embedded_scm {
544 unsmob_translator_def ($$)->add_property_assign ($2, $4);
546 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
547 unsmob_translator_def ($$)
548 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
550 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
551 unsmob_translator_def ($$)
552 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
554 | translator_spec_body STRING REVERT embedded_scm {
555 unsmob_translator_def ($$)->add_pop_property (
556 scm_string_to_symbol ($2), $4);
558 | translator_spec_body NAME STRING {
559 unsmob_translator_def ($$)->type_name_ = $3;
561 | translator_spec_body CONSISTS STRING {
562 unsmob_translator_def ($$)->add_element ($3);
564 | translator_spec_body ALIAS STRING {
565 Translator_def*td = unsmob_translator_def ($$);
566 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
568 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
569 Translator_def*td = unsmob_translator_def($$);
570 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
571 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
572 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
574 | translator_spec_body CONSISTSEND STRING {
575 unsmob_translator_def ($$)->add_last_element ( $3);
577 | translator_spec_body ACCEPTS STRING {
578 unsmob_translator_def ($$)->set_acceptor ($3,true);
580 | translator_spec_body DENIES STRING {
581 unsmob_translator_def ($$)->set_acceptor ($3,false);
583 | translator_spec_body REMOVE STRING {
584 unsmob_translator_def ($$)->remove_element ($3);
595 /*cont*/ '{' score_body '}' {
598 if (!$$->defs_.size ())
600 Music_output_def *id =
601 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
602 $$->add_output (id ? id->clone () : new Paper_def );
611 $$->set_spot (THIS->here_input ());
612 SCM m = $1->self_scm ();
613 scm_gc_unprotect_object (m);
618 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
619 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
620 m = gh_call1 (gh_car (check_funcs), m);
625 $$ = unsmob_score ($1);
626 $$->set_spot (THIS->here_input ());
628 | score_body lilypond_header {
631 | score_body output_def {
644 music_output_def_body '}' {
646 THIS-> lexer_-> remove_scope ();
650 music_output_def_body:
652 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
657 p = dynamic_cast<Midi_def*> (id->clone ());
662 THIS->lexer_->add_scope (p->scope_);
665 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
668 p = dynamic_cast<Paper_def*> (id->clone ());
672 THIS->lexer_->add_scope (p->scope_);
675 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
676 Music_output_def * o = unsmob_music_output_def ($3);
679 THIS->lexer_->add_scope (o->scope_);
681 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
682 Music_output_def * o = unsmob_music_output_def ($3);
685 THIS->lexer_->add_scope (o->scope_);
687 | music_output_def_body assignment {
690 | music_output_def_body translator_spec_block {
691 $$->assign_translator ($2);
693 | music_output_def_body tempo_event {
695 junk this ? there already is tempo stuff in
698 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
699 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
700 Midi_def * md = dynamic_cast<Midi_def*> ($$);
702 md->set_tempo (d->get_length (), m);
704 | music_output_def_body error {
710 TEMPO steno_duration '=' bare_unsigned {
711 $$ = MY_MAKE_MUSIC("MetronomeChangeEvent");
712 $$->set_mus_property ("tempo-unit", $2);
713 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
718 The representation of a list is the
722 to have efficient append.
726 $$ = scm_cons (SCM_EOL, SCM_EOL);
730 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
731 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
732 if (gh_pair_p (ly_cdr (s)))
733 gh_set_cdr_x (ly_cdr (s), c); /* append */
735 gh_set_car_x (s, c); /* set first cons */
736 gh_set_cdr_x (s, c) ; /* remember last cell */
752 | ALTERNATIVE '{' Music_list '}' {
758 REPEAT string bare_unsigned Music Alternative_music
762 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
763 if (times < scm_ilength (alts)) {
764 unsmob_music (gh_car (alts))
765 ->origin ()->warning (
766 _("More alternatives than repeats. Junking excess alternatives."));
767 alts = ly_truncate_list (times, alts);
773 proc = scm_c_eval_string ("make-repeated-music");
775 SCM mus = scm_call_1 (proc, $2);
776 scm_gc_protect_object (mus); // UGH.
777 Music *r =unsmob_music (mus);
780 r-> set_mus_property ("element", beg->self_scm ());
781 scm_gc_unprotect_object (beg->self_scm ());
783 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
785 r-> set_mus_property ("elements",alts);
786 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
789 we can not get durations and other stuff correct down the line, so we have to
790 add to the duration log here.
792 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
794 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
796 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
798 r->set_spot (*$4->origin ());
805 SEQUENTIAL '{' Music_list '}' {
806 $$ = MY_MAKE_MUSIC("SequentialMusic");
807 $$->set_mus_property ("elements", ly_car ($3));
808 $$->set_spot(THIS->here_input());
810 | '{' Music_list '}' {
811 $$ = MY_MAKE_MUSIC("SequentialMusic");
812 $$->set_mus_property ("elements", ly_car ($2));
813 $$->set_spot(THIS->here_input());
818 SIMULTANEOUS '{' Music_list '}'{
819 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
820 $$->set_mus_property ("elements", ly_car ($3));
821 $$->set_spot(THIS->here_input());
824 | '<' Music_list '>' {
825 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
826 $$->set_mus_property ("elements", ly_car ($2));
827 $$->set_spot(THIS->here_input());
832 event_chord { $$ = $1; }
833 | APPLYOUTPUT embedded_scm {
834 if (!gh_procedure_p ($2))
835 THIS->parser_error (_ ("\applycontext takes function argument"));
836 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
837 $$->set_mus_property ("procedure", $2);
838 $$->set_spot (THIS->here_input());
840 | APPLYCONTEXT embedded_scm {
841 if (!gh_procedure_p ($2))
842 THIS->parser_error (_ ("\applycontext takes function argument"));
843 $$ = MY_MAKE_MUSIC ("ApplyContext");
844 $$->set_mus_property ("procedure", $2);
845 $$->set_spot (THIS->here_input());
847 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
849 if (!gh_symbol_p ($3))
851 THIS->parser_error (_ ("Second argument must be a symbol"));
853 /* Should check # args */
854 if (!gh_procedure_p (pred))
856 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
859 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
860 m->set_mus_property ("predicate", pred);
861 m->set_mus_property ("grob-property", $3);
862 m->set_mus_property ("grob-value", $5);
867 $$ = unsmob_music ($1);
875 CONTEXT STRING Music {
876 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
878 csm->set_mus_property ("element", $3->self_scm ());
879 scm_gc_unprotect_object ($3->self_scm ());
881 csm->set_mus_property ("context-type",$2);
882 csm->set_mus_property ("context-id", scm_makfrom0str (""));
886 | AUTOCHANGE STRING Music {
887 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
888 chm->set_mus_property ("element", $3->self_scm ());
889 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
891 scm_gc_unprotect_object ($3->self_scm ());
892 chm->set_mus_property ("what", $2);
895 chm->set_spot (*$3->origin ());
900 The other version is for easier debugging of
901 Sequential_music_iterator in combination with grace notes.
904 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
905 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
906 Music *startm = unsmob_music (start);
907 Music *stopm = unsmob_music (stop);
911 stopm = stopm->clone ();
912 ms = scm_cons (stopm->self_scm (), ms);
913 scm_gc_unprotect_object (stopm->self_scm ());
915 ms = scm_cons ($2->self_scm (), ms);
916 scm_gc_unprotect_object ($2->self_scm());
918 startm = startm->clone ();
919 ms = scm_cons (startm->self_scm () , ms);
920 scm_gc_unprotect_object (startm->self_scm ());
924 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
925 seq->set_mus_property ("elements", ms);
928 $$ = MY_MAKE_MUSIC("GraceMusic");
929 $$->set_mus_property ("element", seq->self_scm ());
930 scm_gc_unprotect_object (seq->self_scm ());
932 $$ = MY_MAKE_MUSIC("GraceMusic");
933 $$->set_mus_property ("element", $2->self_scm ());
934 scm_gc_unprotect_object ($2->self_scm ());
937 | CONTEXT string '=' string Music {
938 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
940 csm->set_mus_property ("element", $5->self_scm ());
941 scm_gc_unprotect_object ($5->self_scm ());
943 csm->set_mus_property ("context-type", $2);
944 csm->set_mus_property ("context-id", $4);
955 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
957 $$= MY_MAKE_MUSIC("TimeScaledMusic");
958 $$->set_spot (THIS->pop_spot ());
961 $$->set_mus_property ("element", mp->self_scm ());
962 scm_gc_unprotect_object (mp->self_scm ());
963 $$->set_mus_property ("numerator", gh_int2scm (n));
964 $$->set_mus_property ("denominator", gh_int2scm (d));
965 $$->compress (Moment (Rational (n,d)));
968 | Repeated_music { $$ = $1; }
969 | Simultaneous_music { $$ = $1; }
970 | Sequential_music { $$ = $1; }
971 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
972 $$ = MY_MAKE_MUSIC("TransposedMusic");
974 Pitch from = *unsmob_pitch ($2);
975 Pitch to = *unsmob_pitch ($3);
977 p->transpose (interval (from, to));
978 $$->set_mus_property ("element", p->self_scm ());
979 scm_gc_unprotect_object (p->self_scm ());
981 | APPLY embedded_scm Music {
982 SCM ret = gh_call1 ($2, $3->self_scm ());
983 Music *m = unsmob_music (ret);
985 THIS->parser_error ("\\apply must return a Music");
986 m = MY_MAKE_MUSIC("Music");
991 { THIS->lexer_->push_note_state (); }
994 THIS->lexer_->pop_state ();
997 { THIS->lexer_->push_figuredbass_state (); }
1000 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1001 chm->set_mus_property ("element", $3->self_scm ());
1003 scm_gc_unprotect_object ($3->self_scm());
1005 THIS->lexer_->pop_state ();
1008 { THIS->lexer_->push_chord_state (); }
1011 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1012 chm->set_mus_property ("element", $3->self_scm ());
1013 scm_gc_unprotect_object ($3->self_scm());
1016 THIS->lexer_->pop_state ();
1019 { THIS->lexer_->push_lyric_state (); }
1023 THIS->lexer_->pop_state ();
1025 | relative_music { $$ = $1; }
1026 | re_rhythmed_music { $$ = $1; }
1027 | part_combined_music { $$ = $1; }
1031 RELATIVE absolute_pitch Music {
1033 Pitch pit = *unsmob_pitch ($2);
1034 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1036 $$->set_mus_property ("element", p->self_scm ());
1037 scm_gc_unprotect_object (p->self_scm ());
1040 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1046 ADDLYRICS Music Music {
1047 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1048 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1049 scm_gc_unprotect_object ($3->self_scm ());
1050 scm_gc_unprotect_object ($2->self_scm ());
1055 part_combined_music:
1056 PARTCOMBINE STRING Music Music {
1057 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1058 p->set_mus_property ("what", $2);
1059 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1061 scm_gc_unprotect_object ($3->self_scm ());
1062 scm_gc_unprotect_object ($4->self_scm ());
1069 TRANSLATOR STRING '=' STRING {
1070 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1071 t-> set_mus_property ("change-to-type", $2);
1072 t-> set_mus_property ("change-to-id", $4);
1075 $$->set_spot (THIS->here_input ());
1081 | ONCE simple_property_def {
1083 SCM e = $2->get_mus_property ("element");
1084 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1088 simple_property_def:
1089 PROPERTY STRING '.' STRING '=' scalar {
1090 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1091 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1093 csm->set_mus_property ("element", t->self_scm ());
1094 scm_gc_unprotect_object (t->self_scm ());
1097 $$->set_spot (THIS->here_input ());
1099 csm-> set_mus_property ("context-type", $2);
1101 | PROPERTY STRING '.' STRING UNSET {
1103 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1104 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1106 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1107 csm->set_mus_property ("element", t->self_scm ());
1108 scm_gc_unprotect_object (t->self_scm ());
1111 $$->set_spot (THIS->here_input ());
1113 csm-> set_mus_property ("context-type", $2);
1115 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1117 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1118 bool itc = internal_type_checking_global_b;
1119 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1120 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1121 t->set_mus_property ("pop-first", SCM_BOOL_T);
1123 internal_type_checking_global_b = false;
1124 t->set_mus_property ("grob-property", $6);
1126 internal_type_checking_global_b = itc;
1127 t->set_mus_property ("grob-value", $8);
1129 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1130 csm->set_mus_property ("element", t->self_scm ());
1131 scm_gc_unprotect_object (t->self_scm ());
1133 $$->set_spot (THIS->here_input ());
1135 csm-> set_mus_property ("context-type", $2);
1137 | PROPERTY STRING '.' STRING OVERRIDE
1138 embedded_scm '=' embedded_scm
1144 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1145 bool itc = internal_type_checking_global_b;
1147 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1148 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1150 internal_type_checking_global_b = false;
1151 t->set_mus_property ("grob-property", $6);
1152 t->set_mus_property ("grob-value", $8);
1154 internal_type_checking_global_b = itc;
1156 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1157 csm->set_mus_property ("element", t->self_scm ());
1158 scm_gc_unprotect_object (t->self_scm ());
1161 $$->set_spot (THIS->here_input ());
1163 csm-> set_mus_property ("context-type", $2);
1166 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1167 Music *t = MY_MAKE_MUSIC("RevertProperty");
1169 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1170 bool itc = internal_type_checking_global_b;
1172 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1174 internal_type_checking_global_b = false;
1175 t->set_mus_property ("grob-property", $6);
1177 internal_type_checking_global_b = itc;
1179 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1180 csm->set_mus_property ("element", t->self_scm ());
1181 scm_gc_unprotect_object (t->self_scm ());
1184 $$->set_spot (THIS->here_input ());
1186 csm-> set_mus_property ("context-type", $2);
1193 | bare_int { $$ = gh_int2scm ($1); }
1194 | embedded_scm { $$ = $1; }
1195 | full_markup { $$ = $1; }
1196 | DIGIT { $$ = gh_int2scm ($1); }
1203 } /*cont */ simple_element post_events {
1204 SCM elts = $3-> get_mus_property ("elements");
1206 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1207 scm_reverse_x ($4, SCM_EOL));
1209 $3-> set_mus_property ("elements", elts);
1213 | note_chord_element
1218 chord_body optional_notemode_duration post_events
1220 SCM dur = unsmob_duration ($2)->smobbed_copy();
1221 SCM es = $1->get_mus_property ("elements");
1222 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1224 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1225 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1226 es = gh_append2 (es, postevs);
1228 $1-> set_mus_property ("elements", es);
1234 CHORD_OPEN chord_body_elements CHORD_CLOSE
1236 $$ = MY_MAKE_MUSIC("EventChord");
1237 $$->set_mus_property ("elements",
1238 scm_reverse_x ($2, SCM_EOL));
1242 chord_body_elements:
1243 /* empty */ { $$ = SCM_EOL; }
1244 | chord_body_elements chord_body_element {
1245 $$ = gh_cons ($2->self_scm(), $1);
1246 scm_gc_unprotect_object ($2->self_scm());
1251 pitch exclamations questions post_events
1253 Music * n = MY_MAKE_MUSIC("NoteEvent");
1254 n->set_mus_property ("pitch", $1);
1256 n->set_mus_property ("cautionary", SCM_BOOL_T);
1257 if ($2 % 2 || $3 % 2)
1258 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1260 SCM arts = scm_reverse_x ($4, SCM_EOL);
1261 n->set_mus_property ("articulations", arts);
1269 $$ = MY_MAKE_MUSIC("EventChord");
1270 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1271 scm_gc_unprotect_object ($1->self_scm());
1273 $$-> set_spot (THIS->here_input ());
1274 $1-> set_spot (THIS->here_input ());
1277 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1278 l->set_mus_property ("span-direction", gh_int2scm (START));
1279 l->set_spot (THIS->here_input ());
1281 $$ = MY_MAKE_MUSIC("EventChord");
1282 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1283 scm_gc_unprotect_object (l->self_scm());
1284 $$->set_spot (THIS->here_input ());
1287 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1288 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1289 l->set_spot (THIS->here_input ());
1291 $$ = MY_MAKE_MUSIC("EventChord");
1292 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1293 $$->set_spot (THIS->here_input ());
1294 scm_gc_unprotect_object (l->self_scm());
1297 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1298 $$->set_spot (THIS->here_input ());
1302 $$ = MY_MAKE_MUSIC("BarCheck");
1303 $$->set_spot (THIS->here_input ());
1306 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1308 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1309 csm->set_mus_property ("element", t->self_scm ());
1310 scm_gc_unprotect_object (t->self_scm ());
1313 $$->set_spot (THIS->here_input ());
1315 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1317 | PARTIAL duration_length {
1318 Moment m = - unsmob_duration ($2)->get_length ();
1319 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1321 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1322 sp->set_mus_property ("element", p->self_scm ());
1323 scm_gc_unprotect_object (p->self_scm ());
1326 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1331 proc = scm_c_eval_string ("make-clef-set");
1333 SCM result = scm_call_1 (proc, $2);
1334 scm_gc_protect_object (result);
1335 $$ = unsmob_music (result);
1340 proc = scm_c_eval_string ("make-time-signature-set");
1342 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1343 scm_gc_protect_object (result);
1344 $$ = unsmob_music (result);
1349 shorthand_command_req { $$ = $1; }
1350 | verbose_command_req { $$ = $1; }
1353 shorthand_command_req:
1361 $$ = MY_MAKE_MUSIC("TieEvent");
1364 Music *b= MY_MAKE_MUSIC("BeamEvent");
1365 b->set_mus_property ("span-direction", gh_int2scm (START));
1368 THIS->last_beam_start_ = b->self_scm ();
1371 Music *b= MY_MAKE_MUSIC("BeamEvent");
1372 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1376 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1379 $$ = MY_MAKE_MUSIC("PesOrFlexaEvent");
1383 verbose_command_req:
1385 Music * m = MY_MAKE_MUSIC("MarkEvent");
1389 Music *m = MY_MAKE_MUSIC("MarkEvent");
1390 m->set_mus_property ("label", $2);
1393 | SKIP duration_length {
1394 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1395 skip->set_mus_property ("duration", $2);
1403 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1406 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1407 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1409 key->set_mus_property ("pitch-alist", $3);
1410 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1411 ((Music*)key)->transpose (* unsmob_pitch ($2));
1421 | post_events post_event {
1422 $2->set_spot (THIS->here_input ());
1423 $$ = gh_cons ($2->self_scm(), $$);
1424 scm_gc_unprotect_object ($2->self_scm());
1437 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1438 s->set_mus_property ("string-number", gh_int2scm($1));
1439 s->set_spot (THIS->here_input ());
1445 event_that_take_dir:
1451 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1452 m->set_spot (THIS->here_input());
1453 m->set_mus_property ("span-direction" , gh_int2scm (START));
1457 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1458 m->set_spot (THIS->here_input());
1459 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1463 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1464 m->set_spot (THIS->here_input());
1467 | script_abbreviation {
1468 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1469 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1470 if (gh_string_p (s))
1471 a->set_mus_property ("articulation-type", s);
1472 else THIS->parser_error (_ ("Expecting string as script definition"));
1478 script_dir event_that_take_dir {
1479 $2->set_mus_property ("direction", gh_int2scm ($1));
1486 $$ = unsmob_music ($1);
1489 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1490 a->set_spot (THIS->here_input ());
1491 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1518 | NOTENAME_PITCH sup_quotes {
1519 Pitch p = *unsmob_pitch ($1);
1520 p = p.transposed (Pitch ($2,0,0));
1521 $$ = p.smobbed_copy ();
1523 | NOTENAME_PITCH sub_quotes {
1524 Pitch p =* unsmob_pitch ($1);
1525 p = p.transposed (Pitch (-$2,0,0));
1526 $$ = p.smobbed_copy ();
1538 | TONICNAME_PITCH sup_quotes {
1539 Pitch p = *unsmob_pitch ($1);
1540 p = p.transposed (Pitch ($2,0,0));
1541 $$ = p.smobbed_copy ();
1543 | TONICNAME_PITCH sub_quotes {
1544 Pitch p =* unsmob_pitch ($1);
1546 p = p.transposed (Pitch (-$2,0,0));
1547 $$ = p.smobbed_copy ();
1560 pitch_also_in_chords:
1566 PITCH embedded_scm {
1568 if (!unsmob_pitch ($2)) {
1569 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1570 $$ = Pitch ().smobbed_copy ();
1576 DURATION embedded_scm {
1578 if (!unsmob_duration ($2))
1580 THIS->parser_error (_ ("Must have duration object"));
1581 $$ = Duration ().smobbed_copy ();
1588 if (!THIS->lexer_->lyric_state_b ())
1589 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1590 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1596 if (!THIS->lexer_->lyric_state_b ())
1597 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1598 $$ = MY_MAKE_MUSIC("HyphenEvent");
1603 close_event_parens {
1605 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1612 Music * s= MY_MAKE_MUSIC("SlurEvent");
1614 s->set_spot (THIS->here_input());
1617 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1619 s->set_spot (THIS->here_input());
1622 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1624 s->set_spot (THIS->here_input());
1627 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1629 s->set_spot (THIS->here_input());
1637 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1644 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1645 s->set_spot (THIS->here_input());
1650 Music * s= MY_MAKE_MUSIC("SlurEvent");
1652 s->set_spot (THIS->here_input());
1656 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1658 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1659 s->set_spot (THIS->here_input());
1665 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1666 t->set_mus_property ("text", $1);
1667 t->set_spot (THIS->here_input ());
1671 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1672 t->set_mus_property ("text", $1);
1673 t->set_spot (THIS->here_input ());
1677 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1678 t->set_mus_property ("text", make_simple_markup ($1));
1679 t->set_spot (THIS->here_input ());
1684 Music * t = MY_MAKE_MUSIC("FingerEvent");
1685 t->set_mus_property ("digit", gh_int2scm ($1));
1686 t->set_spot (THIS->here_input ());
1691 script_abbreviation:
1693 $$ = scm_makfrom0str ("Hat");
1696 $$ = scm_makfrom0str ("Plus");
1699 $$ = scm_makfrom0str ("Dash");
1702 $$ = scm_makfrom0str ("Bar");
1705 $$ = scm_makfrom0str ("Larger");
1708 $$ = scm_makfrom0str ("Dot");
1711 $$ = scm_makfrom0str ("Underscore");
1718 | '-' { $$ = CENTER; }
1725 | pre_events open_event {
1726 $$ = gh_cons ($2->self_scm(), $$);
1727 scm_gc_unprotect_object ($2->self_scm());
1738 multiplied_duration {
1741 | verbose_duration {
1746 optional_notemode_duration:
1748 Duration dd = THIS->default_duration_;
1749 $$ = dd.smobbed_copy ();
1751 THIS->beam_check ($$);
1753 | multiplied_duration {
1755 THIS->default_duration_ = *unsmob_duration ($$);
1757 THIS->beam_check ($$);
1759 | verbose_duration {
1761 THIS->default_duration_ = *unsmob_duration ($$);
1766 bare_unsigned dots {
1768 if (!is_duration_b ($1))
1769 THIS->parser_error (_f ("not a duration: %d", $1));
1773 $$ = Duration (l, $2).smobbed_copy ();
1775 | DURATION_IDENTIFIER dots {
1776 Duration *d =unsmob_duration ($1);
1777 Duration k (d->duration_log (),d->dot_count () + $2);
1787 multiplied_duration:
1791 | multiplied_duration '*' bare_unsigned {
1792 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1794 | multiplied_duration '*' FRACTION {
1795 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1797 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1802 FRACTION { $$ = $1; }
1803 | UNSIGNED '/' UNSIGNED {
1804 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1822 | ':' bare_unsigned {
1823 if (!is_duration_b ($2))
1824 THIS->parser_error (_f ("not a duration: %d", $2));
1831 /*****************************************************************
1833 *****************************************************************/
1847 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1848 $$ = bfr->self_scm();
1849 scm_gc_unprotect_object ($$);
1852 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1853 $$ = bfr->self_scm();
1855 bfr->set_mus_property ("figure", gh_int2scm ($1));
1857 scm_gc_unprotect_object ($$);
1859 | bass_figure bass_mod {
1860 Music *m = unsmob_music ($1);
1862 SCM salter =m->get_mus_property ("alteration");
1863 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1864 m->set_mus_property ("alteration",
1865 gh_int2scm (alter + $2));
1867 m->set_mus_property ("alteration", gh_int2scm (0));
1875 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1880 | br_bass_figure ']' {
1882 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1890 | figure_list br_bass_figure {
1891 $$ = scm_cons ($2, $1);
1896 FIGURE_OPEN figure_list FIGURE_CLOSE {
1897 Music * m = MY_MAKE_MUSIC("EventChord");
1898 $2 = scm_reverse_x ($2, SCM_EOL);
1899 m->set_mus_property ("elements", $2);
1900 $$ = m->self_scm ();
1911 pitch exclamations questions optional_notemode_duration optional_rest {
1913 Input i = THIS->pop_spot ();
1914 if (!THIS->lexer_->note_state_b ())
1915 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1919 n = MY_MAKE_MUSIC("RestEvent");
1921 n = MY_MAKE_MUSIC("NoteEvent");
1923 n->set_mus_property ("pitch", $1);
1924 n->set_mus_property ("duration", $4);
1928 n->set_mus_property ("cautionary", SCM_BOOL_T);
1929 if ($2 % 2 || $3 % 2)
1930 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1932 Music *v = MY_MAKE_MUSIC("EventChord");
1933 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1934 scm_gc_unprotect_object (n->self_scm());
1940 | figure_spec optional_notemode_duration {
1941 Music * m = unsmob_music ($1);
1942 Input i = THIS->pop_spot ();
1944 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1946 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1950 | RESTNAME optional_notemode_duration {
1952 Input i = THIS->pop_spot ();
1954 if (ly_scm2string ($1) =="s") {
1956 ev = MY_MAKE_MUSIC("SkipEvent");
1959 ev = MY_MAKE_MUSIC("RestEvent");
1962 ev->set_mus_property ("duration" ,$2);
1964 Music * velt = MY_MAKE_MUSIC("EventChord");
1965 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1970 | MULTI_MEASURE_REST optional_notemode_duration {
1975 proc = scm_c_eval_string ("make-multi-measure-rest");
1977 SCM mus = scm_call_2 (proc, $2,
1978 make_input (THIS->here_input()));
1979 scm_gc_protect_object (mus);
1980 $$ = unsmob_music (mus);
1982 | STRING optional_notemode_duration {
1983 Input i = THIS->pop_spot ();
1985 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1986 lreq->set_mus_property ("text", $1);
1987 lreq->set_mus_property ("duration",$2);
1989 Music * velt = MY_MAKE_MUSIC("EventChord");
1990 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1997 if (!THIS->lexer_->chord_state_b ())
1998 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1999 $$ = unsmob_music ($1);
2004 steno_tonic_pitch optional_notemode_duration {
2005 $$ = make_chord ($1, $2, SCM_EOL);
2007 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2008 SCM its = scm_reverse_x ($4, SCM_EOL);
2009 $$ = make_chord ($1, $2, gh_cons ($3, its));
2017 | chord_items chord_item {
2018 $$ = gh_cons ($2, $$);
2024 $$ = ly_symbol2scm ("chord-colon");
2027 $$ = ly_symbol2scm ("chord-caret");
2029 | CHORD_SLASH steno_tonic_pitch {
2030 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2032 | CHORD_BASS steno_tonic_pitch {
2033 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2042 $$ = scm_reverse_x ($1, SCM_EOL);
2050 step_number { $$ = gh_cons ($1, SCM_EOL); }
2051 | step_numbers '.' step_number {
2052 $$ = gh_cons ($3, $$);
2058 $$ = make_chord_step ($1, 0);
2060 | bare_unsigned '+' {
2061 $$ = make_chord_step ($1, 1);
2063 | bare_unsigned CHORD_MINUS {
2064 $$ = make_chord_step ($1,-1);
2072 number_expression '+' number_term {
2073 $$ = scm_sum ($1, $3);
2075 | number_expression '-' number_term {
2076 $$ = scm_difference ($1, $3);
2085 | number_factor '*' number_factor {
2086 $$ = scm_product ($1, $3);
2088 | number_factor '/' number_factor {
2089 $$ = scm_divide ($1, $3);
2094 '-' number_factor { /* %prec UNARY_MINUS */
2095 $$ = scm_difference ($2, SCM_UNDEFINED);
2103 $$ = gh_int2scm ($1);
2108 | NUMBER_IDENTIFIER {
2111 | REAL NUMBER_IDENTIFIER {
2112 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2114 | UNSIGNED NUMBER_IDENTIFIER {
2115 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2131 if (scm_integer_p ($1) == SCM_BOOL_T)
2133 int k = gh_scm2int ($1);
2137 THIS->parser_error (_ ("need integer number arg"));
2151 | STRING_IDENTIFIER {
2154 | string '+' string {
2155 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2162 | exclamations '!' { $$ ++; }
2167 | questions '?' { $$ ++; }
2177 { THIS->lexer_->push_markup_state (); }
2180 THIS->lexer_->pop_state ();
2186 This should be done more dynamically if possible.
2190 $$ = make_simple_markup ($1);
2192 | MARKUP_HEAD_MARKUP0 markup {
2193 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2195 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2196 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2198 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2199 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2204 | MARKUP_HEAD_LIST0 markup_list {
2205 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2207 | MARKUP_HEAD_SCM0 embedded_scm {
2208 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2210 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2211 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2213 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2214 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2216 | MARKUP_IDENTIFIER {
2223 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2227 '{' markup_list_body '}' {
2230 line = scm_c_eval_string ("line-markup");
2232 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2237 /**/ { $$ = SCM_EOL; }
2238 | markup_list_body markup {
2239 $$ = gh_cons ($2, $1) ;
2247 My_lily_parser::set_yydebug (bool )
2254 extern My_lily_parser * current_parser;
2257 My_lily_parser::do_yyparse ()
2259 current_parser = this;;
2260 yyparse ((void*)this);
2265 Should make this optional? It will also complain when you do
2269 which is entirely legitimate.
2271 Or we can scrap it. Barchecks should detect wrong durations, and
2272 skipTypesetting speeds it up a lot.
2276 My_lily_parser::beam_check (SCM dur)
2278 Duration *d = unsmob_duration (dur);
2279 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2281 Music * m = unsmob_music (last_beam_start_);
2282 m->origin ()->warning (_("Suspect duration found following this beam"));
2284 last_beam_start_ = SCM_EOL;
2292 return gh_pair_p (x)
2293 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2296 It is a little strange, to have this function in this file, but
2297 otherwise, we have to import music classes into the lexer.
2301 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2303 if (gh_string_p (sid)) {
2305 return STRING_IDENTIFIER;
2306 } else if (gh_number_p (sid)) {
2308 return NUMBER_IDENTIFIER;
2309 } else if (unsmob_translator_def (sid)) {
2310 *destination = unsmob_translator_def (sid)->clone_scm();
2311 return TRANSLATOR_IDENTIFIER;
2312 } else if (unsmob_score (sid)) {
2313 Score *sc = new Score (*unsmob_score (sid));
2314 *destination =sc->self_scm ();
2315 return SCORE_IDENTIFIER;
2316 } else if (Music * mus =unsmob_music (sid)) {
2317 *destination = unsmob_music (sid)->clone ()->self_scm();
2318 unsmob_music (*destination)->
2319 set_mus_property ("origin", make_input (last_input_));
2320 return dynamic_cast<Event*> (mus)
2321 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2322 } else if (unsmob_duration (sid)) {
2323 *destination = unsmob_duration (sid)->smobbed_copy();
2324 return DURATION_IDENTIFIER;
2325 } else if (unsmob_music_output_def (sid)) {
2326 Music_output_def *p = unsmob_music_output_def (sid);
2329 *destination = p->self_scm();
2330 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2331 } else if (new_markup_p (sid)) {
2333 return MARKUP_IDENTIFIER;