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
226 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
227 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
235 %token MULTI_MEASURE_REST
246 %token OVERRIDE SET REVERT
256 %token COMMANDSPANREQUEST
258 %token OUTPUTPROPERTY
273 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
274 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
276 %token <i> E_UNSIGNED
277 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
280 %type <i> exclamations questions dots optional_rest
281 %type <i> bass_number bass_mod
282 %type <scm> br_bass_figure bass_figure figure_list figure_spec
284 %token <scm> NOTENAME_PITCH
285 %token <scm> TONICNAME_PITCH
286 %token <scm> CHORDMODIFIER_PITCH
287 %token <scm> DURATION_IDENTIFIER
288 %token <scm> FRACTION
289 %token <id> IDENTIFIER
290 %token <scm> CHORDNAMES CHORDNAMES_IDENTIFIER
292 %token <scm> CHORD_MODIFIER
294 %token <scm> SCORE_IDENTIFIER
295 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
296 %token <scm> NUMBER_IDENTIFIER
297 %token <scm> EVENT_IDENTIFIER
298 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
299 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
300 %token <scm> RESTNAME
307 %token <scm> MARKUP_HEAD_MARKUP0
308 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
309 %token <scm> MARKUP_HEAD_SCM0
310 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
311 %token <scm> MARKUP_HEAD_SCM0_SCM1
312 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
313 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
315 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
316 %type <scm> markup markup_line markup_list markup_list_body full_markup
318 %type <outputdef> output_def
319 %type <scm> lilypond_header lilypond_header_body
320 %type <music> open_event_parens close_event_parens open_event close_event
321 %type <music> event_with_dir event_that_take_dir verbose_event
322 %type <i> sub_quotes sup_quotes
323 %type <music> simple_element event_chord command_element Simple_music Composite_music
324 %type <music> Repeated_music
325 %type <scm> Alternative_music
326 %type <i> tremolo_type
327 %type <i> bare_int bare_unsigned
329 %type <scm> identifier_init
331 %type <music> note_chord_element chord_body chord_body_element
332 %type <scm> chord_body_elements
333 %type <scm> steno_duration optional_notemode_duration multiplied_duration
334 %type <scm> verbose_duration
336 %type <scm> pre_events post_events
337 %type <music> gen_text_def
338 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
339 %type <scm> explicit_pitch steno_tonic_pitch
341 /* %type <scm> chord_additions chord_subtractions chord_notes chord_step */
342 /* %type <music> chord */
343 /* %type <scm> chord_note chord_inversion chord_bass */
344 %type <scm> duration_length fraction
346 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
348 %type <scm> embedded_scm scalar
349 %type <music> Music Sequential_music Simultaneous_music
350 %type <music> relative_music re_rhythmed_music part_combined_music
351 %type <music> property_def translator_change simple_property_def
352 %type <scm> Music_list
353 %type <outputdef> music_output_def_body
354 %type <music> shorthand_command_req
355 %type <music> post_event
356 %type <music> command_req verbose_command_req
357 %type <music> extender_req
358 %type <music> hyphen_req
359 %type <music> string_event
360 %type <scm> string bare_number number_expression number_term number_factor
361 %type <score> score_block score_body
363 %type <scm> translator_spec_block translator_spec_body
364 %type <music> tempo_event
365 %type <scm> notenames_body notenames_block chordmodifiers_block
366 %type <scm> script_abbreviation
372 /* We don't assign precedence to / and *, because we might need varied
373 prec levels in different prods */
379 lilypond: /* empty */
380 | lilypond toplevel_expression {}
381 | lilypond assignment { }
383 THIS->error_level_ = 1;
386 THIS->error_level_ = 1;
392 THIS->lexer_->pitchname_tab_ = $1;
394 | chordmodifiers_block {
395 THIS->lexer_->chordmodifier_tab_ = $1;
398 THIS->input_file_->header_ = $1;
401 THIS->input_file_->scores_.push ($1);
404 if (dynamic_cast<Paper_def*> ($1))
405 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
406 else if (dynamic_cast<Midi_def*> ($1))
407 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
417 chordmodifiers_block:
418 CHORDMODIFIERS notenames_body { $$ = $2; }
422 PITCHNAMES notenames_body { $$ = $2; }
427 int i = scm_ilength ($1);
429 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
430 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
431 SCM pt = ly_cdar (s);
432 scm_hashq_set_x (tab, ly_caar (s), pt);
438 lilypond_header_body:
440 $$ = ly_make_anonymous_module ();
441 THIS->lexer_->add_scope ($$);
443 | lilypond_header_body assignment {
449 HEADER '{' lilypond_header_body '}' {
450 $$ = THIS->lexer_-> remove_scope();
462 /* cont */ '=' identifier_init {
465 Should find generic way of associating input with objects.
467 Input ip = THIS->pop_spot ();
469 if (! regular_identifier_b ($1))
471 ip.warning (_ ("Identifier should have alphabetic characters only"));
474 THIS->lexer_->set_identifier ($1, $4);
477 TODO: devise standard for protection in parser.
479 The parser stack lives on the C-stack, which means that
480 all objects can be unprotected as soon as they're here.
491 $$ = $1->self_scm ();
492 scm_gc_unprotect_object ($$);
498 $$ = $1->self_scm ();
499 scm_gc_unprotect_object ($$);
501 | translator_spec_block {
505 $$ = $1->self_scm ();
506 scm_gc_unprotect_object ($$);
509 $$ = $1->self_scm ();
510 scm_gc_unprotect_object ($$);
515 | number_expression {
526 translator_spec_block:
527 TRANSLATOR '{' translator_spec_body '}'
533 translator_spec_body:
534 TRANSLATOR_IDENTIFIER {
536 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
539 $$ = Translator_def::make_scm ();
540 Translator_def*td = unsmob_translator_def ($$);
541 td->translator_group_type_ = $2;
542 td->set_spot (THIS->here_input ());
544 | translator_spec_body DESCRIPTION string {
545 unsmob_translator_def ($$)->description_ = $3;
547 | translator_spec_body STRING '=' embedded_scm {
548 unsmob_translator_def ($$)->add_property_assign ($2, $4);
550 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
551 unsmob_translator_def ($$)
552 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
554 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
555 unsmob_translator_def ($$)
556 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
558 | translator_spec_body STRING REVERT embedded_scm {
559 unsmob_translator_def ($$)->add_pop_property (
560 scm_string_to_symbol ($2), $4);
562 | translator_spec_body NAME STRING {
563 unsmob_translator_def ($$)->type_name_ = $3;
565 | translator_spec_body CONSISTS STRING {
566 unsmob_translator_def ($$)->add_element ($3);
568 | translator_spec_body ALIAS STRING {
569 Translator_def*td = unsmob_translator_def ($$);
570 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
572 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
573 Translator_def*td = unsmob_translator_def($$);
574 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
575 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
576 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
578 | translator_spec_body CONSISTSEND STRING {
579 unsmob_translator_def ($$)->add_last_element ( $3);
581 | translator_spec_body ACCEPTS STRING {
582 unsmob_translator_def ($$)->set_acceptor ($3,true);
584 | translator_spec_body DENIES STRING {
585 unsmob_translator_def ($$)->set_acceptor ($3,false);
587 | translator_spec_body REMOVE STRING {
588 unsmob_translator_def ($$)->remove_element ($3);
599 /*cont*/ '{' score_body '}' {
602 if (!$$->defs_.size ())
604 Music_output_def *id =
605 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
606 $$->add_output (id ? id->clone () : new Paper_def );
615 $$->set_spot (THIS->here_input ());
616 SCM m = $1->self_scm ();
617 scm_gc_unprotect_object (m);
622 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
623 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
624 m = gh_call1 (gh_car (check_funcs), m);
629 $$ = unsmob_score ($1);
630 $$->set_spot (THIS->here_input ());
632 | score_body lilypond_header {
635 | score_body output_def {
648 music_output_def_body '}' {
650 THIS-> lexer_-> remove_scope ();
654 music_output_def_body:
656 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
661 p = dynamic_cast<Midi_def*> (id->clone ());
666 THIS->lexer_->add_scope (p->scope_);
669 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
672 p = dynamic_cast<Paper_def*> (id->clone ());
676 THIS->lexer_->add_scope (p->scope_);
679 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
680 Music_output_def * o = unsmob_music_output_def ($3);
683 THIS->lexer_->add_scope (o->scope_);
685 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
686 Music_output_def * o = unsmob_music_output_def ($3);
689 THIS->lexer_->add_scope (o->scope_);
691 | music_output_def_body assignment {
694 | music_output_def_body translator_spec_block {
695 $$->assign_translator ($2);
697 | music_output_def_body tempo_event {
699 junk this ? there already is tempo stuff in
702 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
703 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
704 Midi_def * md = dynamic_cast<Midi_def*> ($$);
706 md->set_tempo (d->get_length (), m);
708 | music_output_def_body error {
714 TEMPO steno_duration '=' bare_unsigned {
715 $$ = MY_MAKE_MUSIC("MetronomeChangeEvent");
716 $$->set_mus_property ("tempo-unit", $2);
717 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
722 The representation of a list is the
726 to have efficient append.
730 $$ = scm_cons (SCM_EOL, SCM_EOL);
734 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
735 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
736 if (gh_pair_p (ly_cdr (s)))
737 gh_set_cdr_x (ly_cdr (s), c); /* append */
739 gh_set_car_x (s, c); /* set first cons */
740 gh_set_cdr_x (s, c) ; /* remember last cell */
756 | ALTERNATIVE '{' Music_list '}' {
762 REPEAT string bare_unsigned Music Alternative_music
766 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
767 if (times < scm_ilength (alts)) {
768 unsmob_music (gh_car (alts))
769 ->origin ()->warning (
770 _("More alternatives than repeats. Junking excess alternatives."));
771 alts = ly_truncate_list (times, alts);
777 proc = scm_c_eval_string ("make-repeated-music");
779 SCM mus = scm_call_1 (proc, $2);
780 scm_gc_protect_object (mus); // UGH.
781 Music *r =unsmob_music (mus);
784 r-> set_mus_property ("element", beg->self_scm ());
785 scm_gc_unprotect_object (beg->self_scm ());
787 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
789 r-> set_mus_property ("elements",alts);
790 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
793 we can not get durations and other stuff correct down the line, so we have to
794 add to the duration log here.
796 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
798 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
800 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
802 r->set_spot (*$4->origin ());
809 SEQUENTIAL '{' Music_list '}' {
810 $$ = MY_MAKE_MUSIC("SequentialMusic");
811 $$->set_mus_property ("elements", ly_car ($3));
812 $$->set_spot(THIS->here_input());
814 | '{' Music_list '}' {
815 $$ = MY_MAKE_MUSIC("SequentialMusic");
816 $$->set_mus_property ("elements", ly_car ($2));
817 $$->set_spot(THIS->here_input());
822 SIMULTANEOUS '{' Music_list '}'{
823 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
824 $$->set_mus_property ("elements", ly_car ($3));
825 $$->set_spot(THIS->here_input());
828 | '<' Music_list '>' {
829 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
830 $$->set_mus_property ("elements", ly_car ($2));
831 $$->set_spot(THIS->here_input());
836 event_chord { $$ = $1; }
837 | APPLYOUTPUT embedded_scm {
838 if (!gh_procedure_p ($2))
839 THIS->parser_error (_ ("\applycontext takes function argument"));
840 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
841 $$->set_mus_property ("procedure", $2);
842 $$->set_spot (THIS->here_input());
844 | APPLYCONTEXT embedded_scm {
845 if (!gh_procedure_p ($2))
846 THIS->parser_error (_ ("\applycontext takes function argument"));
847 $$ = MY_MAKE_MUSIC ("ApplyContext");
848 $$->set_mus_property ("procedure", $2);
849 $$->set_spot (THIS->here_input());
851 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
853 if (!gh_symbol_p ($3))
855 THIS->parser_error (_ ("Second argument must be a symbol"));
857 /* Should check # args */
858 if (!gh_procedure_p (pred))
860 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
863 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
864 m->set_mus_property ("predicate", pred);
865 m->set_mus_property ("grob-property", $3);
866 m->set_mus_property ("grob-value", $5);
871 $$ = unsmob_music ($1);
879 CONTEXT STRING Music {
880 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
882 csm->set_mus_property ("element", $3->self_scm ());
883 scm_gc_unprotect_object ($3->self_scm ());
885 csm->set_mus_property ("context-type",$2);
886 csm->set_mus_property ("context-id", scm_makfrom0str (""));
890 | AUTOCHANGE STRING Music {
891 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
892 chm->set_mus_property ("element", $3->self_scm ());
893 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
895 scm_gc_unprotect_object ($3->self_scm ());
896 chm->set_mus_property ("what", $2);
899 chm->set_spot (*$3->origin ());
904 The other version is for easier debugging of
905 Sequential_music_iterator in combination with grace notes.
908 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
909 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
910 Music *startm = unsmob_music (start);
911 Music *stopm = unsmob_music (stop);
915 stopm = stopm->clone ();
916 ms = scm_cons (stopm->self_scm (), ms);
917 scm_gc_unprotect_object (stopm->self_scm ());
919 ms = scm_cons ($2->self_scm (), ms);
920 scm_gc_unprotect_object ($2->self_scm());
922 startm = startm->clone ();
923 ms = scm_cons (startm->self_scm () , ms);
924 scm_gc_unprotect_object (startm->self_scm ());
928 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
929 seq->set_mus_property ("elements", ms);
932 $$ = MY_MAKE_MUSIC("GraceMusic");
933 $$->set_mus_property ("element", seq->self_scm ());
934 scm_gc_unprotect_object (seq->self_scm ());
936 $$ = MY_MAKE_MUSIC("GraceMusic");
937 $$->set_mus_property ("element", $2->self_scm ());
938 scm_gc_unprotect_object ($2->self_scm ());
941 | CONTEXT string '=' string Music {
942 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
944 csm->set_mus_property ("element", $5->self_scm ());
945 scm_gc_unprotect_object ($5->self_scm ());
947 csm->set_mus_property ("context-type", $2);
948 csm->set_mus_property ("context-id", $4);
959 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
961 $$= MY_MAKE_MUSIC("TimeScaledMusic");
962 $$->set_spot (THIS->pop_spot ());
965 $$->set_mus_property ("element", mp->self_scm ());
966 scm_gc_unprotect_object (mp->self_scm ());
967 $$->set_mus_property ("numerator", gh_int2scm (n));
968 $$->set_mus_property ("denominator", gh_int2scm (d));
969 $$->compress (Moment (Rational (n,d)));
972 | Repeated_music { $$ = $1; }
973 | Simultaneous_music { $$ = $1; }
974 | Sequential_music { $$ = $1; }
975 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
976 $$ = MY_MAKE_MUSIC("TransposedMusic");
978 Pitch from = *unsmob_pitch ($2);
979 Pitch to = *unsmob_pitch ($3);
981 p->transpose (interval (from, to));
982 $$->set_mus_property ("element", p->self_scm ());
983 scm_gc_unprotect_object (p->self_scm ());
985 | APPLY embedded_scm Music {
986 SCM ret = gh_call1 ($2, $3->self_scm ());
987 Music *m = unsmob_music (ret);
989 THIS->parser_error ("\\apply must return a Music");
990 m = MY_MAKE_MUSIC("Music");
995 { THIS->lexer_->push_note_state (); }
998 THIS->lexer_->pop_state ();
1001 { THIS->lexer_->push_figuredbass_state (); }
1004 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1005 chm->set_mus_property ("element", $3->self_scm ());
1007 scm_gc_unprotect_object ($3->self_scm());
1009 THIS->lexer_->pop_state ();
1012 { THIS->lexer_->push_chord_state (); }
1015 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1016 chm->set_mus_property ("element", $3->self_scm ());
1017 scm_gc_unprotect_object ($3->self_scm());
1020 THIS->lexer_->pop_state ();
1023 { THIS->lexer_->push_lyric_state (); }
1027 THIS->lexer_->pop_state ();
1029 | relative_music { $$ = $1; }
1030 | re_rhythmed_music { $$ = $1; }
1031 | part_combined_music { $$ = $1; }
1035 RELATIVE absolute_pitch Music {
1037 Pitch pit = *unsmob_pitch ($2);
1038 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1040 $$->set_mus_property ("element", p->self_scm ());
1041 scm_gc_unprotect_object (p->self_scm ());
1044 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1050 ADDLYRICS Music Music {
1051 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1052 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1053 scm_gc_unprotect_object ($3->self_scm ());
1054 scm_gc_unprotect_object ($2->self_scm ());
1059 part_combined_music:
1060 PARTCOMBINE STRING Music Music {
1061 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1062 p->set_mus_property ("what", $2);
1063 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1065 scm_gc_unprotect_object ($3->self_scm ());
1066 scm_gc_unprotect_object ($4->self_scm ());
1073 TRANSLATOR STRING '=' STRING {
1074 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1075 t-> set_mus_property ("change-to-type", $2);
1076 t-> set_mus_property ("change-to-id", $4);
1079 $$->set_spot (THIS->here_input ());
1085 | ONCE simple_property_def {
1087 SCM e = $2->get_mus_property ("element");
1088 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1092 simple_property_def:
1093 PROPERTY STRING '.' STRING '=' scalar {
1094 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1095 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1097 csm->set_mus_property ("element", t->self_scm ());
1098 scm_gc_unprotect_object (t->self_scm ());
1101 $$->set_spot (THIS->here_input ());
1103 csm-> set_mus_property ("context-type", $2);
1105 | PROPERTY STRING '.' STRING UNSET {
1107 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1108 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1110 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1111 csm->set_mus_property ("element", t->self_scm ());
1112 scm_gc_unprotect_object (t->self_scm ());
1115 $$->set_spot (THIS->here_input ());
1117 csm-> set_mus_property ("context-type", $2);
1119 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1121 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1122 bool itc = internal_type_checking_global_b;
1123 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1124 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1125 t->set_mus_property ("pop-first", SCM_BOOL_T);
1127 internal_type_checking_global_b = false;
1128 t->set_mus_property ("grob-property", $6);
1130 internal_type_checking_global_b = itc;
1131 t->set_mus_property ("grob-value", $8);
1133 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1134 csm->set_mus_property ("element", t->self_scm ());
1135 scm_gc_unprotect_object (t->self_scm ());
1137 $$->set_spot (THIS->here_input ());
1139 csm-> set_mus_property ("context-type", $2);
1141 | PROPERTY STRING '.' STRING OVERRIDE
1142 embedded_scm '=' embedded_scm
1148 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1149 bool itc = internal_type_checking_global_b;
1151 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1152 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1154 internal_type_checking_global_b = false;
1155 t->set_mus_property ("grob-property", $6);
1156 t->set_mus_property ("grob-value", $8);
1158 internal_type_checking_global_b = itc;
1160 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1161 csm->set_mus_property ("element", t->self_scm ());
1162 scm_gc_unprotect_object (t->self_scm ());
1165 $$->set_spot (THIS->here_input ());
1167 csm-> set_mus_property ("context-type", $2);
1170 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1171 Music *t = MY_MAKE_MUSIC("RevertProperty");
1173 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1174 bool itc = internal_type_checking_global_b;
1176 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1178 internal_type_checking_global_b = false;
1179 t->set_mus_property ("grob-property", $6);
1181 internal_type_checking_global_b = itc;
1183 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1184 csm->set_mus_property ("element", t->self_scm ());
1185 scm_gc_unprotect_object (t->self_scm ());
1188 $$->set_spot (THIS->here_input ());
1190 csm-> set_mus_property ("context-type", $2);
1197 | bare_int { $$ = gh_int2scm ($1); }
1198 | embedded_scm { $$ = $1; }
1199 | full_markup { $$ = $1; }
1200 | DIGIT { $$ = gh_int2scm ($1); }
1207 } /*cont */ simple_element post_events {
1208 SCM elts = $3-> get_mus_property ("elements");
1210 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1211 scm_reverse_x ($4, SCM_EOL));
1213 $3-> set_mus_property ("elements", elts);
1217 | note_chord_element
1222 chord_body optional_notemode_duration post_events
1224 SCM dur = unsmob_duration ($2)->smobbed_copy();
1225 SCM es = $1->get_mus_property ("elements");
1226 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1228 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1229 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1230 es = gh_append2 (es, postevs);
1232 $1-> set_mus_property ("elements", es);
1238 CHORD_OPEN chord_body_elements CHORD_CLOSE
1240 $$ = MY_MAKE_MUSIC("EventChord");
1241 $$->set_mus_property ("elements",
1242 scm_reverse_x ($2, SCM_EOL));
1246 chord_body_elements:
1247 /* empty */ { $$ = SCM_EOL; }
1248 | chord_body_elements chord_body_element {
1249 $$ = gh_cons ($2->self_scm(), $1);
1250 scm_gc_unprotect_object ($2->self_scm());
1255 pitch exclamations questions post_events
1257 Music * n = MY_MAKE_MUSIC("NoteEvent");
1258 n->set_mus_property ("pitch", $1);
1260 n->set_mus_property ("cautionary", SCM_BOOL_T);
1261 if ($2 % 2 || $3 % 2)
1262 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1264 SCM arts = scm_reverse_x ($4, SCM_EOL);
1265 n->set_mus_property ("articulations", arts);
1273 $$ = MY_MAKE_MUSIC("EventChord");
1274 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1275 scm_gc_unprotect_object ($1->self_scm());
1277 $$-> set_spot (THIS->here_input ());
1278 $1-> set_spot (THIS->here_input ());
1281 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1282 l->set_mus_property ("span-direction", gh_int2scm (START));
1283 l->set_spot (THIS->here_input ());
1285 $$ = MY_MAKE_MUSIC("EventChord");
1286 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1287 scm_gc_unprotect_object (l->self_scm());
1288 $$->set_spot (THIS->here_input ());
1291 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1292 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1293 l->set_spot (THIS->here_input ());
1295 $$ = MY_MAKE_MUSIC("EventChord");
1296 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1297 $$->set_spot (THIS->here_input ());
1298 scm_gc_unprotect_object (l->self_scm());
1301 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1302 $$->set_spot (THIS->here_input ());
1306 $$ = MY_MAKE_MUSIC("BarCheck");
1307 $$->set_spot (THIS->here_input ());
1310 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1312 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1313 csm->set_mus_property ("element", t->self_scm ());
1314 scm_gc_unprotect_object (t->self_scm ());
1317 $$->set_spot (THIS->here_input ());
1319 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1321 | PARTIAL duration_length {
1322 Moment m = - unsmob_duration ($2)->get_length ();
1323 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1325 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1326 sp->set_mus_property ("element", p->self_scm ());
1327 scm_gc_unprotect_object (p->self_scm ());
1330 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1335 proc = scm_c_eval_string ("make-clef-set");
1337 SCM result = scm_call_1 (proc, $2);
1338 scm_gc_protect_object (result);
1339 $$ = unsmob_music (result);
1344 proc = scm_c_eval_string ("make-time-signature-set");
1346 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1347 scm_gc_protect_object (result);
1348 $$ = unsmob_music (result);
1353 shorthand_command_req { $$ = $1; }
1354 | verbose_command_req { $$ = $1; }
1357 shorthand_command_req:
1365 $$ = MY_MAKE_MUSIC("TieEvent");
1368 Music *b= MY_MAKE_MUSIC("BeamEvent");
1369 b->set_mus_property ("span-direction", gh_int2scm (START));
1372 THIS->last_beam_start_ = b->self_scm ();
1375 Music *b= MY_MAKE_MUSIC("BeamEvent");
1376 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1380 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1383 $$ = MY_MAKE_MUSIC("PesOrFlexaEvent");
1387 verbose_command_req:
1389 Music * m = MY_MAKE_MUSIC("MarkEvent");
1393 Music *m = MY_MAKE_MUSIC("MarkEvent");
1394 m->set_mus_property ("label", $2);
1397 | SKIP duration_length {
1398 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1399 skip->set_mus_property ("duration", $2);
1407 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1410 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1411 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1413 key->set_mus_property ("pitch-alist", $3);
1414 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1415 ((Music*)key)->transpose (* unsmob_pitch ($2));
1425 | post_events post_event {
1426 $2->set_spot (THIS->here_input ());
1427 $$ = gh_cons ($2->self_scm(), $$);
1428 scm_gc_unprotect_object ($2->self_scm());
1441 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1442 s->set_mus_property ("string-number", gh_int2scm($1));
1443 s->set_spot (THIS->here_input ());
1449 event_that_take_dir:
1455 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1456 m->set_spot (THIS->here_input());
1457 m->set_mus_property ("span-direction" , gh_int2scm (START));
1461 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1462 m->set_spot (THIS->here_input());
1463 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1467 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1468 m->set_spot (THIS->here_input());
1471 | script_abbreviation {
1472 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1473 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1474 if (gh_string_p (s))
1475 a->set_mus_property ("articulation-type", s);
1476 else THIS->parser_error (_ ("Expecting string as script definition"));
1482 script_dir event_that_take_dir {
1483 $2->set_mus_property ("direction", gh_int2scm ($1));
1490 $$ = unsmob_music ($1);
1493 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1494 a->set_spot (THIS->here_input ());
1495 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1522 | NOTENAME_PITCH sup_quotes {
1523 Pitch p = *unsmob_pitch ($1);
1524 p = p.transposed (Pitch ($2,0,0));
1525 $$ = p.smobbed_copy ();
1527 | NOTENAME_PITCH sub_quotes {
1528 Pitch p =* unsmob_pitch ($1);
1529 p = p.transposed (Pitch (-$2,0,0));
1530 $$ = p.smobbed_copy ();
1542 | TONICNAME_PITCH sup_quotes {
1543 Pitch p = *unsmob_pitch ($1);
1544 p = p.transposed (Pitch ($2,0,0));
1545 $$ = p.smobbed_copy ();
1547 | TONICNAME_PITCH sub_quotes {
1548 Pitch p =* unsmob_pitch ($1);
1550 p = p.transposed (Pitch (-$2,0,0));
1551 $$ = p.smobbed_copy ();
1564 pitch_also_in_chords:
1570 PITCH embedded_scm {
1572 if (!unsmob_pitch ($2)) {
1573 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1574 $$ = Pitch ().smobbed_copy ();
1580 DURATION embedded_scm {
1582 if (!unsmob_duration ($2))
1584 THIS->parser_error (_ ("Must have duration object"));
1585 $$ = Duration ().smobbed_copy ();
1592 if (!THIS->lexer_->lyric_state_b ())
1593 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1594 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1600 if (!THIS->lexer_->lyric_state_b ())
1601 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1602 $$ = MY_MAKE_MUSIC("HyphenEvent");
1607 close_event_parens {
1609 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1616 Music * s= MY_MAKE_MUSIC("SlurEvent");
1618 s->set_spot (THIS->here_input());
1621 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1623 s->set_spot (THIS->here_input());
1626 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1628 s->set_spot (THIS->here_input());
1631 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1633 s->set_spot (THIS->here_input());
1641 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1648 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1649 s->set_spot (THIS->here_input());
1654 Music * s= MY_MAKE_MUSIC("SlurEvent");
1656 s->set_spot (THIS->here_input());
1660 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1662 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1663 s->set_spot (THIS->here_input());
1669 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1670 t->set_mus_property ("text", $1);
1671 t->set_spot (THIS->here_input ());
1675 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1676 t->set_mus_property ("text", $1);
1677 t->set_spot (THIS->here_input ());
1681 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1682 t->set_mus_property ("text", make_simple_markup ($1));
1683 t->set_spot (THIS->here_input ());
1688 Music * t = MY_MAKE_MUSIC("FingerEvent");
1689 t->set_mus_property ("digit", gh_int2scm ($1));
1690 t->set_spot (THIS->here_input ());
1695 script_abbreviation:
1697 $$ = scm_makfrom0str ("Hat");
1700 $$ = scm_makfrom0str ("Plus");
1703 $$ = scm_makfrom0str ("Dash");
1706 $$ = scm_makfrom0str ("Bar");
1709 $$ = scm_makfrom0str ("Larger");
1712 $$ = scm_makfrom0str ("Dot");
1715 $$ = scm_makfrom0str ("Underscore");
1722 | '-' { $$ = CENTER; }
1729 | pre_events open_event {
1730 $$ = gh_cons ($2->self_scm(), $$);
1731 scm_gc_unprotect_object ($2->self_scm());
1742 multiplied_duration {
1745 | verbose_duration {
1750 optional_notemode_duration:
1752 Duration dd = THIS->default_duration_;
1753 $$ = dd.smobbed_copy ();
1755 THIS->beam_check ($$);
1757 | multiplied_duration {
1759 THIS->default_duration_ = *unsmob_duration ($$);
1761 THIS->beam_check ($$);
1763 | verbose_duration {
1765 THIS->default_duration_ = *unsmob_duration ($$);
1770 bare_unsigned dots {
1772 if (!is_duration_b ($1))
1773 THIS->parser_error (_f ("not a duration: %d", $1));
1777 $$ = Duration (l, $2).smobbed_copy ();
1779 | DURATION_IDENTIFIER dots {
1780 Duration *d =unsmob_duration ($1);
1781 Duration k (d->duration_log (),d->dot_count () + $2);
1791 multiplied_duration:
1795 | multiplied_duration '*' bare_unsigned {
1796 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1798 | multiplied_duration '*' FRACTION {
1799 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1801 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1806 FRACTION { $$ = $1; }
1807 | UNSIGNED '/' UNSIGNED {
1808 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1826 | ':' bare_unsigned {
1827 if (!is_duration_b ($2))
1828 THIS->parser_error (_f ("not a duration: %d", $2));
1835 /*****************************************************************
1837 *****************************************************************/
1851 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1852 $$ = bfr->self_scm();
1853 scm_gc_unprotect_object ($$);
1856 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1857 $$ = bfr->self_scm();
1859 bfr->set_mus_property ("figure", gh_int2scm ($1));
1861 scm_gc_unprotect_object ($$);
1863 | bass_figure bass_mod {
1864 Music *m = unsmob_music ($1);
1866 SCM salter =m->get_mus_property ("alteration");
1867 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1868 m->set_mus_property ("alteration",
1869 gh_int2scm (alter + $2));
1871 m->set_mus_property ("alteration", gh_int2scm (0));
1879 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1884 | br_bass_figure ']' {
1886 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1894 | figure_list br_bass_figure {
1895 $$ = scm_cons ($2, $1);
1900 FIGURE_OPEN figure_list FIGURE_CLOSE {
1901 Music * m = MY_MAKE_MUSIC("EventChord");
1902 $2 = scm_reverse_x ($2, SCM_EOL);
1903 m->set_mus_property ("elements", $2);
1904 $$ = m->self_scm ();
1915 pitch exclamations questions optional_notemode_duration optional_rest {
1917 Input i = THIS->pop_spot ();
1918 if (!THIS->lexer_->note_state_b ())
1919 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1923 n = MY_MAKE_MUSIC("RestEvent");
1925 n = MY_MAKE_MUSIC("NoteEvent");
1927 n->set_mus_property ("pitch", $1);
1928 n->set_mus_property ("duration", $4);
1932 n->set_mus_property ("cautionary", SCM_BOOL_T);
1933 if ($2 % 2 || $3 % 2)
1934 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1936 Music *v = MY_MAKE_MUSIC("EventChord");
1937 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1938 scm_gc_unprotect_object (n->self_scm());
1944 | figure_spec optional_notemode_duration {
1945 Music * m = unsmob_music ($1);
1946 Input i = THIS->pop_spot ();
1948 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1950 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1954 | RESTNAME optional_notemode_duration {
1956 Input i = THIS->pop_spot ();
1958 if (ly_scm2string ($1) =="s") {
1960 ev = MY_MAKE_MUSIC("SkipEvent");
1963 ev = MY_MAKE_MUSIC("RestEvent");
1966 ev->set_mus_property ("duration" ,$2);
1968 Music * velt = MY_MAKE_MUSIC("EventChord");
1969 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1974 | MULTI_MEASURE_REST optional_notemode_duration {
1979 proc = scm_c_eval_string ("make-multi-measure-rest");
1981 SCM mus = scm_call_2 (proc, $2,
1982 make_input (THIS->here_input()));
1983 scm_gc_protect_object (mus);
1984 $$ = unsmob_music (mus);
1986 | STRING optional_notemode_duration {
1987 Input i = THIS->pop_spot ();
1989 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1990 lreq->set_mus_property ("text", $1);
1991 lreq->set_mus_property ("duration",$2);
1993 Music * velt = MY_MAKE_MUSIC("EventChord");
1994 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
2001 if (!THIS->lexer_->chord_state_b ())
2002 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2003 $$ = unsmob_music ($1);
2008 steno_tonic_pitch optional_notemode_duration {
2009 $$ = make_chord ($1, $2, SCM_EOL);
2011 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2012 SCM its = scm_reverse_x ($4, SCM_EOL);
2013 $$ = make_chord ($1, $2, gh_cons ($3, its));
2021 | chord_items chord_item {
2022 $$ = gh_cons ($2, $$);
2028 $$ = ly_symbol2scm ("chord-colon");
2031 $$ = ly_symbol2scm ("chord-caret");
2033 | CHORD_SLASH steno_tonic_pitch {
2034 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2036 | CHORD_BASS steno_tonic_pitch {
2037 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2046 $$ = scm_reverse_x ($1, SCM_EOL);
2054 step_number { $$ = gh_cons ($1, SCM_EOL); }
2055 | step_numbers '.' step_number {
2056 $$ = gh_cons ($3, $$);
2062 $$ = make_chord_step ($1, 0);
2064 | bare_unsigned '+' {
2065 $$ = make_chord_step ($1, 1);
2067 | bare_unsigned CHORD_MINUS {
2068 $$ = make_chord_step ($1,-1);
2076 number_expression '+' number_term {
2077 $$ = scm_sum ($1, $3);
2079 | number_expression '-' number_term {
2080 $$ = scm_difference ($1, $3);
2089 | number_factor '*' number_factor {
2090 $$ = scm_product ($1, $3);
2092 | number_factor '/' number_factor {
2093 $$ = scm_divide ($1, $3);
2098 '-' number_factor { /* %prec UNARY_MINUS */
2099 $$ = scm_difference ($2, SCM_UNDEFINED);
2107 $$ = gh_int2scm ($1);
2112 | NUMBER_IDENTIFIER {
2115 | REAL NUMBER_IDENTIFIER {
2116 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2118 | UNSIGNED NUMBER_IDENTIFIER {
2119 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2135 if (scm_integer_p ($1) == SCM_BOOL_T)
2137 int k = gh_scm2int ($1);
2141 THIS->parser_error (_ ("need integer number arg"));
2155 | STRING_IDENTIFIER {
2158 | string '+' string {
2159 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2166 | exclamations '!' { $$ ++; }
2171 | questions '?' { $$ ++; }
2181 { THIS->lexer_->push_markup_state (); }
2184 THIS->lexer_->pop_state ();
2190 This should be done more dynamically if possible.
2194 $$ = make_simple_markup ($1);
2196 | MARKUP_HEAD_MARKUP0 markup {
2197 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2199 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2200 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2202 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2203 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2208 | MARKUP_HEAD_LIST0 markup_list {
2209 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2211 | MARKUP_HEAD_SCM0 embedded_scm {
2212 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2214 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2215 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2217 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2218 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2220 | MARKUP_IDENTIFIER {
2227 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2231 '{' markup_list_body '}' {
2234 line = scm_c_eval_string ("line-markup");
2236 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2241 /**/ { $$ = SCM_EOL; }
2242 | markup_list_body markup {
2243 $$ = gh_cons ($2, $1) ;
2251 My_lily_parser::set_yydebug (bool )
2258 extern My_lily_parser * current_parser;
2261 My_lily_parser::do_yyparse ()
2263 current_parser = this;;
2264 yyparse ((void*)this);
2269 Should make this optional? It will also complain when you do
2273 which is entirely legitimate.
2275 Or we can scrap it. Barchecks should detect wrong durations, and
2276 skipTypesetting speeds it up a lot.
2280 My_lily_parser::beam_check (SCM dur)
2282 Duration *d = unsmob_duration (dur);
2283 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2285 Music * m = unsmob_music (last_beam_start_);
2286 m->origin ()->warning (_("Suspect duration found following this beam"));
2288 last_beam_start_ = SCM_EOL;
2296 return gh_pair_p (x)
2297 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2300 It is a little strange, to have this function in this file, but
2301 otherwise, we have to import music classes into the lexer.
2305 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2307 if (gh_string_p (sid)) {
2309 return STRING_IDENTIFIER;
2310 } else if (gh_number_p (sid)) {
2312 return NUMBER_IDENTIFIER;
2313 } else if (unsmob_translator_def (sid)) {
2314 *destination = unsmob_translator_def (sid)->clone_scm();
2315 return TRANSLATOR_IDENTIFIER;
2316 } else if (unsmob_score (sid)) {
2317 Score *sc = new Score (*unsmob_score (sid));
2318 *destination =sc->self_scm ();
2319 return SCORE_IDENTIFIER;
2320 } else if (Music * mus =unsmob_music (sid)) {
2321 *destination = unsmob_music (sid)->clone ()->self_scm();
2322 unsmob_music (*destination)->
2323 set_mus_property ("origin", make_input (last_input_));
2324 return dynamic_cast<Event*> (mus)
2325 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2326 } else if (unsmob_duration (sid)) {
2327 *destination = unsmob_duration (sid)->smobbed_copy();
2328 return DURATION_IDENTIFIER;
2329 } else if (unsmob_music_output_def (sid)) {
2330 Music_output_def *p = unsmob_music_output_def (sid);
2333 *destination = p->self_scm();
2334 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2335 } else if (new_markup_p (sid)) {
2337 return MARKUP_IDENTIFIER;