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?
53 #include "translator-def.hh"
54 #include "lily-guile.hh"
56 #include "my-lily-lexer.hh"
57 #include "paper-def.hh"
58 #include "midi-def.hh"
60 #include "file-path.hh"
62 #include "dimensions.hh"
63 #include "my-lily-parser.hh"
65 #include "input-file-results.hh"
67 #include "lilypond-input-version.hh"
68 #include "scm-hash.hh"
69 #include "auto-change-iterator.hh"
70 #include "ly-modules.hh"
71 #include "music-sequence.hh"
72 #include "input-smob.hh"
74 #include "text-item.hh"
78 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
82 #define YYERROR_VERBOSE 1
84 My_lily_parser* my_lily_parser;
85 #define YYPARSE_PARAM my_lily_parser
86 #define YYLEX_PARAM my_lily_parser
88 ((My_lily_parser *) my_lily_parser)
90 #define yyerror THIS->parser_error
97 regular_identifier_b (SCM id)
99 String str = ly_scm2string (id);
100 char const *s = str.to_str0 () ;
105 v = v && isalpha (*s);
112 make_simple_markup (SCM a)
116 simple = scm_c_eval_string ("simple-markup");
118 return scm_list_n (simple, a, SCM_UNDEFINED);
123 is_duration_b (int t)
125 return t && t == 1 << intlog2 (t);
129 set_music_properties (Music *p, SCM a)
131 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
133 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
139 make_chord_step (int step, int alter)
144 /* ugh: fucks up above 13 */
145 Pitch m(step > 7 ? 1 : 0,(step - 1) % 7, alter);
146 return m.smobbed_copy ();
151 make_chord (SCM pitch, SCM dur, SCM modification_list)
153 static SCM chord_ctor;
155 chord_ctor= scm_c_eval_string ("construct-chord");
156 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
157 scm_gc_protect_object (ch);
164 set_property_music (SCM sym, SCM value)
166 Music * p = MY_MAKE_MUSIC("PropertySet");
167 p->set_mus_property ("symbol", sym);
168 p->set_mus_property ("value", value);
174 /* We use SCMs to do strings, because it saves us the trouble of
175 deleting them. Let's hope that a stack overflow doesnt trigger a move
176 of the parse stack onto the heap. */
183 Music_output_def * outputdef;
190 yylex (YYSTYPE *s, void * v)
192 My_lily_parser *pars = (My_lily_parser*) v;
193 My_lily_lexer * lex = pars->lexer_;
195 lex->lexval = (void*) s;
196 lex->prepare_for_next_token();
197 return lex->yylex ();
205 /* 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 | APPLYCONTEXT embedded_scm {
833 if (!gh_procedure_p ($2))
834 THIS->parser_error (_ ("\applycontext takes function argument"));
835 $$ = MY_MAKE_MUSIC ("ApplyContext");
836 $$->set_mus_property ("procedure", $2);
837 $$->set_spot (THIS->here_input());
839 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
841 if (!gh_symbol_p ($3))
843 THIS->parser_error (_ ("Second argument must be a symbol"));
845 /* Should check # args */
846 if (!gh_procedure_p (pred))
848 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
851 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
852 m->set_mus_property ("predicate", pred);
853 m->set_mus_property ("grob-property", $3);
854 m->set_mus_property ("grob-value", $5);
859 $$ = unsmob_music ($1);
867 CONTEXT STRING Music {
868 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
870 csm->set_mus_property ("element", $3->self_scm ());
871 scm_gc_unprotect_object ($3->self_scm ());
873 csm->set_mus_property ("context-type",$2);
874 csm->set_mus_property ("context-id", scm_makfrom0str (""));
878 | AUTOCHANGE STRING Music {
879 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
880 chm->set_mus_property ("element", $3->self_scm ());
881 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
883 scm_gc_unprotect_object ($3->self_scm ());
884 chm->set_mus_property ("what", $2);
887 chm->set_spot (*$3->origin ());
892 The other version is for easier debugging of
893 Sequential_music_iterator in combination with grace notes.
896 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
897 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
898 Music *startm = unsmob_music (start);
899 Music *stopm = unsmob_music (stop);
903 stopm = stopm->clone ();
904 ms = scm_cons (stopm->self_scm (), ms);
905 scm_gc_unprotect_object (stopm->self_scm ());
907 ms = scm_cons ($2->self_scm (), ms);
908 scm_gc_unprotect_object ($2->self_scm());
910 startm = startm->clone ();
911 ms = scm_cons (startm->self_scm () , ms);
912 scm_gc_unprotect_object (startm->self_scm ());
916 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
917 seq->set_mus_property ("elements", ms);
920 $$ = MY_MAKE_MUSIC("GraceMusic");
921 $$->set_mus_property ("element", seq->self_scm ());
922 scm_gc_unprotect_object (seq->self_scm ());
924 $$ = MY_MAKE_MUSIC("GraceMusic");
925 $$->set_mus_property ("element", $2->self_scm ());
926 scm_gc_unprotect_object ($2->self_scm ());
929 | CONTEXT string '=' string Music {
930 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
932 csm->set_mus_property ("element", $5->self_scm ());
933 scm_gc_unprotect_object ($5->self_scm ());
935 csm->set_mus_property ("context-type", $2);
936 csm->set_mus_property ("context-id", $4);
947 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
949 $$= MY_MAKE_MUSIC("TimeScaledMusic");
950 $$->set_spot (THIS->pop_spot ());
953 $$->set_mus_property ("element", mp->self_scm ());
954 scm_gc_unprotect_object (mp->self_scm ());
955 $$->set_mus_property ("numerator", gh_int2scm (n));
956 $$->set_mus_property ("denominator", gh_int2scm (d));
957 $$->compress (Moment (Rational (n,d)));
960 | Repeated_music { $$ = $1; }
961 | Simultaneous_music { $$ = $1; }
962 | Sequential_music { $$ = $1; }
963 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
964 $$ = MY_MAKE_MUSIC("TransposedMusic");
966 Pitch from = *unsmob_pitch ($2);
967 Pitch to = *unsmob_pitch ($3);
969 p->transpose (interval (from, to));
970 $$->set_mus_property ("element", p->self_scm ());
971 scm_gc_unprotect_object (p->self_scm ());
973 | APPLY embedded_scm Music {
974 SCM ret = gh_call1 ($2, $3->self_scm ());
975 Music *m = unsmob_music (ret);
977 THIS->parser_error ("\\apply must return a Music");
978 m = MY_MAKE_MUSIC("Music");
983 { THIS->lexer_->push_note_state (); }
986 THIS->lexer_->pop_state ();
989 { THIS->lexer_->push_figuredbass_state (); }
992 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
993 chm->set_mus_property ("element", $3->self_scm ());
995 scm_gc_unprotect_object ($3->self_scm());
997 THIS->lexer_->pop_state ();
1000 { THIS->lexer_->push_chord_state (); }
1003 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1004 chm->set_mus_property ("element", $3->self_scm ());
1005 scm_gc_unprotect_object ($3->self_scm());
1008 THIS->lexer_->pop_state ();
1011 { THIS->lexer_->push_lyric_state (); }
1015 THIS->lexer_->pop_state ();
1017 | relative_music { $$ = $1; }
1018 | re_rhythmed_music { $$ = $1; }
1019 | part_combined_music { $$ = $1; }
1023 RELATIVE absolute_pitch Music {
1025 Pitch pit = *unsmob_pitch ($2);
1026 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1028 $$->set_mus_property ("element", p->self_scm ());
1029 scm_gc_unprotect_object (p->self_scm ());
1031 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1037 ADDLYRICS Music Music {
1038 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1039 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1040 scm_gc_unprotect_object ($3->self_scm ());
1041 scm_gc_unprotect_object ($2->self_scm ());
1046 part_combined_music:
1047 PARTCOMBINE STRING Music Music {
1048 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1049 p->set_mus_property ("what", $2);
1050 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1052 scm_gc_unprotect_object ($3->self_scm ());
1053 scm_gc_unprotect_object ($4->self_scm ());
1060 TRANSLATOR STRING '=' STRING {
1061 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1062 t-> set_mus_property ("change-to-type", $2);
1063 t-> set_mus_property ("change-to-id", $4);
1066 $$->set_spot (THIS->here_input ());
1072 | ONCE simple_property_def {
1074 SCM e = $2->get_mus_property ("element");
1075 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1079 simple_property_def:
1080 PROPERTY STRING '.' STRING '=' scalar {
1081 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1082 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1084 csm->set_mus_property ("element", t->self_scm ());
1085 scm_gc_unprotect_object (t->self_scm ());
1088 $$->set_spot (THIS->here_input ());
1090 csm-> set_mus_property ("context-type", $2);
1092 | PROPERTY STRING '.' STRING UNSET {
1094 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1095 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1097 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1098 csm->set_mus_property ("element", t->self_scm ());
1099 scm_gc_unprotect_object (t->self_scm ());
1102 $$->set_spot (THIS->here_input ());
1104 csm-> set_mus_property ("context-type", $2);
1106 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1108 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1109 bool itc = internal_type_checking_global_b;
1110 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1111 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1112 t->set_mus_property ("pop-first", SCM_BOOL_T);
1114 internal_type_checking_global_b = false;
1115 t->set_mus_property ("grob-property", $6);
1117 internal_type_checking_global_b = itc;
1118 t->set_mus_property ("grob-value", $8);
1120 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1121 csm->set_mus_property ("element", t->self_scm ());
1122 scm_gc_unprotect_object (t->self_scm ());
1124 $$->set_spot (THIS->here_input ());
1126 csm-> set_mus_property ("context-type", $2);
1128 | PROPERTY STRING '.' STRING OVERRIDE
1129 embedded_scm '=' embedded_scm
1135 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1136 bool itc = internal_type_checking_global_b;
1138 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1139 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1141 internal_type_checking_global_b = false;
1142 t->set_mus_property ("grob-property", $6);
1143 t->set_mus_property ("grob-value", $8);
1145 internal_type_checking_global_b = itc;
1147 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1148 csm->set_mus_property ("element", t->self_scm ());
1149 scm_gc_unprotect_object (t->self_scm ());
1152 $$->set_spot (THIS->here_input ());
1154 csm-> set_mus_property ("context-type", $2);
1157 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1158 Music *t = MY_MAKE_MUSIC("RevertProperty");
1160 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1161 bool itc = internal_type_checking_global_b;
1163 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1165 internal_type_checking_global_b = false;
1166 t->set_mus_property ("grob-property", $6);
1168 internal_type_checking_global_b = itc;
1170 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1171 csm->set_mus_property ("element", t->self_scm ());
1172 scm_gc_unprotect_object (t->self_scm ());
1175 $$->set_spot (THIS->here_input ());
1177 csm-> set_mus_property ("context-type", $2);
1184 | bare_int { $$ = gh_int2scm ($1); }
1185 | embedded_scm { $$ = $1; }
1186 | full_markup { $$ = $1; }
1193 } /*cont */ simple_element post_events {
1194 SCM elts = $3-> get_mus_property ("elements");
1196 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1197 scm_reverse_x ($4, SCM_EOL));
1199 $3-> set_mus_property ("elements", elts);
1203 | note_chord_element
1208 chord_body optional_notemode_duration post_events
1210 SCM dur = unsmob_duration ($2)->smobbed_copy();
1211 SCM es = $1->get_mus_property ("elements");
1212 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1214 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1215 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1216 es = gh_append2 (es, postevs);
1218 $1-> set_mus_property ("elements", es);
1224 CHORD_OPEN chord_body_elements CHORD_CLOSE
1226 $$ = MY_MAKE_MUSIC("EventChord");
1227 $$->set_mus_property ("elements",
1228 scm_reverse_x ($2, SCM_EOL));
1232 chord_body_elements:
1233 /* empty */ { $$ = SCM_EOL; }
1234 | chord_body_elements chord_body_element {
1235 $$ = gh_cons ($2->self_scm(), $1);
1236 scm_gc_unprotect_object ($2->self_scm());
1241 pitch exclamations questions post_events
1243 Music * n = MY_MAKE_MUSIC("NoteEvent");
1244 n->set_mus_property ("pitch", $1);
1246 n->set_mus_property ("cautionary", SCM_BOOL_T);
1247 if ($2 % 2 || $3 % 2)
1248 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1250 SCM arts = scm_reverse_x ($4, SCM_EOL);
1251 n->set_mus_property ("articulations", arts);
1259 $$ = MY_MAKE_MUSIC("EventChord");
1260 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1261 scm_gc_unprotect_object ($1->self_scm());
1263 $$-> set_spot (THIS->here_input ());
1264 $1-> set_spot (THIS->here_input ());
1267 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1268 l->set_mus_property ("span-direction", gh_int2scm (START));
1269 l->set_spot (THIS->here_input ());
1271 $$ = MY_MAKE_MUSIC("EventChord");
1272 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1273 scm_gc_unprotect_object (l->self_scm());
1274 $$->set_spot (THIS->here_input ());
1277 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1278 l->set_mus_property ("span-direction", gh_int2scm (STOP));
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 $$->set_spot (THIS->here_input ());
1284 scm_gc_unprotect_object (l->self_scm());
1287 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1288 $$->set_spot (THIS->here_input ());
1292 $$ = MY_MAKE_MUSIC("BarCheck");
1293 $$->set_spot (THIS->here_input ());
1296 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1298 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1299 csm->set_mus_property ("element", t->self_scm ());
1300 scm_gc_unprotect_object (t->self_scm ());
1303 $$->set_spot (THIS->here_input ());
1305 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1307 | PARTIAL duration_length {
1308 Moment m = - unsmob_duration ($2)->get_length ();
1309 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1311 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1312 sp->set_mus_property ("element", p->self_scm ());
1313 scm_gc_unprotect_object (p->self_scm ());
1316 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1321 proc = scm_c_eval_string ("make-clef-set");
1323 SCM result = scm_call_1 (proc, $2);
1324 scm_gc_protect_object (result);
1325 $$ = unsmob_music (result);
1330 proc = scm_c_eval_string ("make-time-signature-set");
1332 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1333 scm_gc_protect_object (result);
1334 $$ = unsmob_music (result);
1339 shorthand_command_req { $$ = $1; }
1340 | verbose_command_req { $$ = $1; }
1343 shorthand_command_req:
1351 $$ = MY_MAKE_MUSIC("TieEvent");
1354 Music *b= MY_MAKE_MUSIC("BeamEvent");
1355 b->set_mus_property ("span-direction", gh_int2scm (START));
1358 THIS->last_beam_start_ = b->self_scm ();
1361 Music *b= MY_MAKE_MUSIC("BeamEvent");
1362 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1366 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1369 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1373 verbose_command_req:
1375 Music * m = MY_MAKE_MUSIC("MarkEvent");
1379 Music *m = MY_MAKE_MUSIC("MarkEvent");
1380 m->set_mus_property ("label", $2);
1383 | SKIP duration_length {
1384 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1385 skip->set_mus_property ("duration", $2);
1393 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1396 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1397 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1399 key->set_mus_property ("pitch-alist", $3);
1400 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1401 ((Music*)key)->transpose (* unsmob_pitch ($2));
1411 | post_events post_event {
1412 $2->set_spot (THIS->here_input ());
1413 $$ = gh_cons ($2->self_scm(), $$);
1414 scm_gc_unprotect_object ($2->self_scm());
1427 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1428 s->set_mus_property ("string-number", gh_int2scm($1));
1429 s->set_spot (THIS->here_input ());
1435 event_that_take_dir:
1441 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1442 m->set_spot (THIS->here_input());
1443 m->set_mus_property ("span-direction" , gh_int2scm (START));
1447 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1448 m->set_spot (THIS->here_input());
1449 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1453 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1454 m->set_spot (THIS->here_input());
1457 | script_abbreviation {
1458 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1459 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1460 if (gh_string_p (s))
1461 a->set_mus_property ("articulation-type", s);
1462 else THIS->parser_error (_ ("Expecting string as script definition"));
1468 script_dir event_that_take_dir {
1469 $2->set_mus_property ("direction", gh_int2scm ($1));
1476 $$ = unsmob_music ($1);
1479 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1480 a->set_spot (THIS->here_input ());
1481 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1508 | NOTENAME_PITCH sup_quotes {
1509 Pitch p = *unsmob_pitch ($1);
1510 p = p.transposed (Pitch ($2,0,0));
1511 $$ = p.smobbed_copy ();
1513 | NOTENAME_PITCH sub_quotes {
1514 Pitch p =* unsmob_pitch ($1);
1515 p = p.transposed (Pitch (-$2,0,0));
1516 $$ = p.smobbed_copy ();
1528 | TONICNAME_PITCH sup_quotes {
1529 Pitch p = *unsmob_pitch ($1);
1530 p = p.transposed (Pitch ($2,0,0));
1531 $$ = p.smobbed_copy ();
1533 | TONICNAME_PITCH sub_quotes {
1534 Pitch p =* unsmob_pitch ($1);
1536 p = p.transposed (Pitch (-$2,0,0));
1537 $$ = p.smobbed_copy ();
1550 pitch_also_in_chords:
1556 PITCH embedded_scm {
1558 if (!unsmob_pitch ($2)) {
1559 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1560 $$ = Pitch ().smobbed_copy ();
1566 DURATION embedded_scm {
1568 if (!unsmob_duration ($2))
1570 THIS->parser_error (_ ("Must have duration object"));
1571 $$ = Duration ().smobbed_copy ();
1578 if (!THIS->lexer_->lyric_state_b ())
1579 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1580 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1586 if (!THIS->lexer_->lyric_state_b ())
1587 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1588 $$ = MY_MAKE_MUSIC("HyphenEvent");
1593 close_event_parens {
1595 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1602 Music * s= MY_MAKE_MUSIC("SlurEvent");
1604 s->set_spot (THIS->here_input());
1607 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1609 s->set_spot (THIS->here_input());
1612 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1614 s->set_spot (THIS->here_input());
1617 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1619 s->set_spot (THIS->here_input());
1627 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1634 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1635 s->set_spot (THIS->here_input());
1640 Music * s= MY_MAKE_MUSIC("SlurEvent");
1642 s->set_spot (THIS->here_input());
1646 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1648 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1649 s->set_spot (THIS->here_input());
1655 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1656 t->set_mus_property ("text", $1);
1657 t->set_spot (THIS->here_input ());
1661 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1662 t->set_mus_property ("text", $1);
1663 t->set_spot (THIS->here_input ());
1667 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1668 t->set_mus_property ("text", make_simple_markup ($1));
1669 t->set_spot (THIS->here_input ());
1674 Music * t = MY_MAKE_MUSIC("FingerEvent");
1675 t->set_mus_property ("digit", gh_int2scm ($1));
1676 t->set_spot (THIS->here_input ());
1681 script_abbreviation:
1683 $$ = scm_makfrom0str ("Hat");
1686 $$ = scm_makfrom0str ("Plus");
1689 $$ = scm_makfrom0str ("Dash");
1692 $$ = scm_makfrom0str ("Bar");
1695 $$ = scm_makfrom0str ("Larger");
1698 $$ = scm_makfrom0str ("Dot");
1701 $$ = scm_makfrom0str ("Underscore");
1708 | '-' { $$ = CENTER; }
1715 | pre_events open_event {
1716 $$ = gh_cons ($2->self_scm(), $$);
1717 scm_gc_unprotect_object ($2->self_scm());
1728 multiplied_duration {
1731 | verbose_duration {
1736 optional_notemode_duration:
1738 Duration dd = THIS->default_duration_;
1739 $$ = dd.smobbed_copy ();
1741 THIS->beam_check ($$);
1743 | multiplied_duration {
1745 THIS->default_duration_ = *unsmob_duration ($$);
1747 THIS->beam_check ($$);
1749 | verbose_duration {
1751 THIS->default_duration_ = *unsmob_duration ($$);
1756 bare_unsigned dots {
1758 if (!is_duration_b ($1))
1759 THIS->parser_error (_f ("not a duration: %d", $1));
1763 $$ = Duration (l, $2).smobbed_copy ();
1765 | DURATION_IDENTIFIER dots {
1766 Duration *d =unsmob_duration ($1);
1767 Duration k (d->duration_log (),d->dot_count () + $2);
1777 multiplied_duration:
1781 | multiplied_duration '*' bare_unsigned {
1782 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1784 | multiplied_duration '*' FRACTION {
1785 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1787 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1792 FRACTION { $$ = $1; }
1793 | UNSIGNED '/' UNSIGNED {
1794 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1812 | ':' bare_unsigned {
1813 if (!is_duration_b ($2))
1814 THIS->parser_error (_f ("not a duration: %d", $2));
1821 /*****************************************************************
1823 *****************************************************************/
1837 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1838 $$ = bfr->self_scm();
1839 scm_gc_unprotect_object ($$);
1842 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1843 $$ = bfr->self_scm();
1845 bfr->set_mus_property ("figure", gh_int2scm ($1));
1847 scm_gc_unprotect_object ($$);
1849 | bass_figure bass_mod {
1850 Music *m = unsmob_music ($1);
1852 SCM salter =m->get_mus_property ("alteration");
1853 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1854 m->set_mus_property ("alteration",
1855 gh_int2scm (alter + $2));
1857 m->set_mus_property ("alteration", gh_int2scm (0));
1865 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1870 | br_bass_figure ']' {
1872 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1880 | figure_list br_bass_figure {
1881 $$ = scm_cons ($2, $1);
1886 FIGURE_OPEN figure_list FIGURE_CLOSE {
1887 Music * m = MY_MAKE_MUSIC("EventChord");
1888 $2 = scm_reverse_x ($2, SCM_EOL);
1889 m->set_mus_property ("elements", $2);
1890 $$ = m->self_scm ();
1901 pitch exclamations questions optional_notemode_duration optional_rest {
1903 Input i = THIS->pop_spot ();
1904 if (!THIS->lexer_->note_state_b ())
1905 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1909 n = MY_MAKE_MUSIC("RestEvent");
1911 n = MY_MAKE_MUSIC("NoteEvent");
1913 n->set_mus_property ("pitch", $1);
1914 n->set_mus_property ("duration", $4);
1918 n->set_mus_property ("cautionary", SCM_BOOL_T);
1919 if ($2 % 2 || $3 % 2)
1920 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1922 Music *v = MY_MAKE_MUSIC("EventChord");
1923 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1924 scm_gc_unprotect_object (n->self_scm());
1930 | figure_spec optional_notemode_duration {
1931 Music * m = unsmob_music ($1);
1932 Input i = THIS->pop_spot ();
1934 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1936 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1940 | RESTNAME optional_notemode_duration {
1942 Input i = THIS->pop_spot ();
1944 if (ly_scm2string ($1) =="s") {
1946 ev = MY_MAKE_MUSIC("SkipEvent");
1949 ev = MY_MAKE_MUSIC("RestEvent");
1952 ev->set_mus_property ("duration" ,$2);
1954 Music * velt = MY_MAKE_MUSIC("EventChord");
1955 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1960 | MULTI_MEASURE_REST optional_notemode_duration {
1965 proc = scm_c_eval_string ("make-multi-measure-rest");
1967 SCM mus = scm_call_2 (proc, $2,
1968 make_input (THIS->here_input()));
1969 scm_gc_protect_object (mus);
1970 $$ = unsmob_music (mus);
1972 | STRING optional_notemode_duration {
1973 Input i = THIS->pop_spot ();
1975 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1976 lreq->set_mus_property ("text", $1);
1977 lreq->set_mus_property ("duration",$2);
1979 Music * velt = MY_MAKE_MUSIC("EventChord");
1980 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1987 if (!THIS->lexer_->chord_state_b ())
1988 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1989 $$ = unsmob_music ($1);
1994 steno_tonic_pitch optional_notemode_duration {
1995 $$ = make_chord ($1, $2, SCM_EOL)
1997 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
1998 SCM its = scm_reverse_x ($4, SCM_EOL);
1999 $$ = make_chord ($1, $2, gh_cons ($3, its));
2007 | chord_items chord_item {
2008 $$ = gh_cons ($2, $$);
2014 $$ = ly_symbol2scm ("chord-colon");
2017 $$ = ly_symbol2scm ("chord-caret");
2019 | CHORD_SLASH steno_tonic_pitch {
2020 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2022 | CHORD_BASS steno_tonic_pitch {
2023 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2032 $$ = scm_reverse_x ($1, SCM_EOL);
2040 step_number { $$ = gh_cons ($1, SCM_EOL); }
2041 | step_numbers '.' step_number {
2042 $$ = gh_cons ($3, $$);
2048 $$ = make_chord_step ($1, 0);
2050 | bare_unsigned '+' {
2051 $$ = make_chord_step ($1, 1);
2053 | bare_unsigned CHORD_MINUS {
2054 $$ = make_chord_step ($1,-1);
2062 number_expression '+' number_term {
2063 $$ = scm_sum ($1, $3);
2065 | number_expression '-' number_term {
2066 $$ = scm_difference ($1, $3);
2075 | number_factor '*' number_factor {
2076 $$ = scm_product ($1, $3);
2078 | number_factor '/' number_factor {
2079 $$ = scm_divide ($1, $3);
2084 '-' number_factor { /* %prec UNARY_MINUS */
2085 $$ = scm_difference ($2, SCM_UNDEFINED);
2093 $$ = gh_int2scm ($1);
2098 | NUMBER_IDENTIFIER {
2101 | REAL NUMBER_IDENTIFIER {
2102 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2104 | UNSIGNED NUMBER_IDENTIFIER {
2105 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2121 if (scm_integer_p ($1) == SCM_BOOL_T)
2123 int k = gh_scm2int ($1);
2127 THIS->parser_error (_ ("need integer number arg"));
2141 | STRING_IDENTIFIER {
2144 | string '+' string {
2145 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2152 | exclamations '!' { $$ ++; }
2157 | questions '?' { $$ ++; }
2167 { THIS->lexer_->push_markup_state (); }
2170 THIS->lexer_->pop_state ();
2176 $$ = make_simple_markup ($1);
2178 | MARKUP_HEAD_MARKUP0 markup {
2179 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2181 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2182 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2184 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2185 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2190 | MARKUP_HEAD_LIST0 markup_list {
2191 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2193 | MARKUP_HEAD_SCM0 embedded_scm {
2194 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2196 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2197 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2199 | MARKUP_IDENTIFIER {
2206 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2210 '{' markup_list_body '}' {
2213 line = scm_c_eval_string ("line-markup");
2215 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2220 /**/ { $$ = SCM_EOL; }
2221 | markup_list_body markup {
2222 $$ = gh_cons ($2, $1) ;
2230 My_lily_parser::set_yydebug (bool )
2237 extern My_lily_parser * current_parser;
2240 My_lily_parser::do_yyparse ()
2242 current_parser = this;;
2243 yyparse ((void*)this);
2248 Should make this optional? It will also complain when you do
2252 which is entirely legitimate.
2254 Or we can scrap it. Barchecks should detect wrong durations, and
2255 skipTypesetting speeds it up a lot.
2259 My_lily_parser::beam_check (SCM dur)
2261 Duration *d = unsmob_duration (dur);
2262 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2264 Music * m = unsmob_music (last_beam_start_);
2265 m->origin ()->warning (_("Suspect duration found following this beam"));
2267 last_beam_start_ = SCM_EOL;
2275 return gh_pair_p (x)
2276 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2279 It is a little strange, to have this function in this file, but
2280 otherwise, we have to import music classes into the lexer.
2284 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2286 if (gh_string_p (sid)) {
2288 return STRING_IDENTIFIER;
2289 } else if (gh_number_p (sid)) {
2291 return NUMBER_IDENTIFIER;
2292 } else if (unsmob_translator_def (sid)) {
2293 *destination = unsmob_translator_def (sid)->clone_scm();
2294 return TRANSLATOR_IDENTIFIER;
2295 } else if (unsmob_score (sid)) {
2296 Score *sc = new Score (*unsmob_score (sid));
2297 *destination =sc->self_scm ();
2298 return SCORE_IDENTIFIER;
2299 } else if (Music * mus =unsmob_music (sid)) {
2300 *destination = unsmob_music (sid)->clone ()->self_scm();
2301 unsmob_music (*destination)->
2302 set_mus_property ("origin", make_input (last_input_));
2303 return dynamic_cast<Event*> (mus)
2304 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2305 } else if (unsmob_duration (sid)) {
2306 *destination = unsmob_duration (sid)->smobbed_copy();
2307 return DURATION_IDENTIFIER;
2308 } else if (unsmob_music_output_def (sid)) {
2309 Music_output_def *p = unsmob_music_output_def (sid);
2312 *destination = p->self_scm();
2313 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2314 } else if (new_markup_p (sid)) {
2316 return MARKUP_IDENTIFIER;