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 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?
59 #include "scm-option.hh"
60 #include "translator-def.hh"
61 #include "lily-guile.hh"
63 #include "my-lily-lexer.hh"
64 #include "paper-def.hh"
65 #include "midi-def.hh"
67 #include "file-path.hh"
69 #include "dimensions.hh"
70 #include "my-lily-parser.hh"
72 #include "input-file-results.hh"
74 #include "lilypond-input-version.hh"
75 #include "scm-hash.hh"
76 #include "auto-change-iterator.hh"
77 #include "ly-modules.hh"
78 #include "music-sequence.hh"
79 #include "input-smob.hh"
81 #include "text-item.hh"
82 #include "music-list.hh"
85 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
89 #define YYERROR_VERBOSE 1
91 My_lily_parser* my_lily_parser;
92 #define YYPARSE_PARAM my_lily_parser
93 #define YYLEX_PARAM my_lily_parser
95 ((My_lily_parser *) my_lily_parser)
97 #define yyerror THIS->parser_error
104 regular_identifier_b (SCM id)
106 String str = ly_scm2string (id);
107 char const *s = str.to_str0 () ;
112 v = v && isalpha (*s);
119 make_simple_markup (SCM a)
123 simple = scm_c_eval_string ("simple-markup");
125 return scm_list_n (simple, a, SCM_UNDEFINED);
130 is_duration_b (int t)
132 return t && t == 1 << intlog2 (t);
136 set_music_properties (Music *p, SCM a)
138 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
140 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
145 make_chord_step (int step, int alter)
150 /* ugh: fucks up above 13 */
151 Pitch m(step > 7 ? 1 : 0,(step - 1) % 7, alter);
152 return m.smobbed_copy ();
157 make_chord (SCM pitch, SCM dur, SCM modification_list)
159 static SCM chord_ctor;
161 chord_ctor= scm_c_eval_string ("construct-chord");
162 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
163 scm_gc_protect_object (ch);
168 Todo: actually also use apply iso. call too ...
171 ly_input_procedure_p (SCM x)
173 return gh_procedure_p (x)
174 || (gh_pair_p (x) && gh_procedure_p (gh_car (x)));
178 set_property_music (SCM sym, SCM value)
180 Music * p = MY_MAKE_MUSIC("PropertySet");
181 p->set_mus_property ("symbol", sym);
182 p->set_mus_property ("value", value);
188 /* We use SCMs to do strings, because it saves us the trouble of
189 deleting them. Let's hope that a stack overflow doesnt trigger a move
190 of the parse stack onto the heap. */
197 Music_output_def * outputdef;
204 yylex (YYSTYPE *s, void * v)
206 My_lily_parser *pars = (My_lily_parser*) v;
207 My_lily_lexer * lex = pars->lexer_;
209 lex->lexval = (void*) s;
210 lex->prepare_for_next_token();
211 return lex->yylex ();
230 %token CHORDMODIFIERS
235 %token COMMANDSPANREQUEST
244 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
245 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
249 %token GROBDESCRIPTIONS
257 %token MULTI_MEASURE_REST
263 %token OUTPUTPROPERTY
264 %token OVERRIDE SET REVERT
291 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
292 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
294 %token <i> E_UNSIGNED
295 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
298 %type <i> exclamations questions dots optional_rest
300 %type <scm> grace_head
301 %type <scm> lyric_element
302 %type <scm> bass_number br_bass_figure bass_figure figure_list figure_spec
304 %token <scm> NOTENAME_PITCH
305 %token <scm> TONICNAME_PITCH
306 %token <scm> CHORDMODIFIER_PITCH
307 %token <scm> DURATION_IDENTIFIER
308 %token <scm> FRACTION
309 %token <id> IDENTIFIER
310 %token <scm> CHORDNAMES
312 %token <scm> CHORD_MODIFIER
314 %token <scm> SCORE_IDENTIFIER
315 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
316 %token <scm> NUMBER_IDENTIFIER
317 %token <scm> EVENT_IDENTIFIER
318 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
319 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
320 %token <scm> RESTNAME
327 %token <scm> MARKUP_HEAD_MARKUP0
328 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
329 %token <scm> MARKUP_HEAD_SCM0
330 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
331 %token <scm> MARKUP_HEAD_SCM0_SCM1
332 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
333 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
335 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
336 %type <scm> markup markup_line markup_list markup_list_body full_markup
338 %type <outputdef> output_def
339 %type <scm> lilypond_header lilypond_header_body
340 %type <music> open_event close_event
341 %type <i> sub_quotes sup_quotes
342 %type <music> simple_element event_chord command_element Simple_music Composite_music
343 %type <music> Repeated_music
344 %type <scm> Alternative_music
345 %type <i> tremolo_type
346 %type <i> bare_int bare_unsigned
348 %type <scm> identifier_init
350 %type <music> note_chord_element chord_body chord_body_element
351 %type <scm> chord_body_elements
352 %type <scm> steno_duration optional_notemode_duration multiplied_duration
353 %type <scm> verbose_duration
355 %type <scm> post_events
356 %type <music> gen_text_def direction_less_event direction_reqd_event
357 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
358 %type <scm> explicit_pitch steno_tonic_pitch
359 %type <scm> duration_length fraction
361 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
363 %type <scm> embedded_scm scalar
364 %type <music> Music Sequential_music Simultaneous_music
365 %type <music> relative_music re_rhythmed_music part_combined_music
366 %type <music> property_def translator_change simple_property_def
367 %type <scm> Music_list
368 %type <outputdef> music_output_def_body
369 %type <music> shorthand_command_req
370 %type <music> post_event
371 %type <music> command_req verbose_command_req
372 %type <music> extender_req
373 %type <music> hyphen_req
374 %type <music> string_number_event
375 %type <scm> string bare_number number_expression number_term number_factor
376 %type <score> score_block score_body
378 %type <scm> translator_spec_block translator_spec_body
379 %type <music> tempo_event
380 %type <scm> notenames_body notenames_block chordmodifiers_block
381 %type <scm> script_abbreviation
387 /* We don't assign precedence to / and *, because we might need varied
388 prec levels in different prods */
394 lilypond: /* empty */
395 | lilypond toplevel_expression {}
396 | lilypond assignment { }
398 THIS->error_level_ = 1;
401 THIS->error_level_ = 1;
407 THIS->lexer_->pitchname_tab_ = $1;
409 | chordmodifiers_block {
410 THIS->lexer_->chordmodifier_tab_ = $1;
413 THIS->input_file_->header_ = $1;
416 THIS->input_file_->scores_.push ($1);
419 if (dynamic_cast<Paper_def*> ($1))
420 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
421 else if (dynamic_cast<Midi_def*> ($1))
422 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
432 chordmodifiers_block:
433 CHORDMODIFIERS notenames_body { $$ = $2; }
437 PITCHNAMES notenames_body { $$ = $2; }
442 int i = scm_ilength ($1);
444 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
445 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
446 SCM pt = ly_cdar (s);
447 scm_hashq_set_x (tab, ly_caar (s), pt);
453 lilypond_header_body:
455 $$ = ly_make_anonymous_module ();
456 THIS->lexer_->add_scope ($$);
458 | lilypond_header_body assignment {
464 HEADER '{' lilypond_header_body '}' {
465 $$ = THIS->lexer_-> remove_scope();
477 /* cont */ '=' identifier_init {
480 Should find generic way of associating input with objects.
482 Input ip = THIS->pop_spot ();
484 if (! regular_identifier_b ($1))
486 ip.warning (_ ("Identifier should have alphabetic characters only"));
489 THIS->lexer_->set_identifier ($1, $4);
492 TODO: devise standard for protection in parser.
494 The parser stack lives on the C-stack, which means that
495 all objects can be unprotected as soon as they're here.
506 $$ = $1->self_scm ();
507 scm_gc_unprotect_object ($$);
513 $$ = $1->self_scm ();
514 scm_gc_unprotect_object ($$);
516 | translator_spec_block {
520 $$ = $1->self_scm ();
521 scm_gc_unprotect_object ($$);
524 $$ = $1->self_scm ();
525 scm_gc_unprotect_object ($$);
530 | number_expression {
541 translator_spec_block:
542 TRANSLATOR '{' translator_spec_body '}'
548 translator_spec_body:
549 TRANSLATOR_IDENTIFIER {
551 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
554 $$ = Translator_def::make_scm ();
555 Translator_def*td = unsmob_translator_def ($$);
556 td->translator_group_type_ = $2;
557 td->set_spot (THIS->here_input ());
559 | translator_spec_body DESCRIPTION string {
560 unsmob_translator_def ($$)->description_ = $3;
562 | translator_spec_body STRING '=' embedded_scm {
563 unsmob_translator_def ($$)->add_property_assign ($2, $4);
565 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
566 unsmob_translator_def ($$)
567 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
569 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
570 unsmob_translator_def ($$)
571 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
573 | translator_spec_body STRING REVERT embedded_scm {
574 unsmob_translator_def ($$)->add_pop_property (
575 scm_string_to_symbol ($2), $4);
577 | translator_spec_body NAME STRING {
578 unsmob_translator_def ($$)->type_name_ = scm_string_to_symbol ($3);
580 | translator_spec_body CONSISTS STRING {
581 unsmob_translator_def ($$)->add_element ($3);
583 | translator_spec_body ALIAS STRING {
584 Translator_def*td = unsmob_translator_def ($$);
585 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
587 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
588 Translator_def*td = unsmob_translator_def($$);
589 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
590 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
591 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
593 | translator_spec_body CONSISTSEND STRING {
594 unsmob_translator_def ($$)->add_last_element ( $3);
596 | translator_spec_body ACCEPTS STRING {
597 unsmob_translator_def ($$)->set_acceptor (scm_string_to_symbol ($3), true);
599 | translator_spec_body DENIES STRING {
600 unsmob_translator_def ($$)->set_acceptor (scm_string_to_symbol ($3), false);
602 | translator_spec_body REMOVE STRING {
603 unsmob_translator_def ($$)->remove_element ($3);
614 /*cont*/ '{' score_body '}' {
617 if (!$$->defs_.size ())
619 Music_output_def *id =
620 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
621 $$->add_output (id ? id->clone () : new Paper_def );
630 $$->set_spot (THIS->here_input ());
631 SCM m = $1->self_scm ();
632 scm_gc_unprotect_object (m);
637 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
638 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
639 m = gh_call1 (gh_car (check_funcs), m);
644 $$ = unsmob_score ($1);
645 $$->set_spot (THIS->here_input ());
647 | score_body lilypond_header {
650 | score_body output_def {
663 music_output_def_body '}' {
665 THIS-> lexer_-> remove_scope ();
669 music_output_def_body:
671 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
676 p = dynamic_cast<Midi_def*> (id->clone ());
681 THIS->lexer_->add_scope (p->scope_);
684 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
687 p = dynamic_cast<Paper_def*> (id->clone ());
691 THIS->lexer_->add_scope (p->scope_);
694 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
695 Music_output_def * o = unsmob_music_output_def ($3);
698 THIS->lexer_->add_scope (o->scope_);
700 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
701 Music_output_def * o = unsmob_music_output_def ($3);
704 THIS->lexer_->add_scope (o->scope_);
706 | music_output_def_body assignment {
709 | music_output_def_body translator_spec_block {
710 $$->assign_translator ($2);
712 | music_output_def_body tempo_event {
714 junk this ? there already is tempo stuff in
717 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
718 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
719 Midi_def * md = dynamic_cast<Midi_def*> ($$);
721 md->set_tempo (d->get_length (), m);
723 | music_output_def_body error {
729 TEMPO steno_duration '=' bare_unsigned {
730 $$ = MY_MAKE_MUSIC("MetronomeChangeEvent");
731 $$->set_mus_property ("tempo-unit", $2);
732 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
737 The representation of a list is the
741 to have efficient append.
745 $$ = scm_cons (SCM_EOL, SCM_EOL);
749 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
750 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
751 if (gh_pair_p (ly_cdr (s)))
752 gh_set_cdr_x (ly_cdr (s), c); /* append */
754 gh_set_car_x (s, c); /* set first cons */
755 gh_set_cdr_x (s, c) ; /* remember last cell */
771 | ALTERNATIVE '{' Music_list '}' {
777 REPEAT string bare_unsigned Music Alternative_music
781 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
782 if (times < scm_ilength (alts)) {
783 unsmob_music (gh_car (alts))
784 ->origin ()->warning (
785 _("More alternatives than repeats. Junking excess alternatives."));
786 alts = ly_truncate_list (times, alts);
792 proc = scm_c_eval_string ("make-repeated-music");
794 SCM mus = scm_call_1 (proc, $2);
795 scm_gc_protect_object (mus); // UGH.
796 Music *r =unsmob_music (mus);
799 r-> set_mus_property ("element", beg->self_scm ());
800 scm_gc_unprotect_object (beg->self_scm ());
802 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
804 r-> set_mus_property ("elements",alts);
805 if (gh_equal_p ($2, scm_makfrom0str ("tremolo"))) {
807 we can not get durations and other stuff correct down the line, so we have to
808 add to the duration log here.
813 func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
815 int dots = ($3 % 3) ? 0 : 1;
816 int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
818 Sequential_music * seq = dynamic_cast<Sequential_music*> ($4);
821 int list_len =scm_ilength (seq->music_list ());
823 seq->origin ()->warning ("Chord tremolo must have 2 elements.");
825 r->compress (Moment (Rational (1,list_len)));
827 gh_call3 (func, r->self_scm (), gh_int2scm(shift),gh_int2scm(dots));
830 r->set_spot (*$4->origin ());
837 SEQUENTIAL '{' Music_list '}' {
838 $$ = MY_MAKE_MUSIC("SequentialMusic");
839 $$->set_mus_property ("elements", ly_car ($3));
840 $$->set_spot(THIS->here_input());
842 | '{' Music_list '}' {
843 $$ = MY_MAKE_MUSIC("SequentialMusic");
844 $$->set_mus_property ("elements", ly_car ($2));
845 $$->set_spot(THIS->here_input());
850 SIMULTANEOUS '{' Music_list '}'{
851 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
852 $$->set_mus_property ("elements", ly_car ($3));
853 $$->set_spot(THIS->here_input());
856 | '<' Music_list '>' {
857 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
858 $$->set_mus_property ("elements", ly_car ($2));
859 $$->set_spot(THIS->here_input());
864 event_chord { $$ = $1; }
865 | APPLYOUTPUT embedded_scm {
866 if (!ly_input_procedure_p ($2))
867 THIS->parser_error (_ ("\\applycontext takes function argument"));
868 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
869 $$->set_mus_property ("procedure", $2);
870 $$->set_spot (THIS->here_input());
872 | APPLYCONTEXT embedded_scm {
873 if (!ly_input_procedure_p ($2))
874 THIS->parser_error (_ ("\\applycontext takes function argument"));
875 $$ = MY_MAKE_MUSIC ("ApplyContext");
876 $$->set_mus_property ("procedure", $2);
877 $$->set_spot (THIS->here_input());
879 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
881 if (!gh_symbol_p ($3))
883 THIS->parser_error (_ ("Second argument must be a symbol"));
885 /* Should check # args */
886 if (!gh_procedure_p (pred))
888 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
891 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
892 m->set_mus_property ("predicate", pred);
893 m->set_mus_property ("grob-property", $3);
894 m->set_mus_property ("grob-value", $5);
899 $$ = unsmob_music ($1);
907 GRACE { $$ = scm_makfrom0str ("Grace"); }
908 | ACCIACATURA { $$ = scm_makfrom0str ("Acciaccatura"); }
909 | APPOGGIATURA { $$ = scm_makfrom0str ("Appoggiatura"); }
914 CONTEXT STRING Music {
915 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
917 csm->set_mus_property ("element", $3->self_scm ());
918 scm_gc_unprotect_object ($3->self_scm ());
920 csm->set_mus_property ("context-type", scm_string_to_symbol ($2));
921 csm->set_mus_property ("context-id", scm_makfrom0str (""));
925 | AUTOCHANGE STRING Music {
926 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
927 chm->set_mus_property ("element", $3->self_scm ());
928 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
930 scm_gc_unprotect_object ($3->self_scm ());
931 chm->set_mus_property ("what", scm_string_to_symbol ($2));
934 chm->set_spot (*$3->origin ());
939 The other version is for easier debugging of
940 Sequential_music_iterator in combination with grace notes.
945 TODO: should distinguish between both grace types in the
946 basic music objects too, since the meaning is different.
950 String start_str = "start" + ly_scm2string ($1) + "Music";
951 String stop_str = "stop" + ly_scm2string ($1) + "Music";
953 SCM start = THIS->lexer_->lookup_identifier (start_str);
954 SCM stop = THIS->lexer_->lookup_identifier (stop_str);
956 Music *startm = unsmob_music (start);
957 Music *stopm = unsmob_music (stop);
961 stopm = stopm->clone ();
962 ms = scm_cons (stopm->self_scm (), ms);
963 scm_gc_unprotect_object (stopm->self_scm ());
965 ms = scm_cons ($2->self_scm (), ms);
966 scm_gc_unprotect_object ($2->self_scm());
968 startm = startm->clone ();
969 ms = scm_cons (startm->self_scm () , ms);
970 scm_gc_unprotect_object (startm->self_scm ());
974 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
975 seq->set_mus_property ("elements", ms);
978 $$ = MY_MAKE_MUSIC("GraceMusic");
979 $$->set_mus_property ("element", seq->self_scm ());
980 scm_gc_unprotect_object (seq->self_scm ());
982 $$ = MY_MAKE_MUSIC("GraceMusic");
983 $$->set_mus_property ("element", $2->self_scm ());
984 scm_gc_unprotect_object ($2->self_scm ());
987 | CONTEXT string '=' string Music {
988 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
990 csm->set_mus_property ("element", $5->self_scm ());
991 scm_gc_unprotect_object ($5->self_scm ());
993 csm->set_mus_property ("context-type", scm_string_to_symbol ($2));
994 csm->set_mus_property ("context-id", $4);
998 | NEWCONTEXT string Music {
999 static int new_context_count;
1001 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1003 csm->set_mus_property ("element", $3->self_scm ());
1004 scm_gc_unprotect_object ($3->self_scm ());
1006 csm->set_mus_property ("context-type", scm_string_to_symbol ($2));
1008 SCM new_id = scm_number_to_string (gh_int2scm (new_context_count ++),
1010 csm->set_mus_property ("context-id", new_id);
1020 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
1023 $$= MY_MAKE_MUSIC("TimeScaledMusic");
1024 $$->set_spot (THIS->pop_spot ());
1026 $$->set_mus_property ("element", mp->self_scm ());
1027 scm_gc_unprotect_object (mp->self_scm ());
1028 $$->set_mus_property ("numerator", gh_int2scm (n));
1029 $$->set_mus_property ("denominator", gh_int2scm (d));
1030 $$->compress (Moment (Rational (n,d)));
1033 | Repeated_music { $$ = $1; }
1034 | Simultaneous_music { $$ = $1; }
1035 | Sequential_music { $$ = $1; }
1036 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
1037 $$ = MY_MAKE_MUSIC("TransposedMusic");
1039 Pitch from = *unsmob_pitch ($2);
1040 Pitch to = *unsmob_pitch ($3);
1042 p->transpose (interval (from, to));
1043 $$->set_mus_property ("element", p->self_scm ());
1044 scm_gc_unprotect_object (p->self_scm ());
1046 | APPLY embedded_scm Music {
1047 if (!ly_input_procedure_p ($2))
1048 THIS->parser_error (_ ("\\apply takes function argument"));
1050 SCM ret = gh_call1 ($2, $3->self_scm ());
1051 Music *m = unsmob_music (ret);
1053 THIS->parser_error ("\\apply must return a Music");
1054 m = MY_MAKE_MUSIC("Music");
1059 { THIS->lexer_->push_note_state (); }
1062 THIS->lexer_->pop_state ();
1065 { THIS->lexer_->push_figuredbass_state (); }
1068 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1069 chm->set_mus_property ("element", $3->self_scm ());
1071 scm_gc_unprotect_object ($3->self_scm());
1073 THIS->lexer_->pop_state ();
1076 { THIS->lexer_->push_chord_state (); }
1079 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1080 chm->set_mus_property ("element", $3->self_scm ());
1081 scm_gc_unprotect_object ($3->self_scm());
1084 THIS->lexer_->pop_state ();
1087 { THIS->lexer_->push_lyric_state (); }
1091 THIS->lexer_->pop_state ();
1093 | relative_music { $$ = $1; }
1094 | re_rhythmed_music { $$ = $1; }
1095 | part_combined_music { $$ = $1; }
1099 RELATIVE absolute_pitch Music {
1101 Pitch pit = *unsmob_pitch ($2);
1102 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1104 $$->set_mus_property ("element", p->self_scm ());
1105 scm_gc_unprotect_object (p->self_scm ());
1108 Pitch retpitch = p->to_relative_octave (pit);
1109 if (lily_1_8_relative)
1110 $$->set_mus_property ("last-pitch", retpitch.smobbed_copy ());
1115 ADDLYRICS Music Music {
1116 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1117 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1118 scm_gc_unprotect_object ($3->self_scm ());
1119 scm_gc_unprotect_object ($2->self_scm ());
1124 part_combined_music:
1125 PARTCOMBINE STRING Music Music {
1126 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1127 p->set_mus_property ("what", scm_string_to_symbol ($2));
1128 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1130 scm_gc_unprotect_object ($3->self_scm ());
1131 scm_gc_unprotect_object ($4->self_scm ());
1138 TRANSLATOR STRING '=' STRING {
1139 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1140 t-> set_mus_property ("change-to-type", scm_string_to_symbol ($2));
1141 t-> set_mus_property ("change-to-id", $4);
1144 $$->set_spot (THIS->here_input ());
1150 | ONCE simple_property_def {
1152 SCM e = $2->get_mus_property ("element");
1153 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1157 simple_property_def:
1158 PROPERTY STRING '.' STRING '=' scalar {
1159 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1160 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1162 csm->set_mus_property ("element", t->self_scm ());
1163 scm_gc_unprotect_object (t->self_scm ());
1166 $$->set_spot (THIS->here_input ());
1168 csm-> set_mus_property ("context-type", scm_string_to_symbol ($2));
1170 | PROPERTY STRING '.' STRING UNSET {
1172 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1173 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1175 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1176 csm->set_mus_property ("element", t->self_scm ());
1177 scm_gc_unprotect_object (t->self_scm ());
1180 $$->set_spot (THIS->here_input ());
1182 csm-> set_mus_property ("context-type", scm_string_to_symbol ($2));
1184 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1186 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1187 bool itc = internal_type_checking_global_b;
1188 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1189 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1190 t->set_mus_property ("pop-first", SCM_BOOL_T);
1192 internal_type_checking_global_b = false;
1193 t->set_mus_property ("grob-property", $6);
1195 internal_type_checking_global_b = itc;
1196 t->set_mus_property ("grob-value", $8);
1198 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1199 csm->set_mus_property ("element", t->self_scm ());
1200 scm_gc_unprotect_object (t->self_scm ());
1202 $$->set_spot (THIS->here_input ());
1204 csm-> set_mus_property ("context-type", scm_string_to_symbol ($2));
1206 | PROPERTY STRING '.' STRING OVERRIDE
1207 embedded_scm '=' embedded_scm
1213 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1214 bool itc = internal_type_checking_global_b;
1216 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1217 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1219 internal_type_checking_global_b = false;
1220 t->set_mus_property ("grob-property", $6);
1221 t->set_mus_property ("grob-value", $8);
1223 internal_type_checking_global_b = itc;
1225 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1226 csm->set_mus_property ("element", t->self_scm ());
1227 scm_gc_unprotect_object (t->self_scm ());
1230 $$->set_spot (THIS->here_input ());
1232 csm-> set_mus_property ("context-type", scm_string_to_symbol ($2));
1235 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1236 Music *t = MY_MAKE_MUSIC("RevertProperty");
1238 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1239 bool itc = internal_type_checking_global_b;
1241 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1243 internal_type_checking_global_b = false;
1244 t->set_mus_property ("grob-property", $6);
1246 internal_type_checking_global_b = itc;
1248 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1249 csm->set_mus_property ("element", t->self_scm ());
1250 scm_gc_unprotect_object (t->self_scm ());
1253 $$->set_spot (THIS->here_input ());
1255 csm-> set_mus_property ("context-type", scm_string_to_symbol ($2));
1262 | bare_int { $$ = gh_int2scm ($1); }
1263 | embedded_scm { $$ = $1; }
1264 | full_markup { $$ = $1; }
1265 | DIGIT { $$ = gh_int2scm ($1); }
1273 Adding pre_events to the simple_element
1274 makes the choice between
1280 simple_element: STRING
1282 a single shift/reduction conflict.
1284 nevertheless, this is not very clean, and we should find a different
1294 pre_events simple_element post_events {
1295 SCM elts = $2-> get_mus_property ("elements");
1297 elts = gh_append2 (elts, scm_reverse_x ($3, SCM_EOL));
1299 $2->set_mus_property ("elements", elts);
1303 | note_chord_element
1308 chord_body optional_notemode_duration post_events
1310 SCM dur = unsmob_duration ($2)->smobbed_copy();
1311 SCM es = $1->get_mus_property ("elements");
1312 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1314 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1315 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1316 es = gh_append2 (es, postevs);
1318 $1-> set_mus_property ("elements", es);
1324 CHORD_OPEN chord_body_elements CHORD_CLOSE
1326 $$ = MY_MAKE_MUSIC("EventChord");
1327 $$->set_mus_property ("elements",
1328 scm_reverse_x ($2, SCM_EOL));
1332 chord_body_elements:
1333 /* empty */ { $$ = SCM_EOL; }
1334 | chord_body_elements chord_body_element {
1335 $$ = gh_cons ($2->self_scm(), $1);
1336 scm_gc_unprotect_object ($2->self_scm());
1341 pitch exclamations questions post_events
1343 Music * n = MY_MAKE_MUSIC("NoteEvent");
1344 n->set_mus_property ("pitch", $1);
1346 n->set_mus_property ("cautionary", SCM_BOOL_T);
1347 if ($2 % 2 || $3 % 2)
1348 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1350 SCM arts = scm_reverse_x ($4, SCM_EOL);
1351 n->set_mus_property ("articulations", arts);
1359 $$ = MY_MAKE_MUSIC("EventChord");
1360 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1361 scm_gc_unprotect_object ($1->self_scm());
1363 $$-> set_spot (THIS->here_input ());
1364 $1-> set_spot (THIS->here_input ());
1366 | OCTAVE { THIS->push_spot (); }
1368 Music *l = MY_MAKE_MUSIC("RelativeOctaveCheck");
1370 $$->set_spot (THIS->pop_spot ());
1371 $$->set_mus_property ("pitch", $3);
1374 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1375 l->set_mus_property ("span-direction", gh_int2scm (START));
1376 l->set_spot (THIS->here_input ());
1378 $$ = MY_MAKE_MUSIC("EventChord");
1379 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1380 scm_gc_unprotect_object (l->self_scm());
1381 $$->set_spot (THIS->here_input ());
1384 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1385 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1386 l->set_spot (THIS->here_input ());
1388 $$ = MY_MAKE_MUSIC("EventChord");
1389 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1390 $$->set_spot (THIS->here_input ());
1391 scm_gc_unprotect_object (l->self_scm());
1394 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1395 $$->set_spot (THIS->here_input ());
1399 $$ = MY_MAKE_MUSIC("BarCheck");
1400 $$->set_spot (THIS->here_input ());
1403 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1405 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1406 csm->set_mus_property ("element", t->self_scm ());
1407 scm_gc_unprotect_object (t->self_scm ());
1410 $$->set_spot (THIS->here_input ());
1412 csm->set_mus_property ("context-type", ly_symbol2scm ("Timing"));
1414 | PARTIAL duration_length {
1415 Moment m = - unsmob_duration ($2)->get_length ();
1416 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1418 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1419 sp->set_mus_property ("element", p->self_scm ());
1420 scm_gc_unprotect_object (p->self_scm ());
1423 sp-> set_mus_property ("context-type", ly_symbol2scm ("Timing"));
1428 proc = scm_c_eval_string ("make-clef-set");
1430 SCM result = scm_call_1 (proc, $2);
1431 scm_gc_protect_object (result);
1432 $$ = unsmob_music (result);
1437 proc = scm_c_eval_string ("make-time-signature-set");
1439 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1440 scm_gc_protect_object (result);
1441 $$ = unsmob_music (result);
1446 shorthand_command_req { $$ = $1; }
1447 | verbose_command_req { $$ = $1; }
1450 shorthand_command_req:
1458 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1461 $$ = MY_MAKE_MUSIC("PesOrFlexaEvent");
1465 verbose_command_req:
1467 Music * m = MY_MAKE_MUSIC("MarkEvent");
1471 Music *m = MY_MAKE_MUSIC("MarkEvent");
1472 m->set_mus_property ("label", $2);
1475 | SKIP duration_length {
1476 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1477 skip->set_mus_property ("duration", $2);
1485 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1488 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1490 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1491 if (scm_ilength ($3) > 0)
1493 key->set_mus_property ("pitch-alist", $3);
1494 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1495 ((Music*)key)->transpose (* unsmob_pitch ($2));
1497 THIS->parser_error (_("Second argument must be pitch list."));
1508 | post_events post_event {
1509 $2->set_spot (THIS->here_input ());
1510 $$ = gh_cons ($2->self_scm(), $$);
1511 scm_gc_unprotect_object ($2->self_scm());
1518 direction_less_event {
1521 | script_dir direction_reqd_event {
1522 $2->set_mus_property ("direction", gh_int2scm ($1));
1525 | script_dir direction_less_event {
1526 $2->set_mus_property ("direction", gh_int2scm ($1));
1529 | string_number_event
1532 string_number_event:
1534 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1535 s->set_mus_property ("string-number", gh_int2scm($1));
1536 s->set_spot (THIS->here_input ());
1542 direction_less_event:
1548 TODO: should take all these defs out of the parser, adn make use
1552 (set-articulation '~ "trill")
1555 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1556 m->set_spot (THIS->here_input());
1557 m->set_mus_property ("span-direction" , gh_int2scm (START));
1561 Music * m = MY_MAKE_MUSIC ("BeamEvent");
1562 m->set_spot (THIS->here_input());
1563 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1567 Music * m = MY_MAKE_MUSIC ("TieEvent");
1568 m->set_spot (THIS->here_input());
1573 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START));
1577 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1579 | EVENT_IDENTIFIER {
1580 $$ = unsmob_music ($1);
1583 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1584 a->set_spot (THIS->here_input ());
1585 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1590 direction_reqd_event:
1594 | script_abbreviation {
1595 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1596 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1597 if (gh_string_p (s))
1598 a->set_mus_property ("articulation-type", s);
1599 else THIS->parser_error (_ ("Expecting string as script definition"));
1626 | NOTENAME_PITCH sup_quotes {
1627 Pitch p = *unsmob_pitch ($1);
1628 p = p.transposed (Pitch ($2,0,0));
1629 $$ = p.smobbed_copy ();
1631 | NOTENAME_PITCH sub_quotes {
1632 Pitch p =* unsmob_pitch ($1);
1633 p = p.transposed (Pitch (-$2,0,0));
1634 $$ = p.smobbed_copy ();
1646 | TONICNAME_PITCH sup_quotes {
1647 Pitch p = *unsmob_pitch ($1);
1648 p = p.transposed (Pitch ($2,0,0));
1649 $$ = p.smobbed_copy ();
1651 | TONICNAME_PITCH sub_quotes {
1652 Pitch p =* unsmob_pitch ($1);
1654 p = p.transposed (Pitch (-$2,0,0));
1655 $$ = p.smobbed_copy ();
1668 pitch_also_in_chords:
1674 PITCH embedded_scm {
1676 if (!unsmob_pitch ($2)) {
1677 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1678 $$ = Pitch ().smobbed_copy ();
1684 DURATION embedded_scm {
1686 if (!unsmob_duration ($2))
1688 THIS->parser_error (_ ("Must have duration object"));
1689 $$ = Duration ().smobbed_copy ();
1696 if (!THIS->lexer_->lyric_state_b ())
1697 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1698 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1704 if (!THIS->lexer_->lyric_state_b ())
1705 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1706 $$ = MY_MAKE_MUSIC("HyphenEvent");
1712 Music * s= MY_MAKE_MUSIC("SlurEvent");
1714 s->set_spot (THIS->here_input());
1717 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1719 s->set_spot (THIS->here_input());
1722 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1724 s->set_spot (THIS->here_input());
1727 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1729 s->set_spot (THIS->here_input());
1736 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1737 s->set_spot (THIS->here_input());
1742 Music * s= MY_MAKE_MUSIC("SlurEvent");
1744 s->set_spot (THIS->here_input());
1748 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1750 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1751 s->set_spot (THIS->here_input());
1757 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1758 t->set_mus_property ("text", $1);
1759 t->set_spot (THIS->here_input ());
1763 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1764 t->set_mus_property ("text", make_simple_markup ($1));
1765 t->set_spot (THIS->here_input ());
1770 Music * t = MY_MAKE_MUSIC("FingerEvent");
1771 t->set_mus_property ("digit", gh_int2scm ($1));
1772 t->set_spot (THIS->here_input ());
1777 script_abbreviation:
1779 $$ = scm_makfrom0str ("Hat");
1782 $$ = scm_makfrom0str ("Plus");
1785 $$ = scm_makfrom0str ("Dash");
1788 $$ = scm_makfrom0str ("Bar");
1791 $$ = scm_makfrom0str ("Larger");
1794 $$ = scm_makfrom0str ("Dot");
1797 $$ = scm_makfrom0str ("Underscore");
1804 | '-' { $$ = CENTER; }
1815 multiplied_duration {
1818 | verbose_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 ($$);
1836 | verbose_duration {
1838 THIS->default_duration_ = *unsmob_duration ($$);
1843 bare_unsigned dots {
1845 if (!is_duration_b ($1))
1846 THIS->parser_error (_f ("not a duration: %d", $1));
1850 $$ = Duration (l, $2).smobbed_copy ();
1852 | DURATION_IDENTIFIER dots {
1853 Duration *d =unsmob_duration ($1);
1854 Duration k (d->duration_log (),d->dot_count () + $2);
1864 multiplied_duration:
1868 | multiplied_duration '*' bare_unsigned {
1869 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1871 | multiplied_duration '*' FRACTION {
1872 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1874 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1879 FRACTION { $$ = $1; }
1880 | UNSIGNED '/' UNSIGNED {
1881 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1899 | ':' bare_unsigned {
1900 if (!is_duration_b ($2))
1901 THIS->parser_error (_f ("not a duration: %d", $2));
1908 /*****************************************************************
1910 *****************************************************************/
1913 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1916 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1918 | STRING { $$ = $1 }
1929 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1930 $$ = bfr->self_scm();
1931 scm_gc_unprotect_object ($$);
1934 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1935 $$ = bfr->self_scm();
1937 bfr->set_mus_property ("figure", $1);
1939 scm_gc_unprotect_object ($$);
1941 | bass_figure bass_mod {
1942 Music *m = unsmob_music ($1);
1944 SCM salter =m->get_mus_property ("alteration");
1945 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1946 m->set_mus_property ("alteration",
1947 gh_int2scm (alter + $2));
1949 m->set_mus_property ("alteration", gh_int2scm (0));
1957 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1962 | br_bass_figure ']' {
1964 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1972 | figure_list br_bass_figure {
1973 $$ = scm_cons ($2, $1);
1978 FIGURE_OPEN figure_list FIGURE_CLOSE {
1979 Music * m = MY_MAKE_MUSIC("EventChord");
1980 $2 = scm_reverse_x ($2, SCM_EOL);
1981 m->set_mus_property ("elements", $2);
1982 $$ = m->self_scm ();
1993 pitch exclamations questions optional_notemode_duration optional_rest {
1995 Input i = THIS->pop_spot ();
1996 if (!THIS->lexer_->note_state_b ())
1997 THIS->parser_error (_ ("Have to be in Note mode for notes"));
2001 n = MY_MAKE_MUSIC("RestEvent");
2003 n = MY_MAKE_MUSIC("NoteEvent");
2005 n->set_mus_property ("pitch", $1);
2006 n->set_mus_property ("duration", $4);
2010 n->set_mus_property ("cautionary", SCM_BOOL_T);
2011 if ($2 % 2 || $3 % 2)
2012 n->set_mus_property ("force-accidental", SCM_BOOL_T);
2014 Music *v = MY_MAKE_MUSIC("EventChord");
2015 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
2016 scm_gc_unprotect_object (n->self_scm());
2022 | figure_spec optional_notemode_duration {
2023 Music * m = unsmob_music ($1);
2024 Input i = THIS->pop_spot ();
2026 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
2028 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
2032 | RESTNAME optional_notemode_duration {
2034 Input i = THIS->pop_spot ();
2036 if (ly_scm2string ($1) =="s") {
2038 ev = MY_MAKE_MUSIC("SkipEvent");
2041 ev = MY_MAKE_MUSIC("RestEvent");
2044 ev->set_mus_property ("duration" ,$2);
2046 Music * velt = MY_MAKE_MUSIC("EventChord");
2047 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
2052 | MULTI_MEASURE_REST optional_notemode_duration {
2057 proc = scm_c_eval_string ("make-multi-measure-rest");
2059 SCM mus = scm_call_2 (proc, $2,
2060 make_input (THIS->here_input()));
2061 scm_gc_protect_object (mus);
2062 $$ = unsmob_music (mus);
2065 | lyric_element optional_notemode_duration {
2066 Input i = THIS->pop_spot ();
2067 if (!THIS->lexer_->lyric_state_b ())
2068 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
2070 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
2071 lreq->set_mus_property ("text", $1);
2072 lreq->set_mus_property ("duration",$2);
2074 Music * velt = MY_MAKE_MUSIC("EventChord");
2075 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
2082 if (!THIS->lexer_->chord_state_b ())
2083 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2084 $$ = unsmob_music ($1);
2089 full_markup { $$ = $1 }
2090 | STRING { $$ = $1 ; }
2094 steno_tonic_pitch optional_notemode_duration {
2095 $$ = make_chord ($1, $2, SCM_EOL);
2097 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2098 SCM its = scm_reverse_x ($4, SCM_EOL);
2099 $$ = make_chord ($1, $2, gh_cons ($3, its));
2107 | chord_items chord_item {
2108 $$ = gh_cons ($2, $$);
2114 $$ = ly_symbol2scm ("chord-colon");
2117 $$ = ly_symbol2scm ("chord-caret");
2119 | CHORD_SLASH steno_tonic_pitch {
2120 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2122 | CHORD_BASS steno_tonic_pitch {
2123 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2132 $$ = scm_reverse_x ($1, SCM_EOL);
2140 step_number { $$ = gh_cons ($1, SCM_EOL); }
2141 | step_numbers '.' step_number {
2142 $$ = gh_cons ($3, $$);
2148 $$ = make_chord_step ($1, 0);
2150 | bare_unsigned '+' {
2151 $$ = make_chord_step ($1, 1);
2153 | bare_unsigned CHORD_MINUS {
2154 $$ = make_chord_step ($1,-1);
2161 TODO: should deprecate in favor of Scheme?
2165 number_expression '+' number_term {
2166 $$ = scm_sum ($1, $3);
2168 | number_expression '-' number_term {
2169 $$ = scm_difference ($1, $3);
2178 | number_factor '*' number_factor {
2179 $$ = scm_product ($1, $3);
2181 | number_factor '/' number_factor {
2182 $$ = scm_divide ($1, $3);
2187 '-' number_factor { /* %prec UNARY_MINUS */
2188 $$ = scm_difference ($2, SCM_UNDEFINED);
2196 $$ = gh_int2scm ($1);
2201 | NUMBER_IDENTIFIER {
2204 | REAL NUMBER_IDENTIFIER {
2205 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2207 | UNSIGNED NUMBER_IDENTIFIER {
2208 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2224 if (scm_integer_p ($1) == SCM_BOOL_T)
2226 int k = gh_scm2int ($1);
2230 THIS->parser_error (_ ("need integer number arg"));
2244 | STRING_IDENTIFIER {
2247 | string '+' string {
2248 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2255 | exclamations '!' { $$ ++; }
2260 | questions '?' { $$ ++; }
2270 { THIS->lexer_->push_markup_state (); }
2273 THIS->lexer_->pop_state ();
2279 This should be done more dynamically if possible.
2283 $$ = make_simple_markup ($1);
2285 | MARKUP_HEAD_MARKUP0 markup {
2286 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2288 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2289 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2291 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2292 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2297 | MARKUP_HEAD_LIST0 markup_list {
2298 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2300 | MARKUP_HEAD_SCM0 embedded_scm {
2301 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2303 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2304 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2306 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2307 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2309 | MARKUP_IDENTIFIER {
2316 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2320 '{' markup_list_body '}' {
2323 line = scm_c_eval_string ("line-markup");
2325 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2330 /**/ { $$ = SCM_EOL; }
2331 | markup_list_body markup {
2332 $$ = gh_cons ($2, $1) ;
2340 My_lily_parser::set_yydebug (bool )
2347 extern My_lily_parser * current_parser;
2350 My_lily_parser::do_yyparse ()
2352 current_parser = this;;
2353 yyparse ((void*)this);
2358 Should make this optional? It will also complain when you do
2362 which is entirely legitimate.
2364 Or we can scrap it. Barchecks should detect wrong durations, and
2365 skipTypesetting speeds it up a lot.
2369 My_lily_parser::beam_check (SCM dur)
2371 Duration *d = unsmob_duration (dur);
2372 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2374 Music * m = unsmob_music (last_beam_start_);
2375 m->origin ()->warning (_("Suspect duration found following this beam"));
2377 last_beam_start_ = SCM_EOL;
2385 It is a little strange to have this function in this file, but
2386 otherwise, we have to import music classes into the lexer.
2390 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2392 if (gh_string_p (sid)) {
2394 return STRING_IDENTIFIER;
2395 } else if (gh_number_p (sid)) {
2397 return NUMBER_IDENTIFIER;
2398 } else if (unsmob_translator_def (sid)) {
2399 *destination = unsmob_translator_def (sid)->clone_scm();
2400 return TRANSLATOR_IDENTIFIER;
2401 } else if (unsmob_score (sid)) {
2402 Score *sc = new Score (*unsmob_score (sid));
2403 *destination =sc->self_scm ();
2404 return SCORE_IDENTIFIER;
2405 } else if (Music * mus =unsmob_music (sid)) {
2406 *destination = unsmob_music (sid)->clone ()->self_scm();
2407 unsmob_music (*destination)->
2408 set_mus_property ("origin", make_input (last_input_));
2409 return dynamic_cast<Event*> (mus)
2410 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2411 } else if (unsmob_duration (sid)) {
2412 *destination = unsmob_duration (sid)->smobbed_copy();
2413 return DURATION_IDENTIFIER;
2414 } else if (unsmob_music_output_def (sid)) {
2415 Music_output_def *p = unsmob_music_output_def (sid);
2418 *destination = p->self_scm();
2419 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2420 } else if (Text_item::markup_p (sid)) {
2422 return MARKUP_IDENTIFIER;