1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
17 "bar" -> String -> Lyric -> Music -> music-assignment
19 "bar" -> String -> string-assignment
23 \repeat .. \alternative
26 \repeat { \repeat .. \alternative }
30 \repeat { \repeat } \alternative
42 * The rules for who is protecting what are very shady. Uniformise
45 * There are too many lexical modes?
53 #include "scm-option.hh"
54 #include "translator-def.hh"
55 #include "lily-guile.hh"
57 #include "my-lily-lexer.hh"
58 #include "paper-def.hh"
59 #include "midi-def.hh"
61 #include "file-path.hh"
63 #include "dimensions.hh"
64 #include "my-lily-parser.hh"
66 #include "input-file-results.hh"
68 #include "lilypond-input-version.hh"
69 #include "scm-hash.hh"
70 #include "auto-change-iterator.hh"
71 #include "ly-modules.hh"
72 #include "music-sequence.hh"
73 #include "input-smob.hh"
75 #include "text-item.hh"
76 #include "music-list.hh"
79 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
83 #define YYERROR_VERBOSE 1
85 My_lily_parser* my_lily_parser;
86 #define YYPARSE_PARAM my_lily_parser
87 #define YYLEX_PARAM my_lily_parser
89 ((My_lily_parser *) my_lily_parser)
91 #define yyerror THIS->parser_error
98 regular_identifier_b (SCM id)
100 String str = ly_scm2string (id);
101 char const *s = str.to_str0 () ;
106 v = v && isalpha (*s);
113 make_simple_markup (SCM a)
117 simple = scm_c_eval_string ("simple-markup");
119 return scm_list_n (simple, a, SCM_UNDEFINED);
124 is_duration_b (int t)
126 return t && t == 1 << intlog2 (t);
130 set_music_properties (Music *p, SCM a)
132 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
134 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
139 make_chord_step (int step, int alter)
144 /* ugh: fucks up above 13 */
145 Pitch m(step > 7 ? 1 : 0,(step - 1) % 7, alter);
146 return m.smobbed_copy ();
151 make_chord (SCM pitch, SCM dur, SCM modification_list)
153 static SCM chord_ctor;
155 chord_ctor= scm_c_eval_string ("construct-chord");
156 SCM ch= scm_call_3 (chord_ctor, pitch, dur, modification_list);
157 scm_gc_protect_object (ch);
162 Todo: actually also use apply iso. call too ...
165 ly_input_procedure_p (SCM x)
167 return gh_procedure_p (x)
168 || (gh_pair_p (x) && gh_procedure_p (gh_car (x)));
172 set_property_music (SCM sym, SCM value)
174 Music * p = MY_MAKE_MUSIC("PropertySet");
175 p->set_mus_property ("symbol", sym);
176 p->set_mus_property ("value", value);
182 /* We use SCMs to do strings, because it saves us the trouble of
183 deleting them. Let's hope that a stack overflow doesnt trigger a move
184 of the parse stack onto the heap. */
191 Music_output_def * outputdef;
198 yylex (YYSTYPE *s, void * v)
200 My_lily_parser *pars = (My_lily_parser*) v;
201 My_lily_lexer * lex = pars->lexer_;
203 lex->lexval = (void*) s;
204 lex->prepare_for_next_token();
205 return lex->yylex ();
213 /* tokens which are not keywords */
223 %token CHORDMODIFIERS
229 %token GROBDESCRIPTIONS
235 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
236 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
244 %token MULTI_MEASURE_REST
255 %token OVERRIDE SET REVERT
265 %token COMMANDSPANREQUEST
267 %token OUTPUTPROPERTY
282 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
283 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
285 %token <i> E_UNSIGNED
286 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
289 %type <i> exclamations questions dots optional_rest
291 %type <scm> bass_number br_bass_figure bass_figure figure_list figure_spec
293 %token <scm> NOTENAME_PITCH
294 %token <scm> TONICNAME_PITCH
295 %token <scm> CHORDMODIFIER_PITCH
296 %token <scm> DURATION_IDENTIFIER
297 %token <scm> FRACTION
298 %token <id> IDENTIFIER
299 %token <scm> CHORDNAMES
301 %token <scm> CHORD_MODIFIER
303 %token <scm> SCORE_IDENTIFIER
304 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
305 %token <scm> NUMBER_IDENTIFIER
306 %token <scm> EVENT_IDENTIFIER
307 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
308 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
309 %token <scm> RESTNAME
316 %token <scm> MARKUP_HEAD_MARKUP0
317 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
318 %token <scm> MARKUP_HEAD_SCM0
319 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
320 %token <scm> MARKUP_HEAD_SCM0_SCM1
321 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
322 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
324 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
325 %type <scm> markup markup_line markup_list markup_list_body full_markup
327 %type <outputdef> output_def
328 %type <scm> lilypond_header lilypond_header_body
329 %type <music> open_event close_event
330 %type <i> sub_quotes sup_quotes
331 %type <music> simple_element event_chord command_element Simple_music Composite_music
332 %type <music> Repeated_music
333 %type <scm> Alternative_music
334 %type <i> tremolo_type
335 %type <i> bare_int bare_unsigned
337 %type <scm> identifier_init
339 %type <music> note_chord_element chord_body chord_body_element
340 %type <scm> chord_body_elements
341 %type <scm> steno_duration optional_notemode_duration multiplied_duration
342 %type <scm> verbose_duration
344 %type <scm> post_events
345 %type <music> gen_text_def direction_less_event direction_reqd_event
346 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
347 %type <scm> explicit_pitch steno_tonic_pitch
348 %type <scm> duration_length fraction
350 %type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
352 %type <scm> embedded_scm scalar
353 %type <music> Music Sequential_music Simultaneous_music
354 %type <music> relative_music re_rhythmed_music part_combined_music
355 %type <music> property_def translator_change simple_property_def
356 %type <scm> Music_list
357 %type <outputdef> music_output_def_body
358 %type <music> shorthand_command_req
359 %type <music> post_event
360 %type <music> command_req verbose_command_req
361 %type <music> extender_req
362 %type <music> hyphen_req
363 %type <music> string_number_event
364 %type <scm> string bare_number number_expression number_term number_factor
365 %type <score> score_block score_body
367 %type <scm> translator_spec_block translator_spec_body
368 %type <music> tempo_event
369 %type <scm> notenames_body notenames_block chordmodifiers_block
370 %type <scm> script_abbreviation
376 /* We don't assign precedence to / and *, because we might need varied
377 prec levels in different prods */
383 lilypond: /* empty */
384 | lilypond toplevel_expression {}
385 | lilypond assignment { }
387 THIS->error_level_ = 1;
390 THIS->error_level_ = 1;
396 THIS->lexer_->pitchname_tab_ = $1;
398 | chordmodifiers_block {
399 THIS->lexer_->chordmodifier_tab_ = $1;
402 THIS->input_file_->header_ = $1;
405 THIS->input_file_->scores_.push ($1);
408 if (dynamic_cast<Paper_def*> ($1))
409 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
410 else if (dynamic_cast<Midi_def*> ($1))
411 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
421 chordmodifiers_block:
422 CHORDMODIFIERS notenames_body { $$ = $2; }
426 PITCHNAMES notenames_body { $$ = $2; }
431 int i = scm_ilength ($1);
433 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
434 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
435 SCM pt = ly_cdar (s);
436 scm_hashq_set_x (tab, ly_caar (s), pt);
442 lilypond_header_body:
444 $$ = ly_make_anonymous_module ();
445 THIS->lexer_->add_scope ($$);
447 | lilypond_header_body assignment {
453 HEADER '{' lilypond_header_body '}' {
454 $$ = THIS->lexer_-> remove_scope();
466 /* cont */ '=' identifier_init {
469 Should find generic way of associating input with objects.
471 Input ip = THIS->pop_spot ();
473 if (! regular_identifier_b ($1))
475 ip.warning (_ ("Identifier should have alphabetic characters only"));
478 THIS->lexer_->set_identifier ($1, $4);
481 TODO: devise standard for protection in parser.
483 The parser stack lives on the C-stack, which means that
484 all objects can be unprotected as soon as they're here.
495 $$ = $1->self_scm ();
496 scm_gc_unprotect_object ($$);
502 $$ = $1->self_scm ();
503 scm_gc_unprotect_object ($$);
505 | translator_spec_block {
509 $$ = $1->self_scm ();
510 scm_gc_unprotect_object ($$);
513 $$ = $1->self_scm ();
514 scm_gc_unprotect_object ($$);
519 | number_expression {
530 translator_spec_block:
531 TRANSLATOR '{' translator_spec_body '}'
537 translator_spec_body:
538 TRANSLATOR_IDENTIFIER {
540 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
543 $$ = Translator_def::make_scm ();
544 Translator_def*td = unsmob_translator_def ($$);
545 td->translator_group_type_ = $2;
546 td->set_spot (THIS->here_input ());
548 | translator_spec_body DESCRIPTION string {
549 unsmob_translator_def ($$)->description_ = $3;
551 | translator_spec_body STRING '=' embedded_scm {
552 unsmob_translator_def ($$)->add_property_assign ($2, $4);
554 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
555 unsmob_translator_def ($$)
556 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
558 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
559 unsmob_translator_def ($$)
560 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
562 | translator_spec_body STRING REVERT embedded_scm {
563 unsmob_translator_def ($$)->add_pop_property (
564 scm_string_to_symbol ($2), $4);
566 | translator_spec_body NAME STRING {
567 unsmob_translator_def ($$)->type_name_ = $3;
569 | translator_spec_body CONSISTS STRING {
570 unsmob_translator_def ($$)->add_element ($3);
572 | translator_spec_body ALIAS STRING {
573 Translator_def*td = unsmob_translator_def ($$);
574 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
576 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
577 Translator_def*td = unsmob_translator_def($$);
578 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
579 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
580 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
582 | translator_spec_body CONSISTSEND STRING {
583 unsmob_translator_def ($$)->add_last_element ( $3);
585 | translator_spec_body ACCEPTS STRING {
586 unsmob_translator_def ($$)->set_acceptor ($3,true);
588 | translator_spec_body DENIES STRING {
589 unsmob_translator_def ($$)->set_acceptor ($3,false);
591 | translator_spec_body REMOVE STRING {
592 unsmob_translator_def ($$)->remove_element ($3);
603 /*cont*/ '{' score_body '}' {
606 if (!$$->defs_.size ())
608 Music_output_def *id =
609 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
610 $$->add_output (id ? id->clone () : new Paper_def );
619 $$->set_spot (THIS->here_input ());
620 SCM m = $1->self_scm ();
621 scm_gc_unprotect_object (m);
626 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
627 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
628 m = gh_call1 (gh_car (check_funcs), m);
633 $$ = unsmob_score ($1);
634 $$->set_spot (THIS->here_input ());
636 | score_body lilypond_header {
639 | score_body output_def {
652 music_output_def_body '}' {
654 THIS-> lexer_-> remove_scope ();
658 music_output_def_body:
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_);
683 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
684 Music_output_def * o = unsmob_music_output_def ($3);
687 THIS->lexer_->add_scope (o->scope_);
689 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
690 Music_output_def * o = unsmob_music_output_def ($3);
693 THIS->lexer_->add_scope (o->scope_);
695 | music_output_def_body assignment {
698 | music_output_def_body translator_spec_block {
699 $$->assign_translator ($2);
701 | music_output_def_body tempo_event {
703 junk this ? there already is tempo stuff in
706 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
707 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
708 Midi_def * md = dynamic_cast<Midi_def*> ($$);
710 md->set_tempo (d->get_length (), m);
712 | music_output_def_body error {
718 TEMPO steno_duration '=' bare_unsigned {
719 $$ = MY_MAKE_MUSIC("MetronomeChangeEvent");
720 $$->set_mus_property ("tempo-unit", $2);
721 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
726 The representation of a list is the
730 to have efficient append.
734 $$ = scm_cons (SCM_EOL, SCM_EOL);
738 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
739 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
740 if (gh_pair_p (ly_cdr (s)))
741 gh_set_cdr_x (ly_cdr (s), c); /* append */
743 gh_set_car_x (s, c); /* set first cons */
744 gh_set_cdr_x (s, c) ; /* remember last cell */
760 | ALTERNATIVE '{' Music_list '}' {
766 REPEAT string bare_unsigned Music Alternative_music
770 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
771 if (times < scm_ilength (alts)) {
772 unsmob_music (gh_car (alts))
773 ->origin ()->warning (
774 _("More alternatives than repeats. Junking excess alternatives."));
775 alts = ly_truncate_list (times, alts);
781 proc = scm_c_eval_string ("make-repeated-music");
783 SCM mus = scm_call_1 (proc, $2);
784 scm_gc_protect_object (mus); // UGH.
785 Music *r =unsmob_music (mus);
788 r-> set_mus_property ("element", beg->self_scm ());
789 scm_gc_unprotect_object (beg->self_scm ());
791 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
793 r-> set_mus_property ("elements",alts);
794 if (gh_equal_p ($2, scm_makfrom0str ("tremolo"))) {
796 we can not get durations and other stuff correct down the line, so we have to
797 add to the duration log here.
802 func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
804 int dots = ($3 % 3) ? 0 : 1;
805 int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
807 Sequential_music * seq = dynamic_cast<Sequential_music*> ($4);
810 int list_len =scm_ilength (seq->music_list ());
812 seq->origin ()->warning ("Chord tremolo must have 2 elements.");
814 r->compress (Moment (Rational (1,list_len)));
816 gh_call3 (func, r->self_scm (), gh_int2scm(shift),gh_int2scm(dots));
819 r->set_spot (*$4->origin ());
826 SEQUENTIAL '{' Music_list '}' {
827 $$ = MY_MAKE_MUSIC("SequentialMusic");
828 $$->set_mus_property ("elements", ly_car ($3));
829 $$->set_spot(THIS->here_input());
831 | '{' Music_list '}' {
832 $$ = MY_MAKE_MUSIC("SequentialMusic");
833 $$->set_mus_property ("elements", ly_car ($2));
834 $$->set_spot(THIS->here_input());
839 SIMULTANEOUS '{' Music_list '}'{
840 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
841 $$->set_mus_property ("elements", ly_car ($3));
842 $$->set_spot(THIS->here_input());
845 | '<' Music_list '>' {
846 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
847 $$->set_mus_property ("elements", ly_car ($2));
848 $$->set_spot(THIS->here_input());
853 event_chord { $$ = $1; }
854 | APPLYOUTPUT embedded_scm {
855 if (!ly_input_procedure_p ($2))
856 THIS->parser_error (_ ("\\applycontext takes function argument"));
857 $$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
858 $$->set_mus_property ("procedure", $2);
859 $$->set_spot (THIS->here_input());
861 | APPLYCONTEXT embedded_scm {
862 if (!ly_input_procedure_p ($2))
863 THIS->parser_error (_ ("\\applycontext takes function argument"));
864 $$ = MY_MAKE_MUSIC ("ApplyContext");
865 $$->set_mus_property ("procedure", $2);
866 $$->set_spot (THIS->here_input());
868 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
870 if (!gh_symbol_p ($3))
872 THIS->parser_error (_ ("Second argument must be a symbol"));
874 /* Should check # args */
875 if (!gh_procedure_p (pred))
877 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
880 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
881 m->set_mus_property ("predicate", pred);
882 m->set_mus_property ("grob-property", $3);
883 m->set_mus_property ("grob-value", $5);
888 $$ = unsmob_music ($1);
896 CONTEXT STRING Music {
897 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
899 csm->set_mus_property ("element", $3->self_scm ());
900 scm_gc_unprotect_object ($3->self_scm ());
902 csm->set_mus_property ("context-type",$2);
903 csm->set_mus_property ("context-id", scm_makfrom0str (""));
907 | AUTOCHANGE STRING Music {
908 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
909 chm->set_mus_property ("element", $3->self_scm ());
910 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
912 scm_gc_unprotect_object ($3->self_scm ());
913 chm->set_mus_property ("what", $2);
916 chm->set_spot (*$3->origin ());
921 The other version is for easier debugging of
922 Sequential_music_iterator in combination with grace notes.
925 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
926 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
927 Music *startm = unsmob_music (start);
928 Music *stopm = unsmob_music (stop);
932 stopm = stopm->clone ();
933 ms = scm_cons (stopm->self_scm (), ms);
934 scm_gc_unprotect_object (stopm->self_scm ());
936 ms = scm_cons ($2->self_scm (), ms);
937 scm_gc_unprotect_object ($2->self_scm());
939 startm = startm->clone ();
940 ms = scm_cons (startm->self_scm () , ms);
941 scm_gc_unprotect_object (startm->self_scm ());
945 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
946 seq->set_mus_property ("elements", ms);
949 $$ = MY_MAKE_MUSIC("GraceMusic");
950 $$->set_mus_property ("element", seq->self_scm ());
951 scm_gc_unprotect_object (seq->self_scm ());
953 $$ = MY_MAKE_MUSIC("GraceMusic");
954 $$->set_mus_property ("element", $2->self_scm ());
955 scm_gc_unprotect_object ($2->self_scm ());
958 | CONTEXT string '=' string Music {
959 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
961 csm->set_mus_property ("element", $5->self_scm ());
962 scm_gc_unprotect_object ($5->self_scm ());
964 csm->set_mus_property ("context-type", $2);
965 csm->set_mus_property ("context-id", $4);
976 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
978 $$= MY_MAKE_MUSIC("TimeScaledMusic");
979 $$->set_spot (THIS->pop_spot ());
982 $$->set_mus_property ("element", mp->self_scm ());
983 scm_gc_unprotect_object (mp->self_scm ());
984 $$->set_mus_property ("numerator", gh_int2scm (n));
985 $$->set_mus_property ("denominator", gh_int2scm (d));
986 $$->compress (Moment (Rational (n,d)));
989 | Repeated_music { $$ = $1; }
990 | Simultaneous_music { $$ = $1; }
991 | Sequential_music { $$ = $1; }
992 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
993 $$ = MY_MAKE_MUSIC("TransposedMusic");
995 Pitch from = *unsmob_pitch ($2);
996 Pitch to = *unsmob_pitch ($3);
998 p->transpose (interval (from, to));
999 $$->set_mus_property ("element", p->self_scm ());
1000 scm_gc_unprotect_object (p->self_scm ());
1002 | APPLY embedded_scm Music {
1003 if (!ly_input_procedure_p ($2))
1004 THIS->parser_error (_ ("\\apply takes function argument"));
1006 SCM ret = gh_call1 ($2, $3->self_scm ());
1007 Music *m = unsmob_music (ret);
1009 THIS->parser_error ("\\apply must return a Music");
1010 m = MY_MAKE_MUSIC("Music");
1015 { THIS->lexer_->push_note_state (); }
1018 THIS->lexer_->pop_state ();
1021 { THIS->lexer_->push_figuredbass_state (); }
1024 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1025 chm->set_mus_property ("element", $3->self_scm ());
1027 scm_gc_unprotect_object ($3->self_scm());
1029 THIS->lexer_->pop_state ();
1032 { THIS->lexer_->push_chord_state (); }
1035 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1036 chm->set_mus_property ("element", $3->self_scm ());
1037 scm_gc_unprotect_object ($3->self_scm());
1040 THIS->lexer_->pop_state ();
1043 { THIS->lexer_->push_lyric_state (); }
1047 THIS->lexer_->pop_state ();
1049 | relative_music { $$ = $1; }
1050 | re_rhythmed_music { $$ = $1; }
1051 | part_combined_music { $$ = $1; }
1055 RELATIVE absolute_pitch Music {
1057 Pitch pit = *unsmob_pitch ($2);
1058 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1060 $$->set_mus_property ("element", p->self_scm ());
1061 scm_gc_unprotect_object (p->self_scm ());
1064 if (lily_1_8_relative)
1065 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1071 ADDLYRICS Music Music {
1072 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1073 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1074 scm_gc_unprotect_object ($3->self_scm ());
1075 scm_gc_unprotect_object ($2->self_scm ());
1080 part_combined_music:
1081 PARTCOMBINE STRING Music Music {
1082 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1083 p->set_mus_property ("what", $2);
1084 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1086 scm_gc_unprotect_object ($3->self_scm ());
1087 scm_gc_unprotect_object ($4->self_scm ());
1094 TRANSLATOR STRING '=' STRING {
1095 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1096 t-> set_mus_property ("change-to-type", $2);
1097 t-> set_mus_property ("change-to-id", $4);
1100 $$->set_spot (THIS->here_input ());
1106 | ONCE simple_property_def {
1108 SCM e = $2->get_mus_property ("element");
1109 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1113 simple_property_def:
1114 PROPERTY STRING '.' STRING '=' scalar {
1115 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1116 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1118 csm->set_mus_property ("element", t->self_scm ());
1119 scm_gc_unprotect_object (t->self_scm ());
1122 $$->set_spot (THIS->here_input ());
1124 csm-> set_mus_property ("context-type", $2);
1126 | PROPERTY STRING '.' STRING UNSET {
1128 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1129 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1131 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1132 csm->set_mus_property ("element", t->self_scm ());
1133 scm_gc_unprotect_object (t->self_scm ());
1136 $$->set_spot (THIS->here_input ());
1138 csm-> set_mus_property ("context-type", $2);
1140 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1142 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1143 bool itc = internal_type_checking_global_b;
1144 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1145 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1146 t->set_mus_property ("pop-first", SCM_BOOL_T);
1148 internal_type_checking_global_b = false;
1149 t->set_mus_property ("grob-property", $6);
1151 internal_type_checking_global_b = itc;
1152 t->set_mus_property ("grob-value", $8);
1154 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1155 csm->set_mus_property ("element", t->self_scm ());
1156 scm_gc_unprotect_object (t->self_scm ());
1158 $$->set_spot (THIS->here_input ());
1160 csm-> set_mus_property ("context-type", $2);
1162 | PROPERTY STRING '.' STRING OVERRIDE
1163 embedded_scm '=' embedded_scm
1169 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1170 bool itc = internal_type_checking_global_b;
1172 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1173 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1175 internal_type_checking_global_b = false;
1176 t->set_mus_property ("grob-property", $6);
1177 t->set_mus_property ("grob-value", $8);
1179 internal_type_checking_global_b = itc;
1181 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1182 csm->set_mus_property ("element", t->self_scm ());
1183 scm_gc_unprotect_object (t->self_scm ());
1186 $$->set_spot (THIS->here_input ());
1188 csm-> set_mus_property ("context-type", $2);
1191 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1192 Music *t = MY_MAKE_MUSIC("RevertProperty");
1194 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1195 bool itc = internal_type_checking_global_b;
1197 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1199 internal_type_checking_global_b = false;
1200 t->set_mus_property ("grob-property", $6);
1202 internal_type_checking_global_b = itc;
1204 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1205 csm->set_mus_property ("element", t->self_scm ());
1206 scm_gc_unprotect_object (t->self_scm ());
1209 $$->set_spot (THIS->here_input ());
1211 csm-> set_mus_property ("context-type", $2);
1218 | bare_int { $$ = gh_int2scm ($1); }
1219 | embedded_scm { $$ = $1; }
1220 | full_markup { $$ = $1; }
1221 | DIGIT { $$ = gh_int2scm ($1); }
1229 Adding pre_events to the simple_element
1230 makes the choice between
1236 simple_element: STRING
1238 a single shift/reduction conflict.
1240 nevertheless, this is not very clean, and we should find a different
1250 pre_events simple_element post_events {
1251 SCM elts = $2-> get_mus_property ("elements");
1253 elts = gh_append2 (elts, scm_reverse_x ($3, SCM_EOL));
1255 $2->set_mus_property ("elements", elts);
1259 | note_chord_element
1264 chord_body optional_notemode_duration post_events
1266 SCM dur = unsmob_duration ($2)->smobbed_copy();
1267 SCM es = $1->get_mus_property ("elements");
1268 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1270 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1271 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1272 es = gh_append2 (es, postevs);
1274 $1-> set_mus_property ("elements", es);
1280 CHORD_OPEN chord_body_elements CHORD_CLOSE
1282 $$ = MY_MAKE_MUSIC("EventChord");
1283 $$->set_mus_property ("elements",
1284 scm_reverse_x ($2, SCM_EOL));
1288 chord_body_elements:
1289 /* empty */ { $$ = SCM_EOL; }
1290 | chord_body_elements chord_body_element {
1291 $$ = gh_cons ($2->self_scm(), $1);
1292 scm_gc_unprotect_object ($2->self_scm());
1297 pitch exclamations questions post_events
1299 Music * n = MY_MAKE_MUSIC("NoteEvent");
1300 n->set_mus_property ("pitch", $1);
1302 n->set_mus_property ("cautionary", SCM_BOOL_T);
1303 if ($2 % 2 || $3 % 2)
1304 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1306 SCM arts = scm_reverse_x ($4, SCM_EOL);
1307 n->set_mus_property ("articulations", arts);
1315 $$ = MY_MAKE_MUSIC("EventChord");
1316 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1317 scm_gc_unprotect_object ($1->self_scm());
1319 $$-> set_spot (THIS->here_input ());
1320 $1-> set_spot (THIS->here_input ());
1322 | OCTAVE { THIS->push_spot (); }
1324 Music *l = MY_MAKE_MUSIC("RelativeOctaveCheck");
1326 $$->set_spot (THIS->pop_spot ());
1327 $$->set_mus_property ("pitch", $3);
1330 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1331 l->set_mus_property ("span-direction", gh_int2scm (START));
1332 l->set_spot (THIS->here_input ());
1334 $$ = MY_MAKE_MUSIC("EventChord");
1335 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1336 scm_gc_unprotect_object (l->self_scm());
1337 $$->set_spot (THIS->here_input ());
1340 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1341 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1342 l->set_spot (THIS->here_input ());
1344 $$ = MY_MAKE_MUSIC("EventChord");
1345 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1346 $$->set_spot (THIS->here_input ());
1347 scm_gc_unprotect_object (l->self_scm());
1350 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1351 $$->set_spot (THIS->here_input ());
1355 $$ = MY_MAKE_MUSIC("BarCheck");
1356 $$->set_spot (THIS->here_input ());
1359 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1361 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1362 csm->set_mus_property ("element", t->self_scm ());
1363 scm_gc_unprotect_object (t->self_scm ());
1366 $$->set_spot (THIS->here_input ());
1368 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1370 | PARTIAL duration_length {
1371 Moment m = - unsmob_duration ($2)->get_length ();
1372 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1374 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1375 sp->set_mus_property ("element", p->self_scm ());
1376 scm_gc_unprotect_object (p->self_scm ());
1379 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1384 proc = scm_c_eval_string ("make-clef-set");
1386 SCM result = scm_call_1 (proc, $2);
1387 scm_gc_protect_object (result);
1388 $$ = unsmob_music (result);
1393 proc = scm_c_eval_string ("make-time-signature-set");
1395 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1396 scm_gc_protect_object (result);
1397 $$ = unsmob_music (result);
1402 shorthand_command_req { $$ = $1; }
1403 | verbose_command_req { $$ = $1; }
1406 shorthand_command_req:
1414 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1417 $$ = MY_MAKE_MUSIC("PesOrFlexaEvent");
1421 verbose_command_req:
1423 Music * m = MY_MAKE_MUSIC("MarkEvent");
1427 Music *m = MY_MAKE_MUSIC("MarkEvent");
1428 m->set_mus_property ("label", $2);
1431 | SKIP duration_length {
1432 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1433 skip->set_mus_property ("duration", $2);
1441 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1444 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1446 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1447 if (scm_ilength ($3) > 0)
1449 key->set_mus_property ("pitch-alist", $3);
1450 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1451 ((Music*)key)->transpose (* unsmob_pitch ($2));
1453 THIS->parser_error (_("Second argument must be pitch list."));
1464 | post_events post_event {
1465 $2->set_spot (THIS->here_input ());
1466 $$ = gh_cons ($2->self_scm(), $$);
1467 scm_gc_unprotect_object ($2->self_scm());
1474 direction_less_event {
1477 | script_dir direction_reqd_event {
1478 $2->set_mus_property ("direction", gh_int2scm ($1));
1481 | script_dir direction_less_event {
1482 $2->set_mus_property ("direction", gh_int2scm ($1));
1485 | string_number_event
1488 string_number_event:
1490 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1491 s->set_mus_property ("string-number", gh_int2scm($1));
1492 s->set_spot (THIS->here_input ());
1498 direction_less_event:
1504 TODO: should take all these defs out of the parser, adn make use
1508 (set-articulation '~ "trill")
1511 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1512 m->set_spot (THIS->here_input());
1513 m->set_mus_property ("span-direction" , gh_int2scm (START));
1517 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1518 m->set_spot (THIS->here_input());
1519 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1523 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1524 m->set_spot (THIS->here_input());
1529 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START));
1533 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1535 | EVENT_IDENTIFIER {
1536 $$ = unsmob_music ($1);
1539 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1540 a->set_spot (THIS->here_input ());
1541 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1546 direction_reqd_event:
1550 | script_abbreviation {
1551 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1552 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1553 if (gh_string_p (s))
1554 a->set_mus_property ("articulation-type", s);
1555 else THIS->parser_error (_ ("Expecting string as script definition"));
1582 | NOTENAME_PITCH sup_quotes {
1583 Pitch p = *unsmob_pitch ($1);
1584 p = p.transposed (Pitch ($2,0,0));
1585 $$ = p.smobbed_copy ();
1587 | NOTENAME_PITCH sub_quotes {
1588 Pitch p =* unsmob_pitch ($1);
1589 p = p.transposed (Pitch (-$2,0,0));
1590 $$ = p.smobbed_copy ();
1602 | TONICNAME_PITCH sup_quotes {
1603 Pitch p = *unsmob_pitch ($1);
1604 p = p.transposed (Pitch ($2,0,0));
1605 $$ = p.smobbed_copy ();
1607 | TONICNAME_PITCH sub_quotes {
1608 Pitch p =* unsmob_pitch ($1);
1610 p = p.transposed (Pitch (-$2,0,0));
1611 $$ = p.smobbed_copy ();
1624 pitch_also_in_chords:
1630 PITCH embedded_scm {
1632 if (!unsmob_pitch ($2)) {
1633 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1634 $$ = Pitch ().smobbed_copy ();
1640 DURATION embedded_scm {
1642 if (!unsmob_duration ($2))
1644 THIS->parser_error (_ ("Must have duration object"));
1645 $$ = Duration ().smobbed_copy ();
1652 if (!THIS->lexer_->lyric_state_b ())
1653 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1654 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1660 if (!THIS->lexer_->lyric_state_b ())
1661 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1662 $$ = MY_MAKE_MUSIC("HyphenEvent");
1668 Music * s= MY_MAKE_MUSIC("SlurEvent");
1670 s->set_spot (THIS->here_input());
1673 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1675 s->set_spot (THIS->here_input());
1678 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1680 s->set_spot (THIS->here_input());
1683 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1685 s->set_spot (THIS->here_input());
1692 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1693 s->set_spot (THIS->here_input());
1698 Music * s= MY_MAKE_MUSIC("SlurEvent");
1700 s->set_spot (THIS->here_input());
1704 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1706 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1707 s->set_spot (THIS->here_input());
1713 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1714 t->set_mus_property ("text", $1);
1715 t->set_spot (THIS->here_input ());
1719 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1720 t->set_mus_property ("text", make_simple_markup ($1));
1721 t->set_spot (THIS->here_input ());
1726 Music * t = MY_MAKE_MUSIC("FingerEvent");
1727 t->set_mus_property ("digit", gh_int2scm ($1));
1728 t->set_spot (THIS->here_input ());
1733 script_abbreviation:
1735 $$ = scm_makfrom0str ("Hat");
1738 $$ = scm_makfrom0str ("Plus");
1741 $$ = scm_makfrom0str ("Dash");
1744 $$ = scm_makfrom0str ("Bar");
1747 $$ = scm_makfrom0str ("Larger");
1750 $$ = scm_makfrom0str ("Dot");
1753 $$ = scm_makfrom0str ("Underscore");
1760 | '-' { $$ = CENTER; }
1771 multiplied_duration {
1774 | verbose_duration {
1779 optional_notemode_duration:
1781 Duration dd = THIS->default_duration_;
1782 $$ = dd.smobbed_copy ();
1784 THIS->beam_check ($$);
1786 | multiplied_duration {
1788 THIS->default_duration_ = *unsmob_duration ($$);
1790 THIS->beam_check ($$);
1792 | verbose_duration {
1794 THIS->default_duration_ = *unsmob_duration ($$);
1799 bare_unsigned dots {
1801 if (!is_duration_b ($1))
1802 THIS->parser_error (_f ("not a duration: %d", $1));
1806 $$ = Duration (l, $2).smobbed_copy ();
1808 | DURATION_IDENTIFIER dots {
1809 Duration *d =unsmob_duration ($1);
1810 Duration k (d->duration_log (),d->dot_count () + $2);
1820 multiplied_duration:
1824 | multiplied_duration '*' bare_unsigned {
1825 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1827 | multiplied_duration '*' FRACTION {
1828 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1830 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1835 FRACTION { $$ = $1; }
1836 | UNSIGNED '/' UNSIGNED {
1837 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1855 | ':' bare_unsigned {
1856 if (!is_duration_b ($2))
1857 THIS->parser_error (_f ("not a duration: %d", $2));
1864 /*****************************************************************
1866 *****************************************************************/
1869 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1872 $$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
1874 | STRING { $$ = $1 }
1885 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1886 $$ = bfr->self_scm();
1887 scm_gc_unprotect_object ($$);
1890 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1891 $$ = bfr->self_scm();
1893 bfr->set_mus_property ("figure", $1);
1895 scm_gc_unprotect_object ($$);
1897 | bass_figure bass_mod {
1898 Music *m = unsmob_music ($1);
1900 SCM salter =m->get_mus_property ("alteration");
1901 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1902 m->set_mus_property ("alteration",
1903 gh_int2scm (alter + $2));
1905 m->set_mus_property ("alteration", gh_int2scm (0));
1913 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1918 | br_bass_figure ']' {
1920 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1928 | figure_list br_bass_figure {
1929 $$ = scm_cons ($2, $1);
1934 FIGURE_OPEN figure_list FIGURE_CLOSE {
1935 Music * m = MY_MAKE_MUSIC("EventChord");
1936 $2 = scm_reverse_x ($2, SCM_EOL);
1937 m->set_mus_property ("elements", $2);
1938 $$ = m->self_scm ();
1949 pitch exclamations questions optional_notemode_duration optional_rest {
1951 Input i = THIS->pop_spot ();
1952 if (!THIS->lexer_->note_state_b ())
1953 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1957 n = MY_MAKE_MUSIC("RestEvent");
1959 n = MY_MAKE_MUSIC("NoteEvent");
1961 n->set_mus_property ("pitch", $1);
1962 n->set_mus_property ("duration", $4);
1966 n->set_mus_property ("cautionary", SCM_BOOL_T);
1967 if ($2 % 2 || $3 % 2)
1968 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1970 Music *v = MY_MAKE_MUSIC("EventChord");
1971 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1972 scm_gc_unprotect_object (n->self_scm());
1978 | figure_spec optional_notemode_duration {
1979 Music * m = unsmob_music ($1);
1980 Input i = THIS->pop_spot ();
1982 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1984 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1988 | RESTNAME optional_notemode_duration {
1990 Input i = THIS->pop_spot ();
1992 if (ly_scm2string ($1) =="s") {
1994 ev = MY_MAKE_MUSIC("SkipEvent");
1997 ev = MY_MAKE_MUSIC("RestEvent");
2000 ev->set_mus_property ("duration" ,$2);
2002 Music * velt = MY_MAKE_MUSIC("EventChord");
2003 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
2008 | MULTI_MEASURE_REST optional_notemode_duration {
2013 proc = scm_c_eval_string ("make-multi-measure-rest");
2015 SCM mus = scm_call_2 (proc, $2,
2016 make_input (THIS->here_input()));
2017 scm_gc_protect_object (mus);
2018 $$ = unsmob_music (mus);
2020 | STRING optional_notemode_duration {
2021 Input i = THIS->pop_spot ();
2023 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
2024 lreq->set_mus_property ("text", $1);
2025 lreq->set_mus_property ("duration",$2);
2027 Music * velt = MY_MAKE_MUSIC("EventChord");
2028 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
2035 if (!THIS->lexer_->chord_state_b ())
2036 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2037 $$ = unsmob_music ($1);
2042 steno_tonic_pitch optional_notemode_duration {
2043 $$ = make_chord ($1, $2, SCM_EOL);
2045 | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2046 SCM its = scm_reverse_x ($4, SCM_EOL);
2047 $$ = make_chord ($1, $2, gh_cons ($3, its));
2055 | chord_items chord_item {
2056 $$ = gh_cons ($2, $$);
2062 $$ = ly_symbol2scm ("chord-colon");
2065 $$ = ly_symbol2scm ("chord-caret");
2067 | CHORD_SLASH steno_tonic_pitch {
2068 $$ = scm_list_n (ly_symbol2scm ("chord-slash"), $2, SCM_UNDEFINED);
2070 | CHORD_BASS steno_tonic_pitch {
2071 $$ = scm_list_n (ly_symbol2scm ("chord-bass"), $2, SCM_UNDEFINED);
2080 $$ = scm_reverse_x ($1, SCM_EOL);
2088 step_number { $$ = gh_cons ($1, SCM_EOL); }
2089 | step_numbers '.' step_number {
2090 $$ = gh_cons ($3, $$);
2096 $$ = make_chord_step ($1, 0);
2098 | bare_unsigned '+' {
2099 $$ = make_chord_step ($1, 1);
2101 | bare_unsigned CHORD_MINUS {
2102 $$ = make_chord_step ($1,-1);
2109 TODO: should deprecate in favor of Scheme?
2113 number_expression '+' number_term {
2114 $$ = scm_sum ($1, $3);
2116 | number_expression '-' number_term {
2117 $$ = scm_difference ($1, $3);
2126 | number_factor '*' number_factor {
2127 $$ = scm_product ($1, $3);
2129 | number_factor '/' number_factor {
2130 $$ = scm_divide ($1, $3);
2135 '-' number_factor { /* %prec UNARY_MINUS */
2136 $$ = scm_difference ($2, SCM_UNDEFINED);
2144 $$ = gh_int2scm ($1);
2149 | NUMBER_IDENTIFIER {
2152 | REAL NUMBER_IDENTIFIER {
2153 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2155 | UNSIGNED NUMBER_IDENTIFIER {
2156 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2172 if (scm_integer_p ($1) == SCM_BOOL_T)
2174 int k = gh_scm2int ($1);
2178 THIS->parser_error (_ ("need integer number arg"));
2192 | STRING_IDENTIFIER {
2195 | string '+' string {
2196 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2203 | exclamations '!' { $$ ++; }
2208 | questions '?' { $$ ++; }
2218 { THIS->lexer_->push_markup_state (); }
2221 THIS->lexer_->pop_state ();
2227 This should be done more dynamically if possible.
2231 $$ = make_simple_markup ($1);
2233 | MARKUP_HEAD_MARKUP0 markup {
2234 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2236 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2237 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2239 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2240 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2245 | MARKUP_HEAD_LIST0 markup_list {
2246 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2248 | MARKUP_HEAD_SCM0 embedded_scm {
2249 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2251 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2252 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2254 | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2255 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2257 | MARKUP_IDENTIFIER {
2264 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2268 '{' markup_list_body '}' {
2271 line = scm_c_eval_string ("line-markup");
2273 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2278 /**/ { $$ = SCM_EOL; }
2279 | markup_list_body markup {
2280 $$ = gh_cons ($2, $1) ;
2288 My_lily_parser::set_yydebug (bool )
2295 extern My_lily_parser * current_parser;
2298 My_lily_parser::do_yyparse ()
2300 current_parser = this;;
2301 yyparse ((void*)this);
2306 Should make this optional? It will also complain when you do
2310 which is entirely legitimate.
2312 Or we can scrap it. Barchecks should detect wrong durations, and
2313 skipTypesetting speeds it up a lot.
2317 My_lily_parser::beam_check (SCM dur)
2319 Duration *d = unsmob_duration (dur);
2320 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2322 Music * m = unsmob_music (last_beam_start_);
2323 m->origin ()->warning (_("Suspect duration found following this beam"));
2325 last_beam_start_ = SCM_EOL;
2333 It is a little strange to have this function in this file, but
2334 otherwise, we have to import music classes into the lexer.
2338 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2340 if (gh_string_p (sid)) {
2342 return STRING_IDENTIFIER;
2343 } else if (gh_number_p (sid)) {
2345 return NUMBER_IDENTIFIER;
2346 } else if (unsmob_translator_def (sid)) {
2347 *destination = unsmob_translator_def (sid)->clone_scm();
2348 return TRANSLATOR_IDENTIFIER;
2349 } else if (unsmob_score (sid)) {
2350 Score *sc = new Score (*unsmob_score (sid));
2351 *destination =sc->self_scm ();
2352 return SCORE_IDENTIFIER;
2353 } else if (Music * mus =unsmob_music (sid)) {
2354 *destination = unsmob_music (sid)->clone ()->self_scm();
2355 unsmob_music (*destination)->
2356 set_mus_property ("origin", make_input (last_input_));
2357 return dynamic_cast<Event*> (mus)
2358 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2359 } else if (unsmob_duration (sid)) {
2360 *destination = unsmob_duration (sid)->smobbed_copy();
2361 return DURATION_IDENTIFIER;
2362 } else if (unsmob_music_output_def (sid)) {
2363 Music_output_def *p = unsmob_music_output_def (sid);
2366 *destination = p->self_scm();
2367 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2368 } else if (Text_item::markup_p (sid)) {
2370 return MARKUP_IDENTIFIER;