1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Four shift/reduce problems:
17 "bar" -> String -> Lyric -> Music -> music-assignment
19 "bar" -> String -> string-assignment
29 \repeat .. \alternative
32 \repeat { \repeat .. \alternative }
36 \repeat { \repeat } \alternative
48 * The rules for who is protecting what are very shady. Uniformise
51 * There are too many lexical modes?
60 #include "scm-option.hh"
61 #include "context-def.hh"
62 #include "lily-guile.hh"
64 #include "my-lily-lexer.hh"
65 #include "paper-def.hh"
66 #include "midi-def.hh"
68 #include "file-path.hh"
70 #include "dimensions.hh"
71 #include "my-lily-parser.hh"
73 #include "input-file-results.hh"
75 #include "lilypond-input-version.hh"
76 #include "scm-hash.hh"
77 #include "ly-module.hh"
78 #include "music-sequence.hh"
79 #include "input-smob.hh"
81 #include "text-item.hh"
82 #include "music-list.hh"
83 #include "paper-book.hh"
85 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
87 Music *property_op_to_music (SCM op);
88 Music *context_spec_music (SCM type, SCM id, Music * m, SCM ops_);
89 SCM get_next_unique_context ();
91 #define YYERROR_VERBOSE 1
93 My_lily_parser* my_lily_parser;
94 #define YYPARSE_PARAM my_lily_parser
95 #define YYLEX_PARAM my_lily_parser
97 ((My_lily_parser *) my_lily_parser)
99 #define yyerror THIS->parser_error
102 Add symbols to the TAGS field of a music object.
106 tag_music (Music*m, SCM tag, Input ip)
108 SCM tags = m->get_property ("tags");
109 if (gh_symbol_p (tag))
110 tags = scm_cons (tag, tags);
111 else if (gh_list_p (tag))
112 tags = gh_append2 (tag, tags);
114 ip.warning (_("Tag must be symbol or list of symbols."));
116 m->set_property ("tags", tags);
122 is_regular_identifier (SCM id)
124 String str = ly_scm2string (id);
125 char const *s = str.to_str0 () ;
134 v = v && isalnum (*s);
141 make_simple_markup (SCM a)
145 simple = scm_c_eval_string ("simple-markup");
147 return scm_list_2 (simple, a);
152 is_is_duration (int t)
154 return t && t == 1 << intlog2 (t);
158 set_music_properties (Music *p, SCM a)
160 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
162 p->internal_set_property (ly_caar (k), ly_cdar (k));
167 make_chord_step (int step, int alter)
174 Pitch m((step -1) / 7 , (step - 1) % 7, alter);
175 return m.smobbed_copy ();
180 make_chord (SCM pitch, SCM dur, SCM modification_list)
182 static SCM chord_ctor;
184 chord_ctor= scm_c_eval_string ("construct-chord");
185 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
186 scm_gc_protect_object (ch);
191 Todo: actually also use apply iso. call too ...
194 ly_input_procedure_p (SCM x)
196 return gh_procedure_p (x)
197 || (gh_pair_p (x) && gh_procedure_p (gh_car (x)));
201 set_property_music (SCM sym, SCM value)
203 Music * p = MY_MAKE_MUSIC ("PropertySet");
204 p->set_property ("symbol", sym);
205 p->set_property ("value", value);
211 /* We use SCMs to do strings, because it saves us the trouble of
212 deleting them. Let's hope that a stack overflow doesnt trigger a move
213 of the parse stack onto the heap. */
220 Music_output_def * outputdef;
227 yylex (YYSTYPE *s, void * v)
229 My_lily_parser *pars = (My_lily_parser*) v;
230 My_lily_lexer * lex = pars->lexer_;
232 lex->lexval = (void*) s;
233 lex->prepare_for_next_token ();
234 return lex->yylex ();
256 %token CHORDMODIFIERS
261 %token COMMANDSPANREQUEST
269 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
270 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
274 %token GROBDESCRIPTIONS
282 %token MULTI_MEASURE_REST
288 %token OVERRIDE SET REVERT
314 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
315 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
317 %token <i> E_UNSIGNED
318 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
321 %type <i> exclamations questions dots optional_rest
323 %type <scm> grace_head
324 %type <scm> oct_check
325 %type <scm> context_mod_list
326 %type <scm> lyric_element
327 %type <scm> bass_number br_bass_figure bass_figure figure_list figure_spec
329 %token <scm> NOTENAME_PITCH
330 %token <scm> TONICNAME_PITCH
331 %token <scm> CHORDMODIFIER_PITCH
332 %token <scm> DURATION_IDENTIFIER
333 %token <scm> FRACTION
334 %token <id> IDENTIFIER
336 %token <scm> DRUM_PITCH
337 %token <scm> CHORD_MODIFIER
338 %token <scm> SCORE_IDENTIFIER
339 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
340 %token <scm> NUMBER_IDENTIFIER
341 %token <scm> EVENT_IDENTIFIER
342 %token <scm> MUSIC_IDENTIFIER CONTEXT_DEF_IDENTIFIER
343 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
344 %token <scm> RESTNAME
351 %token <scm> MARKUP_HEAD_MARKUP0
352 %token <scm> MARKUP_HEAD_EMPTY
353 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
354 %token <scm> MARKUP_HEAD_SCM0
355 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
356 %token <scm> MARKUP_HEAD_SCM0_SCM1
357 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
358 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
360 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
361 %type <scm> markup markup_line markup_list markup_list_body full_markup
363 %type <outputdef> output_def
364 %type <scm> lilypond_header lilypond_header_body
365 %type <music> open_event close_event
366 %type <i> sub_quotes sup_quotes
367 %type <music> simple_element event_chord command_element Simple_music Composite_music
368 %type <music> Repeated_music
369 %type <scm> Alternative_music
370 %type <i> tremolo_type
371 %type <i> bare_int bare_unsigned
373 %type <scm> identifier_init
375 %type <music> note_chord_element chord_body chord_body_element
376 %type <scm> chord_body_elements
377 %type <scm> steno_duration optional_notemode_duration multiplied_duration
379 %type <scm> post_events
380 %type <music> gen_text_def direction_less_event direction_reqd_event
381 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
382 %type <scm> steno_tonic_pitch
383 %type <scm> duration_length fraction
385 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
387 %type <scm> embedded_scm scalar
388 %type <music> Music Sequential_music Simultaneous_music
389 %type <music> relative_music re_rhythmed_music
390 %type <music> music_property_def context_change
391 %type <scm> context_prop_spec
392 %type <scm> Music_list
393 %type <scm> property_operation context_mod context_def_mod optional_context_mod
394 %type <outputdef> music_output_def_body music_output_def_head
395 %type <music> post_event tagged_post_event
396 %type <music> command_req
397 %type <music> string_number_event
398 %type <scm> string bare_number number_expression number_term number_factor
399 %type <score> score_block score_body
401 %type <scm> context_def_spec_block context_def_spec_body
402 %type <music> tempo_event
403 %type <scm> script_abbreviation
409 /* We don't assign precedence to / and *, because we might need varied
410 prec levels in different prods */
416 lilypond: /* empty */
417 | lilypond toplevel_expression {}
418 | lilypond assignment { }
420 THIS->error_level_ = 1;
423 THIS->error_level_ = 1;
429 THIS->input_file_->header_ = $1;
436 SCM head = ly_module_p (sc->header_) ? sc->header_ : THIS->input_file_->header_.to_SCM ();
438 Path p = split_path (THIS->output_basename_);
439 int *c = &THIS->input_file_->score_count_;
442 p.base += "-" + to_string (*c);
446 SCM outname = scm_makfrom0str (p.to_string ().to_str0());
448 for (int i=0; i < sc->defs_.size (); i++)
449 default_rendering (sc->music_, sc->defs_[i]->self_scm (), head, outname);
451 if (sc->defs_.is_empty ())
453 Music_output_def *id =
454 unsmob_music_output_def (THIS->lexer_->lookup_identifier
457 id = id ? id->clone () : new Paper_def;
459 default_rendering (sc->music_, id->self_scm (), head, outname);
460 scm_gc_unprotect_object (id->self_scm ());
462 scm_gc_unprotect_object (sc->self_scm ());
466 if (dynamic_cast<Paper_def*> ($1))
467 id = scm_makfrom0str ("$defaultpaper");
468 else if (dynamic_cast<Midi_def*> ($1))
469 id = scm_makfrom0str ("$defaultmidi");
470 THIS->lexer_->set_identifier (id, $1->self_scm ());
471 scm_gc_unprotect_object ($1->self_scm ());
484 lilypond_header_body:
486 $$ = ly_make_anonymous_module ();
487 THIS->lexer_->add_scope ($$);
489 | lilypond_header_body assignment {
495 HEADER '{' lilypond_header_body '}' {
496 $$ = THIS->lexer_->remove_scope ();
508 /* cont */ '=' identifier_init {
511 Should find generic way of associating input with objects.
513 Input ip = THIS->pop_spot ();
515 if (! is_regular_identifier ($1))
517 ip.warning (_ ("Identifier should have alphabetic characters only"));
520 THIS->lexer_->set_identifier ($1, $4);
523 TODO: devise standard for protection in parser.
525 The parser stack lives on the C-stack, which means that
526 all objects can be unprotected as soon as they're here.
536 $$ = $1->self_scm ();
537 scm_gc_unprotect_object ($$);
543 $$ = $1->self_scm ();
544 scm_gc_unprotect_object ($$);
546 | context_def_spec_block {
550 $$ = $1->self_scm ();
551 scm_gc_unprotect_object ($$);
554 $$ = $1->self_scm ();
555 scm_gc_unprotect_object ($$);
557 | number_expression {
568 context_def_spec_block:
569 CONTEXT '{' context_def_spec_body '}'
575 context_def_spec_body:
577 $$ = Context_def::make_scm ();
578 unsmob_context_def ($$)->set_spot (THIS->here_input ());
580 | CONTEXT_DEF_IDENTIFIER {
582 unsmob_context_def ($$)->set_spot (THIS->here_input ());
584 | context_def_spec_body GROBDESCRIPTIONS embedded_scm {
585 Context_def*td = unsmob_context_def ($$);
587 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p)) {
588 SCM tag = gh_caar (p);
590 /* TODO: should make new tag "grob-definition" ? */
591 td->add_context_mod (scm_list_3 (ly_symbol2scm ("assign"),
592 tag, gh_cons (ly_cdar (p), SCM_EOL)));
595 | context_def_spec_body context_mod {
596 unsmob_context_def ($$)->add_context_mod ($2);
607 /*cont*/ '{' score_body '}' {
618 $$->set_spot (THIS->here_input ());
619 SCM m = $1->self_scm ();
620 scm_gc_unprotect_object (m);
625 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
626 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
627 m = gh_call1 (gh_car (check_funcs), m);
632 $$ = new Score ( *unsmob_score ($1));
633 $$->set_spot (THIS->here_input ());
635 | score_body lilypond_header {
638 | score_body output_def {
640 scm_gc_unprotect_object ($2->self_scm ());
652 music_output_def_body '}' {
654 THIS-> lexer_-> remove_scope ();
658 music_output_def_head:
660 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
665 p = dynamic_cast<Midi_def*> (id->clone ());
670 THIS->lexer_->add_scope (p->scope_);
673 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
676 p = dynamic_cast<Paper_def*> (id->clone ());
680 THIS->lexer_->add_scope (p->scope_);
686 music_output_def_body:
687 music_output_def_head '{' {
690 | music_output_def_head '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
691 scm_gc_unprotect_object ($1->self_scm ());
692 Music_output_def * o = unsmob_music_output_def ($3);
694 THIS->lexer_->remove_scope ();
695 THIS->lexer_->add_scope (o->scope_);
697 | music_output_def_body assignment {
700 | music_output_def_body context_def_spec_block {
701 $$->assign_context_def ($2);
703 | music_output_def_body tempo_event {
705 junk this ? there already is tempo stuff in
708 int m = gh_scm2int ( $2->get_property ("metronome-count"));
709 Duration *d = unsmob_duration ($2->get_property ("tempo-unit"));
710 Midi_def * md = dynamic_cast<Midi_def*> ($$);
712 md->set_tempo (d->get_length (), m);
713 scm_gc_unprotect_object ($2->self_scm ());
715 | music_output_def_body error {
721 TEMPO steno_duration '=' bare_unsigned {
722 $$ = MY_MAKE_MUSIC ("MetronomeChangeEvent");
723 $$->set_property ("tempo-unit", $2);
724 $$->set_property ("metronome-count", gh_int2scm ( $4));
729 The representation of a list is the
733 to have efficient append.
737 $$ = scm_cons (SCM_EOL, SCM_EOL);
741 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
742 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
743 if (gh_pair_p (ly_cdr (s)))
744 gh_set_cdr_x (ly_cdr (s), c); /* append */
746 gh_set_car_x (s, c); /* set first cons */
747 gh_set_cdr_x (s, c) ; /* remember last cell */
763 | ALTERNATIVE '{' Music_list '}' {
769 REPEAT string bare_unsigned Music Alternative_music
773 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
774 if (times < scm_ilength (alts)) {
775 unsmob_music (gh_car (alts))
776 ->origin ()->warning (
777 _("More alternatives than repeats. Junking excess alternatives."));
778 alts = ly_truncate_list (times, alts);
784 proc = scm_c_eval_string ("make-repeated-music");
786 SCM mus = scm_call_1 (proc, $2);
787 scm_gc_protect_object (mus); // UGH.
788 Music *r =unsmob_music (mus);
791 r-> set_property ("element", beg->self_scm ());
792 scm_gc_unprotect_object (beg->self_scm ());
794 r->set_property ("repeat-count", gh_int2scm (times >? 1));
796 r-> set_property ("elements",alts);
797 if (gh_equal_p ($2, scm_makfrom0str ("tremolo"))) {
799 we can not get durations and other stuff correct down the line, so we have to
800 add to the duration log here.
805 func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
807 int dots = ($3 % 3) ? 0 : 1;
808 int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
810 Sequential_music * seq = dynamic_cast<Sequential_music*> ($4);
813 int list_len =scm_ilength (seq->music_list ());
815 seq->origin ()->warning ("Chord tremolo must have 2 elements.");
817 r->compress (Moment (Rational (1,list_len)));
819 gh_call3 (func, r->self_scm (), gh_int2scm (shift),gh_int2scm (dots));
822 r->set_spot (*$4->origin ());
829 SEQUENTIAL '{' Music_list '}' {
830 $$ = MY_MAKE_MUSIC ("SequentialMusic");
831 $$->set_property ("elements", ly_car ($3));
832 $$->set_spot (THIS->here_input ());
834 | '{' Music_list '}' {
835 $$ = MY_MAKE_MUSIC ("SequentialMusic");
836 $$->set_property ("elements", ly_car ($2));
837 $$->set_spot (THIS->here_input ());
842 SIMULTANEOUS '{' Music_list '}'{
843 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
844 $$->set_property ("elements", ly_car ($3));
845 $$->set_spot (THIS->here_input ());
848 | simul_open Music_list simul_close {
849 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
850 $$->set_property ("elements", ly_car ($2));
851 $$->set_spot (THIS->here_input ());
856 event_chord { $$ = $1; }
857 | APPLYOUTPUT embedded_scm {
858 if (!ly_input_procedure_p ($2))
859 THIS->parser_error (_ ("\\applycontext takes function argument"));
860 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
861 $$->set_property ("procedure", $2);
862 $$->set_spot (THIS->here_input ());
864 | APPLYCONTEXT embedded_scm {
865 if (!ly_input_procedure_p ($2))
866 THIS->parser_error (_ ("\\applycontext takes function argument"));
867 $$ = MY_MAKE_MUSIC ("ApplyContext");
868 $$->set_property ("procedure", $2);
869 $$->set_spot (THIS->here_input ());
872 $$ = unsmob_music ($1);
879 optional_context_mod:
880 /**/ { $$ = SCM_EOL; }
881 | WITH '{' context_mod_list '}' { $$ = $3; }
885 GRACE { $$ = scm_makfrom0str ("Grace"); }
886 | ACCIACCATURA { $$ = scm_makfrom0str ("Acciaccatura"); }
887 | APPOGGIATURA { $$ = scm_makfrom0str ("Appoggiatura"); }
891 /* */ { $$ = SCM_EOL; }
892 | context_mod_list context_mod {
893 $$ = gh_cons ($2, $1);
901 proc = scm_c_eval_string ("make-autochange-music");
903 SCM res = scm_call_1 (proc, $2->self_scm ());
904 scm_gc_unprotect_object ($2->self_scm ());
905 $$ = unsmob_music (res);
906 scm_gc_protect_object (res);
907 $$->set_spot (THIS->here_input ());
909 | PARTCOMBINE Music Music {
912 proc = scm_c_eval_string ("make-part-combine-music");
914 SCM res = scm_call_1 (proc, gh_list ($2->self_scm (),
915 $3->self_scm (), SCM_UNDEFINED));
916 scm_gc_unprotect_object ($3->self_scm ());
917 scm_gc_unprotect_object ($2->self_scm ());
918 $$ = unsmob_music (res);
919 scm_gc_protect_object (res);
920 $$->set_spot (THIS->here_input ());
925 The other version is for easier debugging of
926 Sequential_music_iterator in combination with grace notes.
931 TODO: should distinguish between both grace types in the
932 basic music objects too, since the meaning is different.
936 String start_str = "start" + ly_scm2string ($1) + "Music";
937 String stop_str = "stop" + ly_scm2string ($1) + "Music";
939 SCM start = THIS->lexer_->lookup_identifier (start_str);
940 SCM stop = THIS->lexer_->lookup_identifier (stop_str);
942 Music *startm = unsmob_music (start);
943 Music *stopm = unsmob_music (stop);
947 stopm = stopm->clone ();
948 ms = scm_cons (stopm->self_scm (), ms);
949 scm_gc_unprotect_object (stopm->self_scm ());
951 ms = scm_cons ($2->self_scm (), ms);
952 scm_gc_unprotect_object ($2->self_scm ());
954 startm = startm->clone ();
955 ms = scm_cons (startm->self_scm () , ms);
956 scm_gc_unprotect_object (startm->self_scm ());
959 Music* seq = MY_MAKE_MUSIC ("SequentialMusic");
960 seq->set_property ("elements", ms);
963 $$ = MY_MAKE_MUSIC ("GraceMusic");
964 $$->set_property ("element", seq->self_scm ());
965 scm_gc_unprotect_object (seq->self_scm ());
967 $$ = MY_MAKE_MUSIC ("GraceMusic");
968 $$->set_property ("element", $2->self_scm ());
969 scm_gc_unprotect_object ($2->self_scm ());
972 | CONTEXT string '=' string optional_context_mod Music {
973 $$ = context_spec_music ($2, $4, $6, $5);
976 | CONTEXT STRING optional_context_mod Music {
977 $$ = context_spec_music ($2, SCM_UNDEFINED, $4, $3);
979 | NEWCONTEXT string optional_context_mod Music {
980 $$ = context_spec_music ($2, get_next_unique_context (),
991 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
994 $$= MY_MAKE_MUSIC ("TimeScaledMusic");
995 $$->set_spot (THIS->pop_spot ());
997 $$->set_property ("element", mp->self_scm ());
998 scm_gc_unprotect_object (mp->self_scm ());
999 $$->set_property ("numerator", gh_int2scm (n));
1000 $$->set_property ("denominator", gh_int2scm (d));
1001 $$->compress (Moment (Rational (n,d)));
1004 | Repeated_music { $$ = $1; }
1005 | Simultaneous_music { $$ = $1; }
1006 | Sequential_music { $$ = $1; }
1007 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
1008 $$ = MY_MAKE_MUSIC ("TransposedMusic");
1010 Pitch from = *unsmob_pitch ($2);
1011 Pitch to = *unsmob_pitch ($3);
1013 p->transpose (interval (from, to));
1014 $$->set_property ("element", p->self_scm ());
1015 scm_gc_unprotect_object (p->self_scm ());
1017 | APPLY embedded_scm Music {
1018 if (!ly_input_procedure_p ($2))
1020 THIS->parser_error (_ ("\\apply takes function argument"));
1025 SCM ret = gh_call1 ($2, $3->self_scm ());
1026 Music *m = unsmob_music (ret);
1028 THIS->parser_error ("\\apply must return a Music");
1029 m = MY_MAKE_MUSIC ("Music");
1036 SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
1037 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1041 THIS->lexer_->pop_state ();
1045 SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
1046 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1050 THIS->lexer_->pop_state ();
1053 { THIS->lexer_->push_figuredbass_state (); }
1056 Music * chm = MY_MAKE_MUSIC ("UntransposableMusic");
1057 chm->set_property ("element", $3->self_scm ());
1059 scm_gc_unprotect_object ($3->self_scm ());
1061 THIS->lexer_->pop_state ();
1064 SCM nn = THIS->lexer_->lookup_identifier ("chordmodifiers");
1065 THIS->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
1066 nn = THIS->lexer_->lookup_identifier ("pitchnames");
1067 THIS->lexer_->push_chord_state (alist_to_hashq (nn));
1070 Music * chm = MY_MAKE_MUSIC ("UnrelativableMusic");
1071 chm->set_property ("element", $3->self_scm ());
1072 scm_gc_unprotect_object ($3->self_scm ());
1075 THIS->lexer_->pop_state ();
1078 { THIS->lexer_->push_lyric_state (); }
1082 THIS->lexer_->pop_state ();
1084 | relative_music { $$ = $1; }
1085 | re_rhythmed_music { $$ = $1; }
1086 | TAG embedded_scm Music {
1087 tag_music ($3, $2, THIS->here_input ());
1093 RELATIVE absolute_pitch Music {
1095 Pitch pit = *unsmob_pitch ($2);
1096 $$ = MY_MAKE_MUSIC ("RelativeOctaveMusic");
1098 $$->set_property ("element", p->self_scm ());
1099 scm_gc_unprotect_object (p->self_scm ());
1102 Pitch retpitch = p->to_relative_octave (pit);
1103 if (lily_1_8_relative)
1104 $$->set_property ("last-pitch", retpitch.smobbed_copy ());
1109 ADDLYRICS Music Music {
1110 Music*l =MY_MAKE_MUSIC ("LyricCombineMusic");
1111 l->set_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1112 scm_gc_unprotect_object ($3->self_scm ());
1113 scm_gc_unprotect_object ($2->self_scm ());
1116 | NEWADDLYRICS string Music {
1117 Music*l =MY_MAKE_MUSIC ("NewLyricCombineMusic");
1118 l->set_property ("element", $3->self_scm ());
1119 scm_gc_unprotect_object ($3->self_scm ());
1121 l->set_property ("associated-context", $2);
1126 CHANGE STRING '=' STRING {
1127 Music*t= MY_MAKE_MUSIC ("ContextChange");
1128 t-> set_property ("change-to-type", scm_string_to_symbol ($2));
1129 t-> set_property ("change-to-id", $4);
1132 $$->set_spot (THIS->here_input ());
1138 $$ = scm_list_3 (ly_symbol2scm ("assign"),
1139 scm_string_to_symbol ($1), $3);
1142 $$ = scm_list_2 (ly_symbol2scm ("unset"),
1143 scm_string_to_symbol ($2));
1145 | OVERRIDE STRING embedded_scm '=' embedded_scm {
1146 $$ = scm_list_4 (ly_symbol2scm ("push"),
1147 scm_string_to_symbol ($2), $3, $5);
1149 | REVERT STRING embedded_scm {
1150 $$ = scm_list_3 (ly_symbol2scm ("pop"),
1151 scm_string_to_symbol ($2), $3);
1156 CONSISTSEND { $$ = ly_symbol2scm ("consists-end"); }
1157 | CONSISTS { $$ = ly_symbol2scm ("consists"); }
1158 | REMOVE { $$ = ly_symbol2scm ("remove"); }
1160 | ACCEPTS { $$ = ly_symbol2scm ("accepts"); }
1161 | DENIES { $$ = ly_symbol2scm ("denies"); }
1163 | ALIAS { $$ = ly_symbol2scm ("alias"); }
1164 | TYPE { $$ = ly_symbol2scm ("translator-type"); }
1165 | DESCRIPTION { $$ = ly_symbol2scm ("description"); }
1166 | NAME { $$ = ly_symbol2scm ("context-name"); }
1170 property_operation { $$ = $1; }
1171 | context_def_mod STRING {
1172 $$ = scm_list_2 ($1, $2);
1178 $$ = scm_list_2 (ly_symbol2scm ("Bottom"), scm_string_to_symbol ($1));
1180 | STRING '.' STRING {
1181 $$ = scm_list_2 (scm_string_to_symbol ($1), scm_string_to_symbol ($3));
1186 OVERRIDE context_prop_spec embedded_scm '=' scalar {
1187 $$ = property_op_to_music (scm_list_4 (
1188 ly_symbol2scm ("poppush"),
1191 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1193 | REVERT context_prop_spec embedded_scm {
1194 $$ = property_op_to_music (scm_list_3 (
1195 ly_symbol2scm ("pop"),
1199 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1201 | SET context_prop_spec '=' scalar {
1202 $$ = property_op_to_music (scm_list_3 (
1203 ly_symbol2scm ("assign"),
1206 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1208 | UNSET context_prop_spec {
1209 $$ = property_op_to_music (scm_list_2 (
1210 ly_symbol2scm ("unset"),
1212 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1214 | ONCE music_property_def {
1215 SCM e = $2->get_property ("element");
1216 unsmob_music (e)->set_property ("once", SCM_BOOL_T);
1226 | bare_int { $$ = gh_int2scm ($1); }
1227 | embedded_scm { $$ = $1; }
1228 | full_markup { $$ = $1; }
1229 | DIGIT { $$ = gh_int2scm ($1); }
1235 Adding pre_events to the simple_element
1236 makes the choice between
1242 simple_element: STRING
1244 a single shift/reduction conflict.
1246 nevertheless, this is not very clean, and we should find a different
1256 pre_events simple_element post_events {
1257 SCM elts = $2-> get_property ("elements");
1259 elts = gh_append2 (elts, scm_reverse_x ($3, SCM_EOL));
1261 $2->set_property ("elements", elts);
1265 | note_chord_element
1270 chord_body optional_notemode_duration post_events
1272 SCM dur = unsmob_duration ($2)->smobbed_copy ();
1273 SCM es = $1->get_property ("elements");
1274 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1276 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1277 unsmob_music (gh_car (s))->set_property ("duration", dur);
1278 es = gh_append2 (es, postevs);
1280 $1-> set_property ("elements", es);
1291 simul_open: LESSLESS
1294 simul_close: MOREMORE
1298 chord_open chord_body_elements chord_close
1300 $$ = MY_MAKE_MUSIC ("EventChord");
1301 $$->set_property ("elements",
1302 scm_reverse_x ($2, SCM_EOL));
1306 chord_body_elements:
1307 /* empty */ { $$ = SCM_EOL; }
1308 | chord_body_elements chord_body_element {
1309 $$ = gh_cons ($2->self_scm (), $1);
1310 scm_gc_unprotect_object ($2->self_scm ());
1315 pitch exclamations questions post_events
1317 Music * n = MY_MAKE_MUSIC ("NoteEvent");
1318 n->set_property ("pitch", $1);
1320 n->set_property ("cautionary", SCM_BOOL_T);
1321 if ($2 % 2 || $3 % 2)
1322 n->set_property ("force-accidental", SCM_BOOL_T);
1324 if (gh_pair_p ($4)) {
1325 SCM arts = scm_reverse_x ($4, SCM_EOL);
1326 n->set_property ("articulations", arts);
1330 | DRUM_PITCH post_events {
1331 Music *n = MY_MAKE_MUSIC ("NoteEvent");
1332 n->set_property ("duration" ,$2);
1333 n->set_property ("drum-type" , $1);
1334 n->set_spot (THIS->here_input ());
1336 if (gh_pair_p ($2)) {
1337 SCM arts = scm_reverse_x ($2, SCM_EOL);
1338 n->set_property ("articulations", arts);
1345 ADDQUOTE string Music {
1348 adder = scm_c_eval_string ("add-quotable");
1350 scm_call_2 (adder, $2, $3->self_scm ());
1351 scm_gc_unprotect_object ($3->self_scm ());
1357 $$ = MY_MAKE_MUSIC ("EventChord");
1358 $$->set_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1359 scm_gc_unprotect_object ($1->self_scm ());
1361 $$-> set_spot (THIS->here_input ());
1362 $1-> set_spot (THIS->here_input ());
1364 | SKIP duration_length {
1365 Music * skip = MY_MAKE_MUSIC ("SkipMusic");
1366 skip->set_property ("duration", $2);
1370 | QUOTE STRING duration_length {
1371 SCM tab = THIS->lexer_->lookup_identifier ("musicQuotes");
1373 if (scm_hash_table_p (tab) == SCM_BOOL_T)
1375 SCM key = $2; // use symbol?
1376 evs = scm_hash_ref (tab, key, SCM_BOOL_F);
1379 if (gh_vector_p (evs))
1381 quote = MY_MAKE_MUSIC ("QuoteMusic");
1382 quote->set_property ("duration", $3);
1383 quote->set_property ("quoted-events", evs);
1385 THIS->here_input ().warning (_f ("Can\'t find music"));
1386 quote = MY_MAKE_MUSIC ("Event");
1388 quote->set_spot (THIS->here_input ());
1391 | OCTAVE { THIS->push_spot (); }
1393 Music *l = MY_MAKE_MUSIC ("RelativeOctaveCheck");
1395 $$->set_spot (THIS->pop_spot ());
1396 $$->set_property ("pitch", $3);
1399 Music *l = MY_MAKE_MUSIC ("LigatureEvent");
1400 l->set_property ("span-direction", gh_int2scm (START));
1401 l->set_spot (THIS->here_input ());
1403 $$ = MY_MAKE_MUSIC ("EventChord");
1404 $$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1405 scm_gc_unprotect_object (l->self_scm ());
1406 $$->set_spot (THIS->here_input ());
1409 Music *l = MY_MAKE_MUSIC ("LigatureEvent");
1410 l->set_property ("span-direction", gh_int2scm (STOP));
1411 l->set_spot (THIS->here_input ());
1413 $$ = MY_MAKE_MUSIC ("EventChord");
1414 $$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1415 $$->set_spot (THIS->here_input ());
1416 scm_gc_unprotect_object (l->self_scm ());
1419 $$ = MY_MAKE_MUSIC ("VoiceSeparator");
1420 $$->set_spot (THIS->here_input ());
1424 $$ = MY_MAKE_MUSIC ("BarCheck");
1425 $$->set_spot (THIS->here_input ());
1427 | TRANSPOSITION pitch {
1428 $$ = set_property_music (ly_symbol2scm ("instrumentTransposition"),
1430 $$->set_spot (THIS-> here_input ());
1431 $$ = context_spec_music (ly_symbol2scm ("Staff"), SCM_UNDEFINED,
1435 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1437 Music *csm = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1439 $$ = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED, csm, SCM_EOL);
1440 $$->set_spot (THIS->here_input ());
1441 t->set_spot (THIS->here_input ());
1443 | PARTIAL duration_length {
1444 Moment m = - unsmob_duration ($2)->get_length ();
1445 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1446 p->set_spot (THIS->here_input ());
1447 p = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1449 p = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED,
1456 proc = scm_c_eval_string ("make-clef-set");
1458 SCM result = scm_call_1 (proc, $2);
1459 scm_gc_protect_object (result);
1460 $$ = unsmob_music (result);
1465 proc = scm_c_eval_string ("make-time-signature-set");
1467 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1468 scm_gc_protect_object (result);
1469 $$ = unsmob_music (result);
1474 proc = scm_c_eval_string ("make-mark-set");
1476 SCM result = scm_call_1 (proc, $2);
1477 scm_gc_protect_object (result);
1478 $$ = unsmob_music (result);
1484 $$ = MY_MAKE_MUSIC ("BreathingSignEvent");
1487 $$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
1490 Music * m = MY_MAKE_MUSIC ("MarkEvent");
1497 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1500 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1502 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1503 if (scm_ilength ($3) > 0)
1505 key->set_property ("pitch-alist", $3);
1506 key->set_property ("tonic", Pitch (0,0,0).smobbed_copy ());
1507 ((Music*)key)->transpose (* unsmob_pitch ($2));
1509 THIS->parser_error (_("Second argument must be pitch list."));
1520 | post_events post_event {
1521 $2->set_spot (THIS->here_input ());
1522 $$ = gh_cons ($2->self_scm (), $$);
1523 scm_gc_unprotect_object ($2->self_scm ());
1525 | post_events tagged_post_event {
1526 $2 -> set_spot (THIS->here_input ());
1527 $$ = scm_cons ($2->self_scm (), $$);
1528 scm_gc_unprotect_object ($2->self_scm ());
1534 '-' TAG embedded_scm post_event {
1535 tag_music ($4, $3, THIS->here_input ());
1541 direction_less_event {
1545 if (!THIS->lexer_->is_lyric_state ())
1546 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1547 $$ = MY_MAKE_MUSIC ("HyphenEvent");
1550 if (!THIS->lexer_->is_lyric_state ())
1551 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1552 $$ = MY_MAKE_MUSIC ("ExtenderEvent");
1554 | script_dir direction_reqd_event {
1556 $2->set_property ("direction", gh_int2scm ($1));
1559 | script_dir direction_less_event {
1561 $2->set_property ("direction", gh_int2scm ($1));
1564 | string_number_event
1567 string_number_event:
1569 Music * s = MY_MAKE_MUSIC ("StringNumberEvent");
1570 s->set_property ("string-number", gh_int2scm ($1));
1571 s->set_spot (THIS->here_input ());
1577 direction_less_event:
1583 TODO: should take all these defs out of the parser, adn make use
1587 (set-articulation '~ "trill")
1590 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1591 m->set_spot (THIS->here_input ());
1592 m->set_property ("span-direction" , gh_int2scm (START));
1596 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1597 m->set_spot (THIS->here_input ());
1598 m->set_property ("span-direction" , gh_int2scm (STOP));
1602 Music * m = MY_MAKE_MUSIC ("TieEvent");
1603 m->set_spot (THIS->here_input ());
1608 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1609 gh_int2scm (START));
1613 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1616 | EVENT_IDENTIFIER {
1617 $$ = unsmob_music ($1);
1620 Music * a = MY_MAKE_MUSIC ("TremoloEvent");
1621 a->set_spot (THIS->here_input ());
1622 a->set_property ("tremolo-type", gh_int2scm ($1));
1627 direction_reqd_event:
1631 | script_abbreviation {
1632 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1633 Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
1634 if (gh_string_p (s))
1635 a->set_property ("articulation-type", s);
1636 else THIS->parser_error (_ ("Expecting string as script definition"));
1642 /**/ { $$ = SCM_EOL; }
1643 | '=' { $$ = gh_int2scm (0); }
1644 | '=' sub_quotes { $$ = gh_int2scm ($2); }
1645 | '=' sup_quotes { $$ = gh_int2scm ($2); }
1670 | NOTENAME_PITCH sup_quotes {
1671 Pitch p = *unsmob_pitch ($1);
1672 p = p.transposed (Pitch ($2,0,0));
1673 $$ = p.smobbed_copy ();
1675 | NOTENAME_PITCH sub_quotes {
1676 Pitch p =* unsmob_pitch ($1);
1677 p = p.transposed (Pitch (-$2,0,0));
1678 $$ = p.smobbed_copy ();
1690 | TONICNAME_PITCH sup_quotes {
1691 Pitch p = *unsmob_pitch ($1);
1692 p = p.transposed (Pitch ($2,0,0));
1693 $$ = p.smobbed_copy ();
1695 | TONICNAME_PITCH sub_quotes {
1696 Pitch p =* unsmob_pitch ($1);
1698 p = p.transposed (Pitch (-$2,0,0));
1699 $$ = p.smobbed_copy ();
1709 pitch_also_in_chords:
1716 Music * s= MY_MAKE_MUSIC ("SlurEvent");
1718 s->set_spot (THIS->here_input ());
1721 Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
1723 s->set_spot (THIS->here_input ());
1726 Music *s =MY_MAKE_MUSIC ("CrescendoEvent");
1728 s->set_spot (THIS->here_input ());
1731 Music *s =MY_MAKE_MUSIC ("DecrescendoEvent");
1733 s->set_spot (THIS->here_input ());
1740 Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
1741 s->set_spot (THIS->here_input ());
1746 Music * s= MY_MAKE_MUSIC ("SlurEvent");
1748 s->set_spot (THIS->here_input ());
1752 Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
1754 s->set_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1755 s->set_spot (THIS->here_input ());
1761 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1762 t->set_property ("text", $1);
1763 t->set_spot (THIS->here_input ());
1767 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1768 t->set_property ("text", make_simple_markup ($1));
1769 t->set_spot (THIS->here_input ());
1774 Music * t = MY_MAKE_MUSIC ("FingerEvent");
1775 t->set_property ("digit", gh_int2scm ($1));
1776 t->set_spot (THIS->here_input ());
1781 script_abbreviation:
1783 $$ = scm_makfrom0str ("Hat");
1786 $$ = scm_makfrom0str ("Plus");
1789 $$ = scm_makfrom0str ("Dash");
1792 $$ = scm_makfrom0str ("Bar");
1795 $$ = scm_makfrom0str ("Larger");
1798 $$ = scm_makfrom0str ("Dot");
1801 $$ = scm_makfrom0str ("Underscore");
1808 | '-' { $$ = CENTER; }
1819 multiplied_duration {
1824 optional_notemode_duration:
1826 Duration dd = THIS->default_duration_;
1827 $$ = dd.smobbed_copy ();
1829 THIS->beam_check ($$);
1831 | multiplied_duration {
1833 THIS->default_duration_ = *unsmob_duration ($$);
1835 THIS->beam_check ($$);
1840 bare_unsigned dots {
1842 if (!is_is_duration ($1))
1843 THIS->parser_error (_f ("not a duration: %d", $1));
1847 $$ = Duration (l, $2).smobbed_copy ();
1849 | DURATION_IDENTIFIER dots {
1850 Duration *d =unsmob_duration ($1);
1851 Duration k (d->duration_log (),d->dot_count () + $2);
1861 multiplied_duration:
1865 | multiplied_duration '*' bare_unsigned {
1866 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1868 | multiplied_duration '*' FRACTION {
1869 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1871 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1876 FRACTION { $$ = $1; }
1877 | UNSIGNED '/' UNSIGNED {
1878 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1896 | ':' bare_unsigned {
1897 if (!is_is_duration ($2))
1898 THIS->parser_error (_f ("not a duration: %d", $2));
1905 /*****************************************************************
1907 *****************************************************************/
1910 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1913 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1915 | STRING { $$ = $1; }
1926 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
1927 $$ = bfr->self_scm ();
1928 scm_gc_unprotect_object ($$);
1931 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
1932 $$ = bfr->self_scm ();
1934 bfr->set_property ("figure", $1);
1936 scm_gc_unprotect_object ($$);
1938 | bass_figure bass_mod {
1939 Music *m = unsmob_music ($1);
1941 SCM salter =m->get_property ("alteration");
1942 int alter = gh_number_p (salter) ? gh_scm2int (salter) : 0;
1943 m->set_property ("alteration",
1944 gh_int2scm (alter + $2));
1946 m->set_property ("alteration", gh_int2scm (0));
1954 unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
1959 | br_bass_figure ']' {
1961 unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
1969 | figure_list br_bass_figure {
1970 $$ = scm_cons ($2, $1);
1975 FIGURE_OPEN figure_list FIGURE_CLOSE {
1976 Music * m = MY_MAKE_MUSIC ("EventChord");
1977 $2 = scm_reverse_x ($2, SCM_EOL);
1978 m->set_property ("elements", $2);
1979 $$ = m->self_scm ();
1990 pitch exclamations questions oct_check optional_notemode_duration optional_rest {
1992 Input i = THIS->pop_spot ();
1993 if (!THIS->lexer_->is_note_state ())
1994 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1998 n = MY_MAKE_MUSIC ("RestEvent");
2000 n = MY_MAKE_MUSIC ("NoteEvent");
2002 n->set_property ("pitch", $1);
2003 n->set_property ("duration", $5);
2005 if (gh_number_p ($4))
2007 int q = gh_scm2int ($4);
2008 n->set_property ("absolute-octave", gh_int2scm (q-1));
2012 n->set_property ("cautionary", SCM_BOOL_T);
2013 if ($2 % 2 || $3 % 2)
2014 n->set_property ("force-accidental", SCM_BOOL_T);
2016 Music *v = MY_MAKE_MUSIC ("EventChord");
2017 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2018 scm_gc_unprotect_object (n->self_scm ());
2024 | DRUM_PITCH optional_notemode_duration {
2025 Input i = THIS->pop_spot ();
2027 Music *n = MY_MAKE_MUSIC ("NoteEvent");
2028 n->set_property ("duration" ,$2);
2029 n->set_property ("drum-type" , $1);
2031 Music *v = MY_MAKE_MUSIC ("EventChord");
2032 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2033 scm_gc_unprotect_object (n->self_scm ());
2039 | figure_spec optional_notemode_duration {
2040 Music * m = unsmob_music ($1);
2041 Input i = THIS->pop_spot ();
2043 for (SCM s = m->get_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
2045 unsmob_music (ly_car (s))->set_property ("duration", $2);
2049 | RESTNAME optional_notemode_duration {
2051 Input i = THIS->pop_spot ();
2053 if (ly_scm2string ($1) =="s") {
2055 ev = MY_MAKE_MUSIC ("SkipEvent");
2058 ev = MY_MAKE_MUSIC ("RestEvent");
2061 ev->set_property ("duration" ,$2);
2063 Music * velt = MY_MAKE_MUSIC ("EventChord");
2064 velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
2067 scm_gc_unprotect_object (ev->self_scm ());
2071 | MULTI_MEASURE_REST optional_notemode_duration {
2076 proc = scm_c_eval_string ("make-multi-measure-rest");
2078 SCM mus = scm_call_2 (proc, $2,
2079 make_input (THIS->here_input ()));
2080 scm_gc_protect_object (mus);
2081 $$ = unsmob_music (mus);
2084 | lyric_element optional_notemode_duration {
2085 Input i = THIS->pop_spot ();
2086 if (!THIS->lexer_->is_lyric_state ())
2087 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
2089 Music * lreq = MY_MAKE_MUSIC ("LyricEvent");
2090 lreq->set_property ("text", $1);
2091 lreq->set_property ("duration",$2);
2093 Music * velt = MY_MAKE_MUSIC ("EventChord");
2094 velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
2101 if (!THIS->lexer_->is_chord_state ())
2102 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2103 $$ = unsmob_music ($1);
2108 full_markup { $$ = $1; }
2109 | STRING { $$ = $1 ; }
2113 steno_tonic_pitch optional_notemode_duration {
2114 $$ = make_chord ($1, $2, SCM_EOL);
2116 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2117 SCM its = scm_reverse_x ($4, SCM_EOL);
2118 $$ = make_chord ($1, $2, gh_cons ($3, its));
2126 | chord_items chord_item {
2127 $$ = gh_cons ($2, $$);
2133 $$ = ly_symbol2scm ("chord-colon");
2136 $$ = ly_symbol2scm ("chord-caret");
2138 | CHORD_SLASH steno_tonic_pitch {
2139 $$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2);
2141 | CHORD_BASS steno_tonic_pitch {
2142 $$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2);
2151 $$ = scm_reverse_x ($1, SCM_EOL);
2159 step_number { $$ = gh_cons ($1, SCM_EOL); }
2160 | step_numbers '.' step_number {
2161 $$ = gh_cons ($3, $$);
2167 $$ = make_chord_step ($1, 0);
2169 | bare_unsigned '+' {
2170 $$ = make_chord_step ($1, SHARP);
2172 | bare_unsigned CHORD_MINUS {
2173 $$ = make_chord_step ($1, FLAT);
2180 TODO: should deprecate in favor of Scheme?
2184 number_expression '+' number_term {
2185 $$ = scm_sum ($1, $3);
2187 | number_expression '-' number_term {
2188 $$ = scm_difference ($1, $3);
2197 | number_factor '*' number_factor {
2198 $$ = scm_product ($1, $3);
2200 | number_factor '/' number_factor {
2201 $$ = scm_divide ($1, $3);
2206 '-' number_factor { /* %prec UNARY_MINUS */
2207 $$ = scm_difference ($2, SCM_UNDEFINED);
2215 $$ = gh_int2scm ($1);
2220 | NUMBER_IDENTIFIER {
2223 | REAL NUMBER_IDENTIFIER {
2224 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2226 | UNSIGNED NUMBER_IDENTIFIER {
2227 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2243 if (scm_integer_p ($1) == SCM_BOOL_T)
2245 int k = gh_scm2int ($1);
2249 THIS->parser_error (_ ("need integer number arg"));
2263 | STRING_IDENTIFIER {
2266 | string '+' string {
2267 $$ = scm_string_append (scm_list_2 ($1, $3));
2274 | exclamations '!' { $$ ++; }
2279 | questions '?' { $$ ++; }
2289 { THIS->lexer_->push_markup_state (); }
2292 THIS->lexer_->pop_state ();
2298 This should be done more dynamically if possible.
2302 $$ = make_simple_markup ($1);
2304 | MARKUP_HEAD_EMPTY {
2305 $$ = scm_list_1 ($1);
2307 | MARKUP_HEAD_MARKUP0 markup {
2308 $$ = scm_list_2 ($1, $2);
2310 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2311 $$ = scm_list_3 ($1, $2, $3);
2313 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2314 $$ = scm_list_3 ($1, $2, $3);
2319 | MARKUP_HEAD_LIST0 markup_list {
2320 $$ = scm_list_2 ($1,$2);
2322 | MARKUP_HEAD_SCM0 embedded_scm {
2323 $$ = scm_list_2 ($1, $2);
2325 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2326 $$ = scm_list_4 ($1, $2, $3, $4);
2328 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2329 $$ = scm_list_4 ($1, $2, $3, $4);
2331 | MARKUP_HEAD_SCM0_SCM1 embedded_scm embedded_scm {
2332 $$ = scm_list_3 ($1, $2, $3);
2334 | MARKUP_IDENTIFIER {
2337 | STRING_IDENTIFIER {
2343 chord_open markup_list_body chord_close { $$ = scm_reverse_x ($2, SCM_EOL); }
2347 '{' markup_list_body '}' {
2350 line = scm_c_eval_string ("line-markup");
2352 $$ = scm_list_2 (line, scm_reverse_x ($2, SCM_EOL));
2357 /**/ { $$ = SCM_EOL; }
2358 | markup_list_body markup {
2359 $$ = gh_cons ($2, $1) ;
2367 My_lily_parser::set_yydebug (bool )
2374 extern My_lily_parser * current_parser;
2377 My_lily_parser::do_yyparse ()
2379 current_parser = this;;
2380 yyparse ((void*)this);
2385 Should make this optional? It will also complain when you do
2389 which is entirely legitimate.
2391 Or we can scrap it. Barchecks should detect wrong durations, and
2392 skipTypesetting speeds it up a lot.
2396 My_lily_parser::beam_check (SCM dur)
2398 Duration *d = unsmob_duration (dur);
2399 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2401 Music * m = unsmob_music (last_beam_start_);
2402 m->origin ()->warning (_("Suspect duration found following this beam"));
2404 last_beam_start_ = SCM_EOL;
2412 It is a little strange to have this function in this file, but
2413 otherwise, we have to import music classes into the lexer.
2417 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2419 if (gh_string_p (sid)) {
2421 return STRING_IDENTIFIER;
2422 } else if (gh_number_p (sid)) {
2424 return NUMBER_IDENTIFIER;
2425 } else if (unsmob_context_def (sid)) {
2426 *destination = unsmob_context_def (sid)->clone_scm ();
2427 return CONTEXT_DEF_IDENTIFIER;
2428 } else if (unsmob_score (sid)) {
2429 Score *sc = new Score (*unsmob_score (sid));
2430 *destination =sc->self_scm ();
2431 return SCORE_IDENTIFIER;
2432 } else if (Music * mus =unsmob_music (sid)) {
2433 mus = mus->clone ();
2434 *destination = mus->self_scm ();
2435 unsmob_music (*destination)->
2436 set_property ("origin", make_input (last_input_));
2437 return dynamic_cast<Event*> (mus)
2438 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2439 } else if (unsmob_duration (sid)) {
2440 *destination = unsmob_duration (sid)->smobbed_copy ();
2441 return DURATION_IDENTIFIER;
2442 } else if (unsmob_music_output_def (sid)) {
2443 Music_output_def *p = unsmob_music_output_def (sid);
2446 *destination = p->self_scm ();
2447 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2448 } else if (Text_item::markup_p (sid)) {
2450 return MARKUP_IDENTIFIER;
2457 property_op_to_music (SCM op)
2460 SCM tag = gh_car (op);
2461 SCM symbol = gh_cadr (op);
2462 SCM args = gh_cddr (op);
2463 SCM grob_val = SCM_UNDEFINED;
2464 SCM grob_sym = SCM_UNDEFINED;
2465 SCM val = SCM_UNDEFINED;
2467 if (tag == ly_symbol2scm ("assign"))
2469 m = MY_MAKE_MUSIC ("PropertySet");
2470 val = gh_car (args);
2472 else if (tag == ly_symbol2scm ("unset"))
2473 m = MY_MAKE_MUSIC ("PropertyUnset");
2474 else if (tag == ly_symbol2scm ("poppush")
2475 || tag == ly_symbol2scm ("push"))
2477 m = MY_MAKE_MUSIC ("OverrideProperty");
2478 grob_sym = gh_car (args);
2479 grob_val = gh_cadr (args);
2481 else if (tag == ly_symbol2scm ("pop")) {
2482 m = MY_MAKE_MUSIC ("RevertProperty");
2483 grob_sym = gh_car (args);
2486 m->set_property ("symbol", symbol);
2488 if (val != SCM_UNDEFINED)
2489 m->set_property ("value", val);
2490 if (grob_val != SCM_UNDEFINED)
2491 m->set_property ("grob-value", grob_val);
2493 if (grob_sym != SCM_UNDEFINED)
2495 bool itc = internal_type_checking_global_b;
2498 bool autobeam = gh_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
2500 internal_type_checking_global_b = false;
2501 m->set_property ("grob-property", grob_sym);
2503 internal_type_checking_global_b = itc;
2506 if (op == ly_symbol2scm ("poppush"))
2507 m->set_property ("pop-first", SCM_BOOL_T);
2514 context_spec_music (SCM type, SCM id, Music * m, SCM ops)
2516 Music * csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
2518 csm->set_property ("element", m->self_scm ());
2519 scm_gc_unprotect_object (m->self_scm ());
2521 csm->set_property ("context-type",
2522 gh_symbol_p (type) ? type : scm_string_to_symbol (type));
2523 csm->set_property ("property-operations", ops);
2525 if (gh_string_p (id))
2526 csm->set_property ("context-id", id);
2532 get_next_unique_context ()
2534 static int new_context_count;
2537 snprintf (s, 1024, "uniqueContext%d", new_context_count ++);
2539 return scm_makfrom0str (s);