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 () ;
130 v = v && isalpha (*s);
137 make_simple_markup (SCM a)
141 simple = scm_c_eval_string ("simple-markup");
143 return scm_list_2 (simple, a);
148 is_is_duration (int t)
150 return t && t == 1 << intlog2 (t);
154 set_music_properties (Music *p, SCM a)
156 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
158 p->internal_set_property (ly_caar (k), ly_cdar (k));
163 make_chord_step (int step, int alter)
170 Pitch m((step -1) / 7 , (step - 1) % 7, alter);
171 return m.smobbed_copy ();
176 make_chord (SCM pitch, SCM dur, SCM modification_list)
178 static SCM chord_ctor;
180 chord_ctor= scm_c_eval_string ("construct-chord");
181 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
182 scm_gc_protect_object (ch);
187 Todo: actually also use apply iso. call too ...
190 ly_input_procedure_p (SCM x)
192 return gh_procedure_p (x)
193 || (gh_pair_p (x) && gh_procedure_p (gh_car (x)));
197 set_property_music (SCM sym, SCM value)
199 Music * p = MY_MAKE_MUSIC ("PropertySet");
200 p->set_property ("symbol", sym);
201 p->set_property ("value", value);
207 /* We use SCMs to do strings, because it saves us the trouble of
208 deleting them. Let's hope that a stack overflow doesnt trigger a move
209 of the parse stack onto the heap. */
216 Music_output_def * outputdef;
223 yylex (YYSTYPE *s, void * v)
225 My_lily_parser *pars = (My_lily_parser*) v;
226 My_lily_lexer * lex = pars->lexer_;
228 lex->lexval = (void*) s;
229 lex->prepare_for_next_token ();
230 return lex->yylex ();
252 %token CHORDMODIFIERS
257 %token COMMANDSPANREQUEST
265 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
266 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
270 %token GROBDESCRIPTIONS
278 %token MULTI_MEASURE_REST
284 %token OVERRIDE SET REVERT
310 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
311 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
313 %token <i> E_UNSIGNED
314 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
317 %type <i> exclamations questions dots optional_rest
319 %type <scm> grace_head
320 %type <scm> oct_check
321 %type <scm> context_mod_list
322 %type <scm> lyric_element
323 %type <scm> bass_number br_bass_figure bass_figure figure_list figure_spec
325 %token <scm> NOTENAME_PITCH
326 %token <scm> TONICNAME_PITCH
327 %token <scm> CHORDMODIFIER_PITCH
328 %token <scm> DURATION_IDENTIFIER
329 %token <scm> FRACTION
330 %token <id> IDENTIFIER
332 %token <scm> DRUM_PITCH
333 %token <scm> CHORD_MODIFIER
334 %token <scm> SCORE_IDENTIFIER
335 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
336 %token <scm> NUMBER_IDENTIFIER
337 %token <scm> EVENT_IDENTIFIER
338 %token <scm> MUSIC_IDENTIFIER CONTEXT_DEF_IDENTIFIER
339 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
340 %token <scm> RESTNAME
347 %token <scm> MARKUP_HEAD_MARKUP0
348 %token <scm> MARKUP_HEAD_EMPTY
349 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
350 %token <scm> MARKUP_HEAD_SCM0
351 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
352 %token <scm> MARKUP_HEAD_SCM0_SCM1
353 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
354 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
356 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
357 %type <scm> markup markup_line markup_list markup_list_body full_markup
359 %type <outputdef> output_def
360 %type <scm> lilypond_header lilypond_header_body
361 %type <music> open_event close_event
362 %type <i> sub_quotes sup_quotes
363 %type <music> simple_element event_chord command_element Simple_music Composite_music
364 %type <music> Repeated_music
365 %type <scm> Alternative_music
366 %type <i> tremolo_type
367 %type <i> bare_int bare_unsigned
369 %type <scm> identifier_init
371 %type <music> note_chord_element chord_body chord_body_element
372 %type <scm> chord_body_elements
373 %type <scm> steno_duration optional_notemode_duration multiplied_duration
375 %type <scm> post_events
376 %type <music> gen_text_def direction_less_event direction_reqd_event
377 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
378 %type <scm> steno_tonic_pitch
379 %type <scm> duration_length fraction
381 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
383 %type <scm> embedded_scm scalar
384 %type <music> Music Sequential_music Simultaneous_music
385 %type <music> relative_music re_rhythmed_music
386 %type <music> music_property_def context_change
387 %type <scm> context_prop_spec
388 %type <scm> Music_list
389 %type <scm> property_operation context_mod context_def_mod optional_context_mod
390 %type <outputdef> music_output_def_body music_output_def_head
391 %type <music> post_event tagged_post_event
392 %type <music> command_req
393 %type <music> string_number_event
394 %type <scm> string bare_number number_expression number_term number_factor
395 %type <score> score_block score_body
397 %type <scm> context_def_spec_block context_def_spec_body
398 %type <music> tempo_event
399 %type <scm> script_abbreviation
405 /* We don't assign precedence to / and *, because we might need varied
406 prec levels in different prods */
412 lilypond: /* empty */
413 | lilypond toplevel_expression {}
414 | lilypond assignment { }
416 THIS->error_level_ = 1;
419 THIS->error_level_ = 1;
425 THIS->input_file_->header_ = $1;
432 SCM head = ly_module_p (sc->header_) ? sc->header_ : THIS->input_file_->header_.to_SCM ();
434 Path p = split_path (THIS->output_basename_);
435 int *c = &THIS->input_file_->score_count_;
438 p.base += "-" + to_string (*c);
442 SCM outname = scm_makfrom0str (p.to_string ().to_str0());
444 for (int i=0; i < sc->defs_.size (); i++)
445 default_rendering (sc->music_, sc->defs_[i]->self_scm (), head, outname);
447 if (sc->defs_.is_empty ())
449 Music_output_def *id =
450 unsmob_music_output_def (THIS->lexer_->lookup_identifier
453 id = id ? id->clone () : new Paper_def;
455 default_rendering (sc->music_, id->self_scm (), head, outname);
457 if (output_format_global != PAGE_LAYOUT)
458 scm_gc_unprotect_object (id->self_scm ());
460 if (output_format_global != PAGE_LAYOUT)
461 scm_gc_unprotect_object (sc->self_scm ());
465 if (dynamic_cast<Paper_def*> ($1))
466 id = scm_makfrom0str ("$defaultpaper");
467 else if (dynamic_cast<Midi_def*> ($1))
468 id = scm_makfrom0str ("$defaultmidi");
469 THIS->lexer_->set_identifier (id, $1->self_scm ());
470 scm_gc_unprotect_object ($1->self_scm ());
483 lilypond_header_body:
485 $$ = ly_make_anonymous_module ();
486 THIS->lexer_->add_scope ($$);
488 | lilypond_header_body assignment {
494 HEADER '{' lilypond_header_body '}' {
495 $$ = THIS->lexer_-> remove_scope ();
507 /* cont */ '=' identifier_init {
510 Should find generic way of associating input with objects.
512 Input ip = THIS->pop_spot ();
514 if (! is_regular_identifier ($1))
516 ip.warning (_ ("Identifier should have alphabetic characters only"));
519 THIS->lexer_->set_identifier ($1, $4);
522 TODO: devise standard for protection in parser.
524 The parser stack lives on the C-stack, which means that
525 all objects can be unprotected as soon as they're here.
535 $$ = $1->self_scm ();
536 scm_gc_unprotect_object ($$);
542 $$ = $1->self_scm ();
543 scm_gc_unprotect_object ($$);
545 | context_def_spec_block {
549 $$ = $1->self_scm ();
550 scm_gc_unprotect_object ($$);
553 $$ = $1->self_scm ();
554 scm_gc_unprotect_object ($$);
556 | number_expression {
567 context_def_spec_block:
568 CONTEXT '{' context_def_spec_body '}'
574 context_def_spec_body:
576 $$ = Context_def::make_scm ();
577 unsmob_context_def ($$)->set_spot (THIS->here_input ());
579 | CONTEXT_DEF_IDENTIFIER {
581 unsmob_context_def ($$)->set_spot (THIS->here_input ());
583 | context_def_spec_body GROBDESCRIPTIONS embedded_scm {
584 Context_def*td = unsmob_context_def ($$);
586 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p)) {
587 SCM tag = gh_caar (p);
589 /* TODO: should make new tag "grob-definition" ? */
590 td->add_context_mod (scm_list_3 (ly_symbol2scm ("assign"),
591 tag, gh_cons (ly_cdar (p), SCM_EOL)));
594 | context_def_spec_body context_mod {
595 unsmob_context_def ($$)->add_context_mod ($2);
606 /*cont*/ '{' score_body '}' {
617 $$->set_spot (THIS->here_input ());
618 SCM m = $1->self_scm ();
619 scm_gc_unprotect_object (m);
624 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
625 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
626 m = gh_call1 (gh_car (check_funcs), m);
631 $$ = new Score ( *unsmob_score ($1));
632 $$->set_spot (THIS->here_input ());
634 | score_body lilypond_header {
637 | score_body output_def {
639 scm_gc_unprotect_object ($2->self_scm ());
651 music_output_def_body '}' {
653 THIS-> lexer_-> remove_scope ();
657 music_output_def_head:
659 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
664 p = dynamic_cast<Midi_def*> (id->clone ());
669 THIS->lexer_->add_scope (p->scope_);
672 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
675 p = dynamic_cast<Paper_def*> (id->clone ());
679 THIS->lexer_->add_scope (p->scope_);
685 music_output_def_body:
686 music_output_def_head '{' {
689 | music_output_def_head '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
690 scm_gc_unprotect_object ($1->self_scm ());
691 Music_output_def * o = unsmob_music_output_def ($3);
693 THIS->lexer_->remove_scope ();
694 THIS->lexer_->add_scope (o->scope_);
696 | music_output_def_body assignment {
699 | music_output_def_body context_def_spec_block {
700 $$->assign_context_def ($2);
702 | music_output_def_body tempo_event {
704 junk this ? there already is tempo stuff in
707 int m = gh_scm2int ( $2->get_property ("metronome-count"));
708 Duration *d = unsmob_duration ($2->get_property ("tempo-unit"));
709 Midi_def * md = dynamic_cast<Midi_def*> ($$);
711 md->set_tempo (d->get_length (), m);
712 scm_gc_unprotect_object ($2->self_scm ());
714 | music_output_def_body error {
720 TEMPO steno_duration '=' bare_unsigned {
721 $$ = MY_MAKE_MUSIC ("MetronomeChangeEvent");
722 $$->set_property ("tempo-unit", $2);
723 $$->set_property ("metronome-count", gh_int2scm ( $4));
728 The representation of a list is the
732 to have efficient append.
736 $$ = scm_cons (SCM_EOL, SCM_EOL);
740 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
741 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
742 if (gh_pair_p (ly_cdr (s)))
743 gh_set_cdr_x (ly_cdr (s), c); /* append */
745 gh_set_car_x (s, c); /* set first cons */
746 gh_set_cdr_x (s, c) ; /* remember last cell */
762 | ALTERNATIVE '{' Music_list '}' {
768 REPEAT string bare_unsigned Music Alternative_music
772 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
773 if (times < scm_ilength (alts)) {
774 unsmob_music (gh_car (alts))
775 ->origin ()->warning (
776 _("More alternatives than repeats. Junking excess alternatives."));
777 alts = ly_truncate_list (times, alts);
783 proc = scm_c_eval_string ("make-repeated-music");
785 SCM mus = scm_call_1 (proc, $2);
786 scm_gc_protect_object (mus); // UGH.
787 Music *r =unsmob_music (mus);
790 r-> set_property ("element", beg->self_scm ());
791 scm_gc_unprotect_object (beg->self_scm ());
793 r->set_property ("repeat-count", gh_int2scm (times >? 1));
795 r-> set_property ("elements",alts);
796 if (gh_equal_p ($2, scm_makfrom0str ("tremolo"))) {
798 we can not get durations and other stuff correct down the line, so we have to
799 add to the duration log here.
804 func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
806 int dots = ($3 % 3) ? 0 : 1;
807 int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
809 Sequential_music * seq = dynamic_cast<Sequential_music*> ($4);
812 int list_len =scm_ilength (seq->music_list ());
814 seq->origin ()->warning ("Chord tremolo must have 2 elements.");
816 r->compress (Moment (Rational (1,list_len)));
818 gh_call3 (func, r->self_scm (), gh_int2scm (shift),gh_int2scm (dots));
821 r->set_spot (*$4->origin ());
828 SEQUENTIAL '{' Music_list '}' {
829 $$ = MY_MAKE_MUSIC ("SequentialMusic");
830 $$->set_property ("elements", ly_car ($3));
831 $$->set_spot (THIS->here_input ());
833 | '{' Music_list '}' {
834 $$ = MY_MAKE_MUSIC ("SequentialMusic");
835 $$->set_property ("elements", ly_car ($2));
836 $$->set_spot (THIS->here_input ());
841 SIMULTANEOUS '{' Music_list '}'{
842 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
843 $$->set_property ("elements", ly_car ($3));
844 $$->set_spot (THIS->here_input ());
847 | simul_open Music_list simul_close {
848 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
849 $$->set_property ("elements", ly_car ($2));
850 $$->set_spot (THIS->here_input ());
855 event_chord { $$ = $1; }
856 | APPLYOUTPUT embedded_scm {
857 if (!ly_input_procedure_p ($2))
858 THIS->parser_error (_ ("\\applycontext takes function argument"));
859 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
860 $$->set_property ("procedure", $2);
861 $$->set_spot (THIS->here_input ());
863 | APPLYCONTEXT embedded_scm {
864 if (!ly_input_procedure_p ($2))
865 THIS->parser_error (_ ("\\applycontext takes function argument"));
866 $$ = MY_MAKE_MUSIC ("ApplyContext");
867 $$->set_property ("procedure", $2);
868 $$->set_spot (THIS->here_input ());
871 $$ = unsmob_music ($1);
878 optional_context_mod:
879 /**/ { $$ = SCM_EOL; }
880 | WITH '{' context_mod_list '}' { $$ = $3; }
884 GRACE { $$ = scm_makfrom0str ("Grace"); }
885 | ACCIACCATURA { $$ = scm_makfrom0str ("Acciaccatura"); }
886 | APPOGGIATURA { $$ = scm_makfrom0str ("Appoggiatura"); }
890 /* */ { $$ = SCM_EOL; }
891 | context_mod_list context_mod {
892 $$ = gh_cons ($2, $1);
900 proc = scm_c_eval_string ("make-autochange-music");
902 SCM res = scm_call_1 (proc, $2->self_scm ());
903 scm_gc_unprotect_object ($2->self_scm ());
904 $$ = unsmob_music (res);
905 scm_gc_protect_object (res);
906 $$->set_spot (THIS->here_input ());
908 | PARTCOMBINE Music Music {
911 proc = scm_c_eval_string ("make-part-combine-music");
913 SCM res = scm_call_1 (proc, gh_list ($2->self_scm (),
914 $3->self_scm (), SCM_UNDEFINED));
915 scm_gc_unprotect_object ($3->self_scm ());
916 scm_gc_unprotect_object ($2->self_scm ());
917 $$ = unsmob_music (res);
918 scm_gc_protect_object (res);
919 $$->set_spot (THIS->here_input ());
924 The other version is for easier debugging of
925 Sequential_music_iterator in combination with grace notes.
930 TODO: should distinguish between both grace types in the
931 basic music objects too, since the meaning is different.
935 String start_str = "start" + ly_scm2string ($1) + "Music";
936 String stop_str = "stop" + ly_scm2string ($1) + "Music";
938 SCM start = THIS->lexer_->lookup_identifier (start_str);
939 SCM stop = THIS->lexer_->lookup_identifier (stop_str);
941 Music *startm = unsmob_music (start);
942 Music *stopm = unsmob_music (stop);
946 stopm = stopm->clone ();
947 ms = scm_cons (stopm->self_scm (), ms);
948 scm_gc_unprotect_object (stopm->self_scm ());
950 ms = scm_cons ($2->self_scm (), ms);
951 scm_gc_unprotect_object ($2->self_scm ());
953 startm = startm->clone ();
954 ms = scm_cons (startm->self_scm () , ms);
955 scm_gc_unprotect_object (startm->self_scm ());
958 Music* seq = MY_MAKE_MUSIC ("SequentialMusic");
959 seq->set_property ("elements", ms);
962 $$ = MY_MAKE_MUSIC ("GraceMusic");
963 $$->set_property ("element", seq->self_scm ());
964 scm_gc_unprotect_object (seq->self_scm ());
966 $$ = MY_MAKE_MUSIC ("GraceMusic");
967 $$->set_property ("element", $2->self_scm ());
968 scm_gc_unprotect_object ($2->self_scm ());
971 | CONTEXT string '=' string optional_context_mod Music {
972 $$ = context_spec_music ($2, $4, $6, $5);
975 | CONTEXT STRING optional_context_mod Music {
976 $$ = context_spec_music ($2, SCM_UNDEFINED, $4, $3);
978 | NEWCONTEXT string optional_context_mod Music {
979 $$ = context_spec_music ($2, get_next_unique_context (),
990 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
993 $$= MY_MAKE_MUSIC ("TimeScaledMusic");
994 $$->set_spot (THIS->pop_spot ());
996 $$->set_property ("element", mp->self_scm ());
997 scm_gc_unprotect_object (mp->self_scm ());
998 $$->set_property ("numerator", gh_int2scm (n));
999 $$->set_property ("denominator", gh_int2scm (d));
1000 $$->compress (Moment (Rational (n,d)));
1003 | Repeated_music { $$ = $1; }
1004 | Simultaneous_music { $$ = $1; }
1005 | Sequential_music { $$ = $1; }
1006 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
1007 $$ = MY_MAKE_MUSIC ("TransposedMusic");
1009 Pitch from = *unsmob_pitch ($2);
1010 Pitch to = *unsmob_pitch ($3);
1012 p->transpose (interval (from, to));
1013 $$->set_property ("element", p->self_scm ());
1014 scm_gc_unprotect_object (p->self_scm ());
1016 | APPLY embedded_scm Music {
1017 if (!ly_input_procedure_p ($2))
1019 THIS->parser_error (_ ("\\apply takes function argument"));
1024 SCM ret = gh_call1 ($2, $3->self_scm ());
1025 Music *m = unsmob_music (ret);
1027 THIS->parser_error ("\\apply must return a Music");
1028 m = MY_MAKE_MUSIC ("Music");
1035 SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
1036 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1040 THIS->lexer_->pop_state ();
1044 SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
1045 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1049 THIS->lexer_->pop_state ();
1052 { THIS->lexer_->push_figuredbass_state (); }
1055 Music * chm = MY_MAKE_MUSIC ("UntransposableMusic");
1056 chm->set_property ("element", $3->self_scm ());
1058 scm_gc_unprotect_object ($3->self_scm ());
1060 THIS->lexer_->pop_state ();
1063 SCM nn = THIS->lexer_->lookup_identifier ("chordmodifiers");
1064 THIS->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
1065 nn = THIS->lexer_->lookup_identifier ("pitchnames");
1066 THIS->lexer_->push_chord_state (alist_to_hashq (nn));
1069 Music * chm = MY_MAKE_MUSIC ("UnrelativableMusic");
1070 chm->set_property ("element", $3->self_scm ());
1071 scm_gc_unprotect_object ($3->self_scm ());
1074 THIS->lexer_->pop_state ();
1077 { THIS->lexer_->push_lyric_state (); }
1081 THIS->lexer_->pop_state ();
1083 | relative_music { $$ = $1; }
1084 | re_rhythmed_music { $$ = $1; }
1085 | TAG embedded_scm Music {
1086 tag_music ($3, $2, THIS->here_input ());
1092 RELATIVE absolute_pitch Music {
1094 Pitch pit = *unsmob_pitch ($2);
1095 $$ = MY_MAKE_MUSIC ("RelativeOctaveMusic");
1097 $$->set_property ("element", p->self_scm ());
1098 scm_gc_unprotect_object (p->self_scm ());
1101 Pitch retpitch = p->to_relative_octave (pit);
1102 if (lily_1_8_relative)
1103 $$->set_property ("last-pitch", retpitch.smobbed_copy ());
1108 ADDLYRICS Music Music {
1109 Music*l =MY_MAKE_MUSIC ("LyricCombineMusic");
1110 l->set_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1111 scm_gc_unprotect_object ($3->self_scm ());
1112 scm_gc_unprotect_object ($2->self_scm ());
1115 | NEWADDLYRICS string Music {
1116 Music*l =MY_MAKE_MUSIC ("NewLyricCombineMusic");
1117 l->set_property ("element", $3->self_scm ());
1118 scm_gc_unprotect_object ($3->self_scm ());
1120 l->set_property ("associated-context", $2);
1125 CHANGE STRING '=' STRING {
1126 Music*t= MY_MAKE_MUSIC ("ContextChange");
1127 t-> set_property ("change-to-type", scm_string_to_symbol ($2));
1128 t-> set_property ("change-to-id", $4);
1131 $$->set_spot (THIS->here_input ());
1137 $$ = scm_list_3 (ly_symbol2scm ("assign"),
1138 scm_string_to_symbol ($1), $3);
1141 $$ = scm_list_2 (ly_symbol2scm ("unset"),
1142 scm_string_to_symbol ($2));
1144 | OVERRIDE STRING embedded_scm '=' embedded_scm {
1145 $$ = scm_list_4 (ly_symbol2scm ("push"),
1146 scm_string_to_symbol ($2), $3, $5);
1148 | REVERT STRING embedded_scm {
1149 $$ = scm_list_3 (ly_symbol2scm ("pop"),
1150 scm_string_to_symbol ($2), $3);
1155 CONSISTSEND { $$ = ly_symbol2scm ("consists-end"); }
1156 | CONSISTS { $$ = ly_symbol2scm ("consists"); }
1157 | REMOVE { $$ = ly_symbol2scm ("remove"); }
1159 | ACCEPTS { $$ = ly_symbol2scm ("accepts"); }
1160 | DENIES { $$ = ly_symbol2scm ("denies"); }
1162 | ALIAS { $$ = ly_symbol2scm ("alias"); }
1163 | TYPE { $$ = ly_symbol2scm ("translator-type"); }
1164 | DESCRIPTION { $$ = ly_symbol2scm ("description"); }
1165 | NAME { $$ = ly_symbol2scm ("context-name"); }
1169 property_operation { $$ = $1; }
1170 | context_def_mod STRING {
1171 $$ = scm_list_2 ($1, $2);
1177 $$ = scm_list_2 (ly_symbol2scm ("Bottom"), scm_string_to_symbol ($1));
1179 | STRING '.' STRING {
1180 $$ = scm_list_2 (scm_string_to_symbol ($1), scm_string_to_symbol ($3));
1185 OVERRIDE context_prop_spec embedded_scm '=' scalar {
1186 $$ = property_op_to_music (scm_list_4 (
1187 ly_symbol2scm ("poppush"),
1190 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1192 | REVERT context_prop_spec embedded_scm {
1193 $$ = property_op_to_music (scm_list_3 (
1194 ly_symbol2scm ("pop"),
1198 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1200 | SET context_prop_spec '=' scalar {
1201 $$ = property_op_to_music (scm_list_3 (
1202 ly_symbol2scm ("assign"),
1205 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1207 | UNSET context_prop_spec {
1208 $$ = property_op_to_music (scm_list_2 (
1209 ly_symbol2scm ("unset"),
1211 $$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1213 | ONCE music_property_def {
1214 SCM e = $2->get_property ("element");
1215 unsmob_music (e)->set_property ("once", SCM_BOOL_T);
1225 | bare_int { $$ = gh_int2scm ($1); }
1226 | embedded_scm { $$ = $1; }
1227 | full_markup { $$ = $1; }
1228 | DIGIT { $$ = gh_int2scm ($1); }
1234 Adding pre_events to the simple_element
1235 makes the choice between
1241 simple_element: STRING
1243 a single shift/reduction conflict.
1245 nevertheless, this is not very clean, and we should find a different
1255 pre_events simple_element post_events {
1256 SCM elts = $2-> get_property ("elements");
1258 elts = gh_append2 (elts, scm_reverse_x ($3, SCM_EOL));
1260 $2->set_property ("elements", elts);
1264 | note_chord_element
1269 chord_body optional_notemode_duration post_events
1271 SCM dur = unsmob_duration ($2)->smobbed_copy ();
1272 SCM es = $1->get_property ("elements");
1273 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1275 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1276 unsmob_music (gh_car (s))->set_property ("duration", dur);
1277 es = gh_append2 (es, postevs);
1279 $1-> set_property ("elements", es);
1290 simul_open: LESSLESS
1293 simul_close: MOREMORE
1297 chord_open chord_body_elements chord_close
1299 $$ = MY_MAKE_MUSIC ("EventChord");
1300 $$->set_property ("elements",
1301 scm_reverse_x ($2, SCM_EOL));
1305 chord_body_elements:
1306 /* empty */ { $$ = SCM_EOL; }
1307 | chord_body_elements chord_body_element {
1308 $$ = gh_cons ($2->self_scm (), $1);
1309 scm_gc_unprotect_object ($2->self_scm ());
1314 pitch exclamations questions post_events
1316 Music * n = MY_MAKE_MUSIC ("NoteEvent");
1317 n->set_property ("pitch", $1);
1319 n->set_property ("cautionary", SCM_BOOL_T);
1320 if ($2 % 2 || $3 % 2)
1321 n->set_property ("force-accidental", SCM_BOOL_T);
1323 if (gh_pair_p ($4)) {
1324 SCM arts = scm_reverse_x ($4, SCM_EOL);
1325 n->set_property ("articulations", arts);
1329 | DRUM_PITCH post_events {
1330 Music *n = MY_MAKE_MUSIC ("NoteEvent");
1331 n->set_property ("duration" ,$2);
1332 n->set_property ("drum-type" , $1);
1333 n->set_spot (THIS->here_input ());
1335 if (gh_pair_p ($2)) {
1336 SCM arts = scm_reverse_x ($2, SCM_EOL);
1337 n->set_property ("articulations", arts);
1344 ADDQUOTE string Music {
1347 adder = scm_c_eval_string ("add-quotable");
1349 scm_call_2 (adder, $2, $3->self_scm ());
1350 scm_gc_unprotect_object ($3->self_scm ());
1356 $$ = MY_MAKE_MUSIC ("EventChord");
1357 $$->set_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1358 scm_gc_unprotect_object ($1->self_scm ());
1360 $$-> set_spot (THIS->here_input ());
1361 $1-> set_spot (THIS->here_input ());
1363 | SKIP duration_length {
1364 Music * skip = MY_MAKE_MUSIC ("SkipMusic");
1365 skip->set_property ("duration", $2);
1369 | QUOTE STRING duration_length {
1370 SCM tab = THIS->lexer_->lookup_identifier ("musicQuotes");
1372 if (scm_hash_table_p (tab) == SCM_BOOL_T)
1374 SCM key = $2; // use symbol?
1375 evs = scm_hash_ref (tab, key, SCM_BOOL_F);
1378 if (gh_vector_p (evs))
1380 quote = MY_MAKE_MUSIC ("QuoteMusic");
1381 quote->set_property ("duration", $3);
1382 quote->set_property ("quoted-events", evs);
1384 THIS->here_input ().warning (_f ("Can\'t find music"));
1385 quote = MY_MAKE_MUSIC ("Event");
1387 quote->set_spot (THIS->here_input ());
1390 | OCTAVE { THIS->push_spot (); }
1392 Music *l = MY_MAKE_MUSIC ("RelativeOctaveCheck");
1394 $$->set_spot (THIS->pop_spot ());
1395 $$->set_property ("pitch", $3);
1398 Music *l = MY_MAKE_MUSIC ("LigatureEvent");
1399 l->set_property ("span-direction", gh_int2scm (START));
1400 l->set_spot (THIS->here_input ());
1402 $$ = MY_MAKE_MUSIC ("EventChord");
1403 $$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1404 scm_gc_unprotect_object (l->self_scm ());
1405 $$->set_spot (THIS->here_input ());
1408 Music *l = MY_MAKE_MUSIC ("LigatureEvent");
1409 l->set_property ("span-direction", gh_int2scm (STOP));
1410 l->set_spot (THIS->here_input ());
1412 $$ = MY_MAKE_MUSIC ("EventChord");
1413 $$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1414 $$->set_spot (THIS->here_input ());
1415 scm_gc_unprotect_object (l->self_scm ());
1418 $$ = MY_MAKE_MUSIC ("VoiceSeparator");
1419 $$->set_spot (THIS->here_input ());
1423 $$ = MY_MAKE_MUSIC ("BarCheck");
1424 $$->set_spot (THIS->here_input ());
1426 | TRANSPOSITION pitch {
1427 $$ = set_property_music (ly_symbol2scm ("instrumentTransposition"),
1429 $$->set_spot (THIS-> here_input ());
1430 $$ = context_spec_music (ly_symbol2scm ("Staff"), SCM_UNDEFINED,
1434 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1436 Music *csm = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1438 $$ = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED, csm, SCM_EOL);
1439 $$->set_spot (THIS->here_input ());
1440 t->set_spot (THIS->here_input ());
1442 | PARTIAL duration_length {
1443 Moment m = - unsmob_duration ($2)->get_length ();
1444 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1445 p->set_spot (THIS->here_input ());
1446 p = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1448 p = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED,
1455 proc = scm_c_eval_string ("make-clef-set");
1457 SCM result = scm_call_1 (proc, $2);
1458 scm_gc_protect_object (result);
1459 $$ = unsmob_music (result);
1464 proc = scm_c_eval_string ("make-time-signature-set");
1466 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1467 scm_gc_protect_object (result);
1468 $$ = unsmob_music (result);
1473 proc = scm_c_eval_string ("make-mark-set");
1475 SCM result = scm_call_1 (proc, $2);
1476 scm_gc_protect_object (result);
1477 $$ = unsmob_music (result);
1483 $$ = MY_MAKE_MUSIC ("BreathingSignEvent");
1486 $$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
1489 Music * m = MY_MAKE_MUSIC ("MarkEvent");
1496 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1499 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1501 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1502 if (scm_ilength ($3) > 0)
1504 key->set_property ("pitch-alist", $3);
1505 key->set_property ("tonic", Pitch (0,0,0).smobbed_copy ());
1506 ((Music*)key)->transpose (* unsmob_pitch ($2));
1508 THIS->parser_error (_("Second argument must be pitch list."));
1519 | post_events post_event {
1520 $2->set_spot (THIS->here_input ());
1521 $$ = gh_cons ($2->self_scm (), $$);
1522 scm_gc_unprotect_object ($2->self_scm ());
1524 | post_events tagged_post_event {
1525 $2 -> set_spot (THIS->here_input ());
1526 $$ = scm_cons ($2->self_scm (), $$);
1527 scm_gc_unprotect_object ($2->self_scm ());
1533 '-' TAG embedded_scm post_event {
1534 tag_music ($4, $3, THIS->here_input ());
1540 direction_less_event {
1544 if (!THIS->lexer_->is_lyric_state ())
1545 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1546 $$ = MY_MAKE_MUSIC ("HyphenEvent");
1549 if (!THIS->lexer_->is_lyric_state ())
1550 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1551 $$ = MY_MAKE_MUSIC ("ExtenderEvent");
1553 | script_dir direction_reqd_event {
1555 $2->set_property ("direction", gh_int2scm ($1));
1558 | script_dir direction_less_event {
1560 $2->set_property ("direction", gh_int2scm ($1));
1563 | string_number_event
1566 string_number_event:
1568 Music * s = MY_MAKE_MUSIC ("StringNumberEvent");
1569 s->set_property ("string-number", gh_int2scm ($1));
1570 s->set_spot (THIS->here_input ());
1576 direction_less_event:
1582 TODO: should take all these defs out of the parser, adn make use
1586 (set-articulation '~ "trill")
1589 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1590 m->set_spot (THIS->here_input ());
1591 m->set_property ("span-direction" , gh_int2scm (START));
1595 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1596 m->set_spot (THIS->here_input ());
1597 m->set_property ("span-direction" , gh_int2scm (STOP));
1601 Music * m = MY_MAKE_MUSIC ("TieEvent");
1602 m->set_spot (THIS->here_input ());
1607 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1608 gh_int2scm (START));
1612 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1615 | EVENT_IDENTIFIER {
1616 $$ = unsmob_music ($1);
1619 Music * a = MY_MAKE_MUSIC ("TremoloEvent");
1620 a->set_spot (THIS->here_input ());
1621 a->set_property ("tremolo-type", gh_int2scm ($1));
1626 direction_reqd_event:
1630 | script_abbreviation {
1631 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1632 Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
1633 if (gh_string_p (s))
1634 a->set_property ("articulation-type", s);
1635 else THIS->parser_error (_ ("Expecting string as script definition"));
1641 /**/ { $$ = SCM_EOL; }
1642 | '=' { $$ = gh_int2scm (0); }
1643 | '=' sub_quotes { $$ = gh_int2scm ($2); }
1644 | '=' sup_quotes { $$ = gh_int2scm ($2); }
1669 | NOTENAME_PITCH sup_quotes {
1670 Pitch p = *unsmob_pitch ($1);
1671 p = p.transposed (Pitch ($2,0,0));
1672 $$ = p.smobbed_copy ();
1674 | NOTENAME_PITCH sub_quotes {
1675 Pitch p =* unsmob_pitch ($1);
1676 p = p.transposed (Pitch (-$2,0,0));
1677 $$ = p.smobbed_copy ();
1689 | TONICNAME_PITCH sup_quotes {
1690 Pitch p = *unsmob_pitch ($1);
1691 p = p.transposed (Pitch ($2,0,0));
1692 $$ = p.smobbed_copy ();
1694 | TONICNAME_PITCH sub_quotes {
1695 Pitch p =* unsmob_pitch ($1);
1697 p = p.transposed (Pitch (-$2,0,0));
1698 $$ = p.smobbed_copy ();
1708 pitch_also_in_chords:
1715 Music * s= MY_MAKE_MUSIC ("SlurEvent");
1717 s->set_spot (THIS->here_input ());
1720 Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
1722 s->set_spot (THIS->here_input ());
1725 Music *s =MY_MAKE_MUSIC ("CrescendoEvent");
1727 s->set_spot (THIS->here_input ());
1730 Music *s =MY_MAKE_MUSIC ("DecrescendoEvent");
1732 s->set_spot (THIS->here_input ());
1739 Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
1740 s->set_spot (THIS->here_input ());
1745 Music * s= MY_MAKE_MUSIC ("SlurEvent");
1747 s->set_spot (THIS->here_input ());
1751 Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
1753 s->set_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1754 s->set_spot (THIS->here_input ());
1760 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1761 t->set_property ("text", $1);
1762 t->set_spot (THIS->here_input ());
1766 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1767 t->set_property ("text", make_simple_markup ($1));
1768 t->set_spot (THIS->here_input ());
1773 Music * t = MY_MAKE_MUSIC ("FingerEvent");
1774 t->set_property ("digit", gh_int2scm ($1));
1775 t->set_spot (THIS->here_input ());
1780 script_abbreviation:
1782 $$ = scm_makfrom0str ("Hat");
1785 $$ = scm_makfrom0str ("Plus");
1788 $$ = scm_makfrom0str ("Dash");
1791 $$ = scm_makfrom0str ("Bar");
1794 $$ = scm_makfrom0str ("Larger");
1797 $$ = scm_makfrom0str ("Dot");
1800 $$ = scm_makfrom0str ("Underscore");
1807 | '-' { $$ = CENTER; }
1818 multiplied_duration {
1823 optional_notemode_duration:
1825 Duration dd = THIS->default_duration_;
1826 $$ = dd.smobbed_copy ();
1828 THIS->beam_check ($$);
1830 | multiplied_duration {
1832 THIS->default_duration_ = *unsmob_duration ($$);
1834 THIS->beam_check ($$);
1839 bare_unsigned dots {
1841 if (!is_is_duration ($1))
1842 THIS->parser_error (_f ("not a duration: %d", $1));
1846 $$ = Duration (l, $2).smobbed_copy ();
1848 | DURATION_IDENTIFIER dots {
1849 Duration *d =unsmob_duration ($1);
1850 Duration k (d->duration_log (),d->dot_count () + $2);
1860 multiplied_duration:
1864 | multiplied_duration '*' bare_unsigned {
1865 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1867 | multiplied_duration '*' FRACTION {
1868 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1870 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1875 FRACTION { $$ = $1; }
1876 | UNSIGNED '/' UNSIGNED {
1877 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1895 | ':' bare_unsigned {
1896 if (!is_is_duration ($2))
1897 THIS->parser_error (_f ("not a duration: %d", $2));
1904 /*****************************************************************
1906 *****************************************************************/
1909 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1912 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1914 | STRING { $$ = $1; }
1925 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
1926 $$ = bfr->self_scm ();
1927 scm_gc_unprotect_object ($$);
1930 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
1931 $$ = bfr->self_scm ();
1933 bfr->set_property ("figure", $1);
1935 scm_gc_unprotect_object ($$);
1937 | bass_figure bass_mod {
1938 Music *m = unsmob_music ($1);
1940 SCM salter =m->get_property ("alteration");
1941 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1942 m->set_property ("alteration",
1943 gh_int2scm (alter + $2));
1945 m->set_property ("alteration", gh_int2scm (0));
1953 unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
1958 | br_bass_figure ']' {
1960 unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
1968 | figure_list br_bass_figure {
1969 $$ = scm_cons ($2, $1);
1974 FIGURE_OPEN figure_list FIGURE_CLOSE {
1975 Music * m = MY_MAKE_MUSIC ("EventChord");
1976 $2 = scm_reverse_x ($2, SCM_EOL);
1977 m->set_property ("elements", $2);
1978 $$ = m->self_scm ();
1989 pitch exclamations questions oct_check optional_notemode_duration optional_rest {
1991 Input i = THIS->pop_spot ();
1992 if (!THIS->lexer_->is_note_state ())
1993 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1997 n = MY_MAKE_MUSIC ("RestEvent");
1999 n = MY_MAKE_MUSIC ("NoteEvent");
2001 n->set_property ("pitch", $1);
2002 n->set_property ("duration", $5);
2004 if (gh_number_p ($4))
2006 int q = gh_scm2int ($4);
2007 n->set_property ("absolute-octave", gh_int2scm (q-1));
2011 n->set_property ("cautionary", SCM_BOOL_T);
2012 if ($2 % 2 || $3 % 2)
2013 n->set_property ("force-accidental", SCM_BOOL_T);
2015 Music *v = MY_MAKE_MUSIC ("EventChord");
2016 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2017 scm_gc_unprotect_object (n->self_scm ());
2023 | DRUM_PITCH optional_notemode_duration {
2024 Input i = THIS->pop_spot ();
2026 Music *n = MY_MAKE_MUSIC ("NoteEvent");
2027 n->set_property ("duration" ,$2);
2028 n->set_property ("drum-type" , $1);
2030 Music *v = MY_MAKE_MUSIC ("EventChord");
2031 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2032 scm_gc_unprotect_object (n->self_scm ());
2038 | figure_spec optional_notemode_duration {
2039 Music * m = unsmob_music ($1);
2040 Input i = THIS->pop_spot ();
2042 for (SCM s = m->get_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
2044 unsmob_music (ly_car (s))->set_property ("duration", $2);
2048 | RESTNAME optional_notemode_duration {
2050 Input i = THIS->pop_spot ();
2052 if (ly_scm2string ($1) =="s") {
2054 ev = MY_MAKE_MUSIC ("SkipEvent");
2057 ev = MY_MAKE_MUSIC ("RestEvent");
2060 ev->set_property ("duration" ,$2);
2062 Music * velt = MY_MAKE_MUSIC ("EventChord");
2063 velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
2066 scm_gc_unprotect_object (ev->self_scm ());
2070 | MULTI_MEASURE_REST optional_notemode_duration {
2075 proc = scm_c_eval_string ("make-multi-measure-rest");
2077 SCM mus = scm_call_2 (proc, $2,
2078 make_input (THIS->here_input ()));
2079 scm_gc_protect_object (mus);
2080 $$ = unsmob_music (mus);
2083 | lyric_element optional_notemode_duration {
2084 Input i = THIS->pop_spot ();
2085 if (!THIS->lexer_->is_lyric_state ())
2086 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
2088 Music * lreq = MY_MAKE_MUSIC ("LyricEvent");
2089 lreq->set_property ("text", $1);
2090 lreq->set_property ("duration",$2);
2092 Music * velt = MY_MAKE_MUSIC ("EventChord");
2093 velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
2100 if (!THIS->lexer_->is_chord_state ())
2101 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2102 $$ = unsmob_music ($1);
2107 full_markup { $$ = $1; }
2108 | STRING { $$ = $1 ; }
2112 steno_tonic_pitch optional_notemode_duration {
2113 $$ = make_chord ($1, $2, SCM_EOL);
2115 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2116 SCM its = scm_reverse_x ($4, SCM_EOL);
2117 $$ = make_chord ($1, $2, gh_cons ($3, its));
2125 | chord_items chord_item {
2126 $$ = gh_cons ($2, $$);
2132 $$ = ly_symbol2scm ("chord-colon");
2135 $$ = ly_symbol2scm ("chord-caret");
2137 | CHORD_SLASH steno_tonic_pitch {
2138 $$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2);
2140 | CHORD_BASS steno_tonic_pitch {
2141 $$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2);
2150 $$ = scm_reverse_x ($1, SCM_EOL);
2158 step_number { $$ = gh_cons ($1, SCM_EOL); }
2159 | step_numbers '.' step_number {
2160 $$ = gh_cons ($3, $$);
2166 $$ = make_chord_step ($1, 0);
2168 | bare_unsigned '+' {
2169 $$ = make_chord_step ($1, SHARP);
2171 | bare_unsigned CHORD_MINUS {
2172 $$ = make_chord_step ($1, FLAT);
2179 TODO: should deprecate in favor of Scheme?
2183 number_expression '+' number_term {
2184 $$ = scm_sum ($1, $3);
2186 | number_expression '-' number_term {
2187 $$ = scm_difference ($1, $3);
2196 | number_factor '*' number_factor {
2197 $$ = scm_product ($1, $3);
2199 | number_factor '/' number_factor {
2200 $$ = scm_divide ($1, $3);
2205 '-' number_factor { /* %prec UNARY_MINUS */
2206 $$ = scm_difference ($2, SCM_UNDEFINED);
2214 $$ = gh_int2scm ($1);
2219 | NUMBER_IDENTIFIER {
2222 | REAL NUMBER_IDENTIFIER {
2223 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2225 | UNSIGNED NUMBER_IDENTIFIER {
2226 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2242 if (scm_integer_p ($1) == SCM_BOOL_T)
2244 int k = gh_scm2int ($1);
2248 THIS->parser_error (_ ("need integer number arg"));
2262 | STRING_IDENTIFIER {
2265 | string '+' string {
2266 $$ = scm_string_append (scm_list_2 ($1, $3));
2273 | exclamations '!' { $$ ++; }
2278 | questions '?' { $$ ++; }
2288 { THIS->lexer_->push_markup_state (); }
2291 THIS->lexer_->pop_state ();
2297 This should be done more dynamically if possible.
2301 $$ = make_simple_markup ($1);
2303 | MARKUP_HEAD_EMPTY {
2304 $$ = scm_list_1 ($1);
2306 | MARKUP_HEAD_MARKUP0 markup {
2307 $$ = scm_list_2 ($1, $2);
2309 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2310 $$ = scm_list_3 ($1, $2, $3);
2312 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2313 $$ = scm_list_3 ($1, $2, $3);
2318 | MARKUP_HEAD_LIST0 markup_list {
2319 $$ = scm_list_2 ($1,$2);
2321 | MARKUP_HEAD_SCM0 embedded_scm {
2322 $$ = scm_list_2 ($1, $2);
2324 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2325 $$ = scm_list_4 ($1, $2, $3, $4);
2327 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2328 $$ = scm_list_4 ($1, $2, $3, $4);
2330 | MARKUP_HEAD_SCM0_SCM1 embedded_scm embedded_scm {
2331 $$ = scm_list_3 ($1, $2, $3);
2333 | MARKUP_IDENTIFIER {
2336 | STRING_IDENTIFIER {
2342 chord_open markup_list_body chord_close { $$ = scm_reverse_x ($2, SCM_EOL); }
2346 '{' markup_list_body '}' {
2349 line = scm_c_eval_string ("line-markup");
2351 $$ = scm_list_2 (line, scm_reverse_x ($2, SCM_EOL));
2356 /**/ { $$ = SCM_EOL; }
2357 | markup_list_body markup {
2358 $$ = gh_cons ($2, $1) ;
2366 My_lily_parser::set_yydebug (bool )
2373 extern My_lily_parser * current_parser;
2376 My_lily_parser::do_yyparse ()
2378 current_parser = this;;
2379 yyparse ((void*)this);
2384 Should make this optional? It will also complain when you do
2388 which is entirely legitimate.
2390 Or we can scrap it. Barchecks should detect wrong durations, and
2391 skipTypesetting speeds it up a lot.
2395 My_lily_parser::beam_check (SCM dur)
2397 Duration *d = unsmob_duration (dur);
2398 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2400 Music * m = unsmob_music (last_beam_start_);
2401 m->origin ()->warning (_("Suspect duration found following this beam"));
2403 last_beam_start_ = SCM_EOL;
2411 It is a little strange to have this function in this file, but
2412 otherwise, we have to import music classes into the lexer.
2416 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2418 if (gh_string_p (sid)) {
2420 return STRING_IDENTIFIER;
2421 } else if (gh_number_p (sid)) {
2423 return NUMBER_IDENTIFIER;
2424 } else if (unsmob_context_def (sid)) {
2425 *destination = unsmob_context_def (sid)->clone_scm ();
2426 return CONTEXT_DEF_IDENTIFIER;
2427 } else if (unsmob_score (sid)) {
2428 Score *sc = new Score (*unsmob_score (sid));
2429 *destination =sc->self_scm ();
2430 return SCORE_IDENTIFIER;
2431 } else if (Music * mus =unsmob_music (sid)) {
2432 mus = mus->clone ();
2433 *destination = mus->self_scm ();
2434 unsmob_music (*destination)->
2435 set_property ("origin", make_input (last_input_));
2436 return dynamic_cast<Event*> (mus)
2437 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2438 } else if (unsmob_duration (sid)) {
2439 *destination = unsmob_duration (sid)->smobbed_copy ();
2440 return DURATION_IDENTIFIER;
2441 } else if (unsmob_music_output_def (sid)) {
2442 Music_output_def *p = unsmob_music_output_def (sid);
2445 *destination = p->self_scm ();
2446 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2447 } else if (Text_item::markup_p (sid)) {
2449 return MARKUP_IDENTIFIER;
2456 property_op_to_music (SCM op)
2459 SCM tag = gh_car (op);
2460 SCM symbol = gh_cadr (op);
2461 SCM args = gh_cddr (op);
2462 SCM grob_val = SCM_UNDEFINED;
2463 SCM grob_sym = SCM_UNDEFINED;
2464 SCM val = SCM_UNDEFINED;
2466 if (tag == ly_symbol2scm ("assign"))
2468 m = MY_MAKE_MUSIC ("PropertySet");
2469 val = gh_car (args);
2471 else if (tag == ly_symbol2scm ("unset"))
2472 m = MY_MAKE_MUSIC ("PropertyUnset");
2473 else if (tag == ly_symbol2scm ("poppush")
2474 || tag == ly_symbol2scm ("push"))
2476 m = MY_MAKE_MUSIC ("OverrideProperty");
2477 grob_sym = gh_car (args);
2478 grob_val = gh_cadr (args);
2480 else if (tag == ly_symbol2scm ("pop")) {
2481 m = MY_MAKE_MUSIC ("RevertProperty");
2482 grob_sym = gh_car (args);
2485 m->set_property ("symbol", symbol);
2487 if (val != SCM_UNDEFINED)
2488 m->set_property ("value", val);
2489 if (grob_val != SCM_UNDEFINED)
2490 m->set_property ("grob-value", grob_val);
2492 if (grob_sym != SCM_UNDEFINED)
2494 bool itc = internal_type_checking_global_b;
2497 bool autobeam = gh_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
2499 internal_type_checking_global_b = false;
2500 m->set_property ("grob-property", grob_sym);
2502 internal_type_checking_global_b = itc;
2505 if (op == ly_symbol2scm ("poppush"))
2506 m->set_property ("pop-first", SCM_BOOL_T);
2513 context_spec_music (SCM type, SCM id, Music * m, SCM ops)
2515 Music * csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
2517 csm->set_property ("element", m->self_scm ());
2518 scm_gc_unprotect_object (m->self_scm ());
2520 csm->set_property ("context-type",
2521 gh_symbol_p (type) ? type : scm_string_to_symbol (type));
2522 csm->set_property ("property-operations", ops);
2524 if (gh_string_p (id))
2525 csm->set_property ("context-id", id);
2531 get_next_unique_context ()
2533 static int new_context_count;
2536 snprintf (s, 1024, "uniqueContext%d", new_context_count ++);
2538 return scm_makfrom0str (s);