1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2002 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.
52 #include "translator-def.hh"
53 #include "lily-guile.hh"
55 #include "my-lily-lexer.hh"
56 #include "paper-def.hh"
57 #include "midi-def.hh"
59 #include "file-path.hh"
61 #include "dimensions.hh"
62 #include "my-lily-parser.hh"
64 #include "input-file-results.hh"
66 #include "lilypond-input-version.hh"
67 #include "scm-hash.hh"
68 #include "auto-change-iterator.hh"
70 #include "ly-modules.hh"
71 #include "music-sequence.hh"
72 #include "input-smob.hh"
74 #include "text-item.hh"
77 regular_identifier_b (SCM id)
79 String str = ly_scm2string (id);
80 char const *s = str.to_str0 () ;
85 v = v && isalpha (*s);
92 make_simple_markup (SCM a)
96 simple = scm_c_eval_string ("simple-markup");
98 return scm_list_n (simple, a, SCM_UNDEFINED);
103 is_duration_b (int t)
105 return t && t == 1 << intlog2 (t);
109 set_music_properties (Music *p, SCM a)
111 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
113 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
119 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
122 set_property_music (SCM sym, SCM value)
124 Music * p = MY_MAKE_MUSIC("PropertySet");
125 p->set_mus_property ("symbol", sym);
126 p->set_mus_property ("value", value);
131 // needed for bison.simple's malloc () and free ()
133 // #include <malloc.h>
138 #define YYERROR_VERBOSE 1
140 My_lily_parser* my_lily_parser;
141 #define YYPARSE_PARAM my_lily_parser
142 #define YYLEX_PARAM my_lily_parser
144 ((My_lily_parser *) my_lily_parser)
146 #define yyerror THIS->parser_error
150 /* We use SCMs to do strings, because it saves us the trouble of
151 deleting them. Let's hope that a stack overflow doesnt trigger a move
152 of the parse stack onto the heap. */
159 Music_output_def * outputdef;
166 yylex (YYSTYPE *s, void * v)
168 My_lily_parser *pars = (My_lily_parser*) v;
169 My_lily_lexer * lex = pars->lexer_;
171 lex->lexval = (void*) s;
172 lex->prepare_for_next_token();
173 return lex->yylex ();
181 /* tokens which are not keywords */
190 %token CHORDMODIFIERS
196 %token GROBDESCRIPTIONS
201 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
202 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
210 %token MULTI_MEASURE_REST
221 %token OVERRIDE SET REVERT
231 %token COMMANDSPANREQUEST
233 %token OUTPUTPROPERTY
248 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
249 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
251 %token <i> E_UNSIGNED
252 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
255 %type <i> exclamations questions dots optional_rest
256 %type <i> bass_number bass_mod
257 %type <scm> br_bass_figure bass_figure figure_list figure_spec
259 %token <scm> NOTENAME_PITCH
260 %token <scm> TONICNAME_PITCH
261 %token <scm> CHORDMODIFIER_PITCH
262 %token <scm> DURATION_IDENTIFIER
263 %token <scm> FRACTION
264 %token <id> IDENTIFIER
265 %token <scm> CHORDNAMES CHORDNAMES_IDENTIFIER
266 %type <scm> chordnames_block chordnames_list chord_scm
269 %token <scm> SCORE_IDENTIFIER
270 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
271 %token <scm> NUMBER_IDENTIFIER
272 %token <scm> EVENT_IDENTIFIER
273 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
274 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
275 %token <scm> RESTNAME
282 %token <scm> MARKUP_HEAD_MARKUP0
283 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
284 %token <scm> MARKUP_HEAD_SCM0
285 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
286 %token <scm> MARKUP_HEAD_SCM0_SCM1
287 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
289 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
290 %type <scm> markup markup_line markup_list markup_list_body full_markup
292 %type <outputdef> output_def
293 %type <scm> lilypond_header lilypond_header_body
294 %type <music> open_event_parens close_event_parens open_event close_event
295 %type <music> event_with_dir event_that_take_dir verbose_event
296 %type <i> sub_quotes sup_quotes
297 %type <music> simple_element event_chord command_element Simple_music Composite_music
298 %type <music> Repeated_music
299 %type <scm> Alternative_music
300 %type <i> tremolo_type
301 %type <i> bare_int bare_unsigned
303 %type <scm> identifier_init
305 %type <music> note_chord_element chord_body chord_body_element
306 %type <scm> chord_body_elements
307 %type <scm> steno_duration optional_notemode_duration multiplied_duration
308 %type <scm> verbose_duration
310 %type <scm> pre_events post_events
311 %type <music> gen_text_def
312 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
313 %type <scm> explicit_pitch steno_tonic_pitch
315 %type <scm> chord_additions chord_subtractions chord_notes chord_step
317 %type <scm> chord_note chord_inversion chord_bass
318 %type <scm> duration_length fraction
320 %type <scm> embedded_scm scalar
321 %type <music> Music Sequential_music Simultaneous_music
322 %type <music> relative_music re_rhythmed_music part_combined_music
323 %type <music> property_def translator_change simple_property_def
324 %type <scm> Music_list
325 %type <outputdef> music_output_def_body
326 %type <music> shorthand_command_req
327 %type <music> post_event
328 %type <music> command_req verbose_command_req
329 %type <music> extender_req
330 %type <music> hyphen_req
331 %type <music> string_event
332 %type <scm> string bare_number number_expression number_term number_factor
333 %type <score> score_block score_body
335 %type <scm> translator_spec_block translator_spec_body
336 %type <music> tempo_event
337 %type <scm> notenames_body notenames_block chordmodifiers_block
338 %type <scm> script_abbreviation
344 /* We don't assign precedence to / and *, because we might need varied
345 prec levels in different prods */
351 lilypond: /* empty */
352 | lilypond toplevel_expression {}
353 | lilypond assignment { }
355 THIS->error_level_ = 1;
358 THIS->error_level_ = 1;
364 THIS->lexer_->pitchname_tab_ = $1;
366 | chordmodifiers_block {
367 THIS->lexer_->chordmodifier_tab_ = $1;
370 THIS->input_file_->header_ = $1;
373 THIS->input_file_->scores_.push ($1);
376 if (dynamic_cast<Paper_def*> ($1))
377 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
378 else if (dynamic_cast<Midi_def*> ($1))
379 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
389 chordmodifiers_block:
390 CHORDMODIFIERS notenames_body { $$ = $2; }
394 PITCHNAMES notenames_body { $$ = $2; }
399 int i = scm_ilength ($1);
401 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
402 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
403 SCM pt = ly_cdar (s);
404 if (!unsmob_pitch (pt))
405 THIS->parser_error ("Need pitch object.");
407 scm_hashq_set_x (tab, ly_caar (s), pt);
413 lilypond_header_body:
415 $$ = ly_make_anonymous_module ();
416 THIS->lexer_->add_scope ($$);
418 | lilypond_header_body assignment {
424 HEADER '{' lilypond_header_body '}' {
425 $$ = THIS->lexer_-> remove_scope();
437 /* cont */ '=' identifier_init {
440 Should find generic way of associating input with objects.
442 Input ip = THIS->pop_spot ();
444 if (! regular_identifier_b ($1))
446 ip.warning (_ ("Identifier should have alphabetic characters only"));
449 THIS->lexer_->set_identifier ($1, $4);
452 TODO: devise standard for protection in parser.
454 The parser stack lives on the C-stack, which means that
455 all objects can be unprotected as soon as they're here.
466 $$ = $1->self_scm ();
467 scm_gc_unprotect_object ($$);
473 $$ = $1->self_scm ();
474 scm_gc_unprotect_object ($$);
476 | translator_spec_block {
480 $$ = $1->self_scm ();
481 scm_gc_unprotect_object ($$);
484 $$ = $1->self_scm ();
485 scm_gc_unprotect_object ($$);
490 | number_expression {
506 { THIS->lexer_->push_chord_state (); }
508 { THIS->lexer_->pop_state (); }
519 | CHORDNAMES_IDENTIFIER chordnames_list {
520 $$ = scm_append (scm_list_2 ($1, $2));
522 | chord_scm '=' full_markup chordnames_list {
523 $$ = scm_cons (scm_cons ($1, $3), $4);
527 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
528 $$ = Chord::tonic_add_sub_to_pitches ($1, $3, $4);
529 /* junk bass and inversion for now */
532 translator_spec_block:
533 TRANSLATOR '{' translator_spec_body '}'
539 translator_spec_body:
540 TRANSLATOR_IDENTIFIER {
542 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
545 $$ = Translator_def::make_scm ();
546 Translator_def*td = unsmob_translator_def ($$);
547 td->translator_group_type_ = $2;
548 td->set_spot (THIS->here_input ());
550 | translator_spec_body STRING '=' embedded_scm {
551 unsmob_translator_def ($$)->add_property_assign ($2, $4);
553 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
554 unsmob_translator_def ($$)
555 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
557 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
558 unsmob_translator_def ($$)
559 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
561 | translator_spec_body STRING REVERT embedded_scm {
562 unsmob_translator_def ($$)->add_pop_property (
563 scm_string_to_symbol ($2), $4);
565 | translator_spec_body NAME STRING {
566 unsmob_translator_def ($$)->type_name_ = $3;
568 | translator_spec_body CONSISTS STRING {
569 unsmob_translator_def ($$)->add_element ($3);
571 | translator_spec_body ALIAS STRING {
572 Translator_def*td = unsmob_translator_def ($$);
573 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
575 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
576 Translator_def*td = unsmob_translator_def($$);
577 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
578 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
579 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
581 | translator_spec_body CONSISTSEND STRING {
582 unsmob_translator_def ($$)->add_last_element ( $3);
584 | translator_spec_body ACCEPTS STRING {
585 unsmob_translator_def ($$)->set_acceptor ($3,true);
587 | translator_spec_body DENIES STRING {
588 unsmob_translator_def ($$)->set_acceptor ($3,false);
590 | translator_spec_body REMOVE STRING {
591 unsmob_translator_def ($$)->remove_element ($3);
602 /*cont*/ '{' score_body '}' {
605 if (!$$->defs_.size ())
607 Music_output_def *id =
608 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
609 $$->add_output (id ? id->clone () : new Paper_def );
618 $$->set_spot (THIS->here_input ());
619 SCM m = $1->self_scm ();
620 scm_gc_unprotect_object (m);
625 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
626 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
627 m = gh_call1 (gh_car (check_funcs), m);
632 $$ = unsmob_score ($1);
633 $$->set_spot (THIS->here_input ());
635 | score_body lilypond_header {
638 | score_body output_def {
651 music_output_def_body '}' {
653 THIS-> lexer_-> remove_scope ();
657 music_output_def_body:
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_);
682 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
683 Music_output_def * o = unsmob_music_output_def ($3);
686 THIS->lexer_->add_scope (o->scope_);
688 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
689 Music_output_def * o = unsmob_music_output_def ($3);
692 THIS->lexer_->add_scope (o->scope_);
694 | music_output_def_body assignment {
697 | music_output_def_body translator_spec_block {
698 $$->assign_translator ($2);
700 | music_output_def_body tempo_event {
702 junk this ? there already is tempo stuff in
705 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
706 Duration *d = unsmob_duration ($2->get_mus_property ("tempo-unit"));
707 Midi_def * md = dynamic_cast<Midi_def*> ($$);
709 md->set_tempo (d->get_length (), m);
711 | music_output_def_body error {
717 TEMPO steno_duration '=' bare_unsigned {
718 $$ = MY_MAKE_MUSIC("TempoEvent");
719 $$->set_mus_property ("tempo-unit", $2);
720 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
725 The representation of a list is the
729 to have efficient append.
733 $$ = scm_cons (SCM_EOL, SCM_EOL);
737 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
738 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
739 if (gh_pair_p (ly_cdr (s)))
740 gh_set_cdr_x (ly_cdr (s), c); /* append */
742 gh_set_car_x (s, c); /* set first cons */
743 gh_set_cdr_x (s, c) ; /* remember last cell */
759 | ALTERNATIVE '{' Music_list '}' {
765 REPEAT string bare_unsigned Music Alternative_music
769 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
770 if (times < scm_ilength (alts)) {
771 unsmob_music (gh_car (alts))
772 ->origin ()->warning (
773 _("More alternatives than repeats. Junking excess alternatives."));
774 alts = ly_truncate_list (times, alts);
780 proc = scm_c_eval_string ("make-repeated-music");
782 SCM mus = scm_call_1 (proc, $2);
783 scm_gc_protect_object (mus); // UGH.
784 Music *r =unsmob_music (mus);
787 r-> set_mus_property ("element", beg->self_scm ());
788 scm_gc_unprotect_object (beg->self_scm ());
790 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
792 r-> set_mus_property ("elements",alts);
793 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.
799 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
801 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
803 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
805 r->set_spot (*$4->origin ());
812 SEQUENTIAL '{' Music_list '}' {
813 $$ = MY_MAKE_MUSIC("SequentialMusic");
814 $$->set_mus_property ("elements", ly_car ($3));
815 $$->set_spot(THIS->here_input());
817 | '{' Music_list '}' {
818 $$ = MY_MAKE_MUSIC("SequentialMusic");
819 $$->set_mus_property ("elements", ly_car ($2));
820 $$->set_spot(THIS->here_input());
825 SIMULTANEOUS '{' Music_list '}'{
826 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
827 $$->set_mus_property ("elements", ly_car ($3));
828 $$->set_spot(THIS->here_input());
831 | '<' Music_list '>' {
832 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
833 $$->set_mus_property ("elements", ly_car ($2));
834 $$->set_spot(THIS->here_input());
839 event_chord { $$ = $1; }
840 | APPLYCONTEXT embedded_scm {
841 if (!gh_procedure_p ($2))
842 THIS->parser_error (_ ("\applycontext takes function argument"));
843 $$ = MY_MAKE_MUSIC ("ApplyContext");
844 $$->set_mus_property ("procedure", $2);
845 $$->set_spot (THIS->here_input());
847 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
849 if (!gh_symbol_p ($3))
851 THIS->parser_error (_ ("Second argument must be a symbol"));
853 /* Should check # args */
854 if (!gh_procedure_p (pred))
856 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
859 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
860 m->set_mus_property ("predicate", pred);
861 m->set_mus_property ("grob-property", $3);
862 m->set_mus_property ("grob-value", $5);
867 $$ = unsmob_music ($1);
875 CONTEXT STRING Music {
876 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
878 csm->set_mus_property ("element", $3->self_scm ());
879 scm_gc_unprotect_object ($3->self_scm ());
881 csm->set_mus_property ("context-type",$2);
882 csm->set_mus_property ("context-id", scm_makfrom0str (""));
886 | AUTOCHANGE STRING Music {
887 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
888 chm->set_mus_property ("element", $3->self_scm ());
889 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
891 scm_gc_unprotect_object ($3->self_scm ());
892 chm->set_mus_property ("what", $2);
895 chm->set_spot (*$3->origin ());
900 The other version is for easier debugging of
901 Sequential_music_iterator in combination with grace notes.
904 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
905 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
906 Music *startm = unsmob_music (start);
907 Music *stopm = unsmob_music (stop);
911 stopm = stopm->clone ();
912 ms = scm_cons (stopm->self_scm (), ms);
913 scm_gc_unprotect_object (stopm->self_scm ());
915 ms = scm_cons ($2->self_scm (), ms);
916 scm_gc_unprotect_object ($2->self_scm());
918 startm = startm->clone ();
919 ms = scm_cons (startm->self_scm () , ms);
920 scm_gc_unprotect_object (startm->self_scm ());
924 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
925 seq->set_mus_property ("elements", ms);
928 $$ = MY_MAKE_MUSIC("GraceMusic");
929 $$->set_mus_property ("element", seq->self_scm ());
930 scm_gc_unprotect_object (seq->self_scm ());
932 $$ = MY_MAKE_MUSIC("GraceMusic");
933 $$->set_mus_property ("element", $2->self_scm ());
934 scm_gc_unprotect_object ($2->self_scm ());
937 | CONTEXT string '=' string Music {
938 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
940 csm->set_mus_property ("element", $5->self_scm ());
941 scm_gc_unprotect_object ($5->self_scm ());
943 csm->set_mus_property ("context-type", $2);
944 csm->set_mus_property ("context-id", $4);
955 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
957 $$= MY_MAKE_MUSIC("TimeScaledMusic");
958 $$->set_spot (THIS->pop_spot ());
961 $$->set_mus_property ("element", mp->self_scm ());
962 scm_gc_unprotect_object (mp->self_scm ());
963 $$->set_mus_property ("numerator", gh_int2scm (n));
964 $$->set_mus_property ("denominator", gh_int2scm (d));
965 $$->compress (Moment (Rational (n,d)));
968 | Repeated_music { $$ = $1; }
969 | Simultaneous_music { $$ = $1; }
970 | Sequential_music { $$ = $1; }
971 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
972 $$ = MY_MAKE_MUSIC("TransposedMusic");
974 Pitch from = *unsmob_pitch ($2);
975 Pitch to = *unsmob_pitch ($3);
977 p->transpose (interval (from, to));
978 $$->set_mus_property ("element", p->self_scm ());
979 scm_gc_unprotect_object (p->self_scm ());
981 | APPLY embedded_scm Music {
982 SCM ret = gh_call1 ($2, $3->self_scm ());
983 Music *m = unsmob_music (ret);
985 THIS->parser_error ("\\apply must return a Music");
986 m = MY_MAKE_MUSIC("Music");
991 { THIS->lexer_->push_note_state (); }
994 THIS->lexer_->pop_state ();
997 { THIS->lexer_->push_figuredbass_state (); }
1000 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1001 chm->set_mus_property ("element", $3->self_scm ());
1003 scm_gc_unprotect_object ($3->self_scm());
1005 THIS->lexer_->pop_state ();
1008 { THIS->lexer_->push_chord_state (); }
1011 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1012 chm->set_mus_property ("element", $3->self_scm ());
1013 scm_gc_unprotect_object ($3->self_scm());
1016 THIS->lexer_->pop_state ();
1019 { THIS->lexer_->push_lyric_state (); }
1023 THIS->lexer_->pop_state ();
1025 | relative_music { $$ = $1; }
1026 | re_rhythmed_music { $$ = $1; }
1027 | part_combined_music { $$ = $1; }
1031 RELATIVE absolute_pitch Music {
1033 Pitch pit = *unsmob_pitch ($2);
1034 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1036 $$->set_mus_property ("element", p->self_scm ());
1037 scm_gc_unprotect_object (p->self_scm ());
1039 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1045 ADDLYRICS Music Music {
1046 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1047 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1048 scm_gc_unprotect_object ($3->self_scm ());
1049 scm_gc_unprotect_object ($2->self_scm ());
1054 part_combined_music:
1055 PARTCOMBINE STRING Music Music {
1056 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1057 p->set_mus_property ("what", $2);
1058 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1060 scm_gc_unprotect_object ($3->self_scm ());
1061 scm_gc_unprotect_object ($4->self_scm ());
1068 TRANSLATOR STRING '=' STRING {
1069 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1070 t-> set_mus_property ("change-to-type", $2);
1071 t-> set_mus_property ("change-to-id", $4);
1074 $$->set_spot (THIS->here_input ());
1080 | ONCE simple_property_def {
1082 SCM e = $2->get_mus_property ("element");
1083 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1087 simple_property_def:
1088 PROPERTY STRING '.' STRING '=' scalar {
1089 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1090 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1092 csm->set_mus_property ("element", t->self_scm ());
1093 scm_gc_unprotect_object (t->self_scm ());
1096 $$->set_spot (THIS->here_input ());
1098 csm-> set_mus_property ("context-type", $2);
1100 | PROPERTY STRING '.' STRING UNSET {
1102 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1103 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1105 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1106 csm->set_mus_property ("element", t->self_scm ());
1107 scm_gc_unprotect_object (t->self_scm ());
1110 $$->set_spot (THIS->here_input ());
1112 csm-> set_mus_property ("context-type", $2);
1114 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1116 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1117 bool itc = internal_type_checking_global_b;
1118 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1119 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1120 t->set_mus_property ("pop-first", SCM_BOOL_T);
1122 internal_type_checking_global_b = false;
1123 t->set_mus_property ("grob-property", $6);
1125 internal_type_checking_global_b = itc;
1126 t->set_mus_property ("grob-value", $8);
1128 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1129 csm->set_mus_property ("element", t->self_scm ());
1130 scm_gc_unprotect_object (t->self_scm ());
1132 $$->set_spot (THIS->here_input ());
1134 csm-> set_mus_property ("context-type", $2);
1136 | PROPERTY STRING '.' STRING OVERRIDE
1137 embedded_scm '=' embedded_scm
1143 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1144 bool itc = internal_type_checking_global_b;
1146 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1147 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1149 internal_type_checking_global_b = false;
1150 t->set_mus_property ("grob-property", $6);
1151 t->set_mus_property ("grob-value", $8);
1153 internal_type_checking_global_b = itc;
1155 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1156 csm->set_mus_property ("element", t->self_scm ());
1157 scm_gc_unprotect_object (t->self_scm ());
1160 $$->set_spot (THIS->here_input ());
1162 csm-> set_mus_property ("context-type", $2);
1165 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1166 Music *t = MY_MAKE_MUSIC("RevertProperty");
1168 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1169 bool itc = internal_type_checking_global_b;
1171 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1173 internal_type_checking_global_b = false;
1174 t->set_mus_property ("grob-property", $6);
1176 internal_type_checking_global_b = itc;
1178 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1179 csm->set_mus_property ("element", t->self_scm ());
1180 scm_gc_unprotect_object (t->self_scm ());
1183 $$->set_spot (THIS->here_input ());
1185 csm-> set_mus_property ("context-type", $2);
1192 | bare_int { $$ = gh_int2scm ($1); }
1193 | embedded_scm { $$ = $1; }
1194 | full_markup { $$ = $1; }
1201 } /*cont */ simple_element post_events {
1202 SCM elts = $3-> get_mus_property ("elements");
1204 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1205 scm_reverse_x ($4, SCM_EOL));
1207 $3-> set_mus_property ("elements", elts);
1211 | note_chord_element
1216 chord_body optional_notemode_duration post_events
1218 SCM dur = unsmob_duration ($2)->smobbed_copy();
1219 SCM es = $1->get_mus_property ("elements");
1220 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1222 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1223 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1224 es = gh_append2 (es, postevs);
1226 $1-> set_mus_property ("elements", es);
1232 CHORD_OPEN chord_body_elements CHORD_CLOSE
1234 $$ = MY_MAKE_MUSIC("EventChord");
1235 $$->set_mus_property ("elements",
1236 scm_reverse_x ($2, SCM_EOL));
1240 chord_body_elements:
1241 /* empty */ { $$ = SCM_EOL; }
1242 | chord_body_elements chord_body_element {
1243 $$ = gh_cons ($2->self_scm(), $1);
1244 scm_gc_unprotect_object ($2->self_scm());
1249 pitch exclamations questions post_events
1251 Music * n = MY_MAKE_MUSIC("NoteEvent");
1252 n->set_mus_property ("pitch", $1);
1254 n->set_mus_property ("cautionary", SCM_BOOL_T);
1255 if ($2 % 2 || $3 % 2)
1256 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1258 SCM arts = scm_reverse_x ($4, SCM_EOL);
1259 n->set_mus_property ("articulations", arts);
1267 $$ = MY_MAKE_MUSIC("EventChord");
1268 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1269 scm_gc_unprotect_object ($1->self_scm());
1271 $$-> set_spot (THIS->here_input ());
1272 $1-> set_spot (THIS->here_input ());
1275 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1276 l->set_mus_property ("span-direction", gh_int2scm (START));
1277 l->set_spot (THIS->here_input ());
1279 $$ = MY_MAKE_MUSIC("EventChord");
1280 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1281 scm_gc_unprotect_object (l->self_scm());
1282 $$->set_spot (THIS->here_input ());
1285 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1286 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1287 l->set_spot (THIS->here_input ());
1289 $$ = MY_MAKE_MUSIC("EventChord");
1290 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1291 $$->set_spot (THIS->here_input ());
1292 scm_gc_unprotect_object (l->self_scm());
1295 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1296 $$->set_spot (THIS->here_input ());
1300 $$ = MY_MAKE_MUSIC("BarCheck");
1301 $$->set_spot (THIS->here_input ());
1304 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1306 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1307 csm->set_mus_property ("element", t->self_scm ());
1308 scm_gc_unprotect_object (t->self_scm ());
1311 $$->set_spot (THIS->here_input ());
1313 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1315 | PARTIAL duration_length {
1316 Moment m = - unsmob_duration ($2)->get_length ();
1317 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1319 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1320 sp->set_mus_property ("element", p->self_scm ());
1321 scm_gc_unprotect_object (p->self_scm ());
1324 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1329 proc = scm_c_eval_string ("make-clef-set");
1331 SCM result = scm_call_1 (proc, $2);
1332 scm_gc_protect_object (result);
1333 $$ = unsmob_music (result);
1338 proc = scm_c_eval_string ("make-time-signature-set");
1340 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1341 scm_gc_protect_object (result);
1342 $$ = unsmob_music (result);
1347 shorthand_command_req { $$ = $1; }
1348 | verbose_command_req { $$ = $1; }
1351 shorthand_command_req:
1359 $$ = MY_MAKE_MUSIC("TieEvent");
1362 Music *b= MY_MAKE_MUSIC("BeamEvent");
1363 b->set_mus_property ("span-direction", gh_int2scm (START));
1366 THIS->last_beam_start_ = b->self_scm ();
1369 Music *b= MY_MAKE_MUSIC("BeamEvent");
1370 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1374 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1377 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1381 verbose_command_req:
1383 Music * m = MY_MAKE_MUSIC("MarkEvent");
1387 Music *m = MY_MAKE_MUSIC("MarkEvent");
1388 m->set_mus_property ("label", $2);
1391 | SKIP duration_length {
1392 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1393 skip->set_mus_property ("duration", $2);
1401 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1404 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1405 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1407 key->set_mus_property ("pitch-alist", $3);
1408 ((Music*)key)->transpose (* unsmob_pitch ($2));
1417 | post_events post_event {
1418 $2->set_spot (THIS->here_input ());
1419 $$ = gh_cons ($2->self_scm(), $$);
1420 scm_gc_unprotect_object ($2->self_scm());
1433 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1434 s->set_mus_property ("string-number", gh_int2scm($1));
1435 s->set_spot (THIS->here_input ());
1441 event_that_take_dir:
1447 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1448 m->set_spot (THIS->here_input());
1449 m->set_mus_property ("span-direction" , gh_int2scm (START));
1453 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1454 m->set_spot (THIS->here_input());
1455 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1459 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1460 m->set_spot (THIS->here_input());
1463 | script_abbreviation {
1464 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1465 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1466 if (gh_string_p (s))
1467 a->set_mus_property ("articulation-type", s);
1468 else THIS->parser_error (_ ("Expecting string as script definition"));
1474 script_dir event_that_take_dir {
1475 $2->set_mus_property ("direction", gh_int2scm ($1));
1482 $$ = unsmob_music ($1);
1485 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1486 a->set_spot (THIS->here_input ());
1487 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1514 | NOTENAME_PITCH sup_quotes {
1515 Pitch p = *unsmob_pitch ($1);
1517 $$ = p.smobbed_copy ();
1519 | NOTENAME_PITCH sub_quotes {
1520 Pitch p =* unsmob_pitch ($1);
1523 $$ = p.smobbed_copy ();
1536 | TONICNAME_PITCH sup_quotes {
1537 Pitch p = *unsmob_pitch ($1);
1539 $$ = p.smobbed_copy ();
1541 | TONICNAME_PITCH sub_quotes {
1542 Pitch p =* unsmob_pitch ($1);
1545 $$ = p.smobbed_copy ();
1559 pitch_also_in_chords:
1565 PITCH embedded_scm {
1567 if (!unsmob_pitch ($2)) {
1568 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1569 $$ = Pitch ().smobbed_copy ();
1575 DURATION embedded_scm {
1577 if (!unsmob_duration ($2))
1579 THIS->parser_error (_ ("Must have duration object"));
1580 $$ = Duration ().smobbed_copy ();
1587 if (!THIS->lexer_->lyric_state_b ())
1588 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1589 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1595 if (!THIS->lexer_->lyric_state_b ())
1596 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1597 $$ = MY_MAKE_MUSIC("HyphenEvent");
1602 close_event_parens {
1604 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1611 Music * s= MY_MAKE_MUSIC("SlurEvent");
1613 s->set_spot (THIS->here_input());
1616 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1618 s->set_spot (THIS->here_input());
1621 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1623 s->set_spot (THIS->here_input());
1626 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1628 s->set_spot (THIS->here_input());
1636 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1643 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1644 s->set_spot (THIS->here_input());
1649 Music * s= MY_MAKE_MUSIC("SlurEvent");
1651 s->set_spot (THIS->here_input());
1655 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1657 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1658 s->set_spot (THIS->here_input());
1664 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1665 t->set_mus_property ("text", $1);
1666 t->set_spot (THIS->here_input ());
1670 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1671 t->set_mus_property ("text", $1);
1672 t->set_spot (THIS->here_input ());
1676 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1677 t->set_mus_property ("text", make_simple_markup ($1));
1678 t->set_spot (THIS->here_input ());
1683 Music * t = MY_MAKE_MUSIC("FingerEvent");
1684 t->set_mus_property ("digit", gh_int2scm ($1));
1685 t->set_spot (THIS->here_input ());
1690 script_abbreviation:
1692 $$ = scm_makfrom0str ("Hat");
1695 $$ = scm_makfrom0str ("Plus");
1698 $$ = scm_makfrom0str ("Dash");
1701 $$ = scm_makfrom0str ("Bar");
1704 $$ = scm_makfrom0str ("Larger");
1707 $$ = scm_makfrom0str ("Dot");
1710 $$ = scm_makfrom0str ("Underscore");
1717 | '-' { $$ = CENTER; }
1724 | pre_events open_event {
1725 $$ = gh_cons ($2->self_scm(), $$);
1726 scm_gc_unprotect_object ($2->self_scm());
1737 multiplied_duration {
1740 | verbose_duration {
1745 optional_notemode_duration:
1747 Duration dd = THIS->default_duration_;
1748 $$ = dd.smobbed_copy ();
1750 THIS->beam_check ($$);
1752 | multiplied_duration {
1754 THIS->default_duration_ = *unsmob_duration ($$);
1756 THIS->beam_check ($$);
1758 | verbose_duration {
1760 THIS->default_duration_ = *unsmob_duration ($$);
1765 bare_unsigned dots {
1767 if (!is_duration_b ($1))
1768 THIS->parser_error (_f ("not a duration: %d", $1));
1772 $$ = Duration (l, $2).smobbed_copy ();
1774 | DURATION_IDENTIFIER dots {
1775 Duration *d =unsmob_duration ($1);
1776 Duration k (d->duration_log (),d->dot_count () + $2);
1786 multiplied_duration:
1790 | multiplied_duration '*' bare_unsigned {
1791 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1793 | multiplied_duration '*' FRACTION {
1794 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1796 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1801 FRACTION { $$ = $1; }
1802 | UNSIGNED '/' UNSIGNED {
1803 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1821 | ':' bare_unsigned {
1822 if (!is_duration_b ($2))
1823 THIS->parser_error (_f ("not a duration: %d", $2));
1830 /*****************************************************************
1832 *****************************************************************/
1846 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1847 $$ = bfr->self_scm();
1848 scm_gc_unprotect_object ($$);
1851 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1852 $$ = bfr->self_scm();
1854 bfr->set_mus_property ("figure", gh_int2scm ($1));
1856 scm_gc_unprotect_object ($$);
1858 | bass_figure bass_mod {
1859 Music *m = unsmob_music ($1);
1861 SCM salter =m->get_mus_property ("alteration");
1862 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1863 m->set_mus_property ("alteration",
1864 gh_int2scm (alter + $2));
1866 m->set_mus_property ("alteration", gh_int2scm (0));
1874 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1879 | br_bass_figure ']' {
1881 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1889 | figure_list br_bass_figure {
1890 $$ = scm_cons ($2, $1);
1895 FIGURE_OPEN figure_list FIGURE_CLOSE {
1896 Music * m = MY_MAKE_MUSIC("EventChord");
1897 $2 = scm_reverse_x ($2, SCM_EOL);
1898 m->set_mus_property ("elements", $2);
1899 $$ = m->self_scm ();
1910 pitch exclamations questions optional_notemode_duration optional_rest {
1912 Input i = THIS->pop_spot ();
1913 if (!THIS->lexer_->note_state_b ())
1914 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1918 n = MY_MAKE_MUSIC("RestEvent");
1920 n = MY_MAKE_MUSIC("NoteEvent");
1922 n->set_mus_property ("pitch", $1);
1923 n->set_mus_property ("duration", $4);
1927 n->set_mus_property ("cautionary", SCM_BOOL_T);
1928 if ($2 % 2 || $3 % 2)
1929 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1931 Music *v = MY_MAKE_MUSIC("EventChord");
1932 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1933 scm_gc_unprotect_object (n->self_scm());
1939 | figure_spec optional_notemode_duration {
1940 Music * m = unsmob_music ($1);
1941 Input i = THIS->pop_spot ();
1943 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1945 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1949 | RESTNAME optional_notemode_duration {
1951 Input i = THIS->pop_spot ();
1953 if (ly_scm2string ($1) =="s") {
1955 ev = MY_MAKE_MUSIC("SkipEvent");
1958 ev = MY_MAKE_MUSIC("RestEvent");
1961 ev->set_mus_property ("duration" ,$2);
1963 Music * velt = MY_MAKE_MUSIC("EventChord");
1964 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1969 | MULTI_MEASURE_REST optional_notemode_duration {
1974 proc = scm_c_eval_string ("make-multi-measure-rest");
1976 SCM mus = scm_call_2 (proc, $2,
1977 make_input (THIS->here_input()));
1978 scm_gc_protect_object (mus);
1979 $$ = unsmob_music (mus);
1981 | STRING optional_notemode_duration {
1982 Input i = THIS->pop_spot ();
1984 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1985 lreq->set_mus_property ("text", $1);
1986 lreq->set_mus_property ("duration",$2);
1988 Music * velt = MY_MAKE_MUSIC("EventChord");
1989 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1996 if (!THIS->lexer_->chord_state_b ())
1997 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2004 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
2005 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
2006 $$->set_spot (THIS->here_input ());
2013 | CHORD_COLON chord_notes {
2022 | chord_notes '.' chord_step {
2023 $$ = gh_append2 ($$, $3);
2031 | CHORD_CARET chord_notes {
2041 | CHORD_SLASH steno_tonic_pitch {
2050 | CHORD_BASS steno_tonic_pitch {
2057 $$ = scm_cons ($1, SCM_EOL);
2059 | CHORDMODIFIER_PITCH {
2060 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2062 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2063 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2071 m.notename_ = ($1 - 1) % 7;
2072 m.octave_ = $1 > 7 ? 1 : 0;
2075 $$ = m.smobbed_copy ();
2077 | bare_unsigned '+' {
2079 m.notename_ = ($1 - 1) % 7;
2080 m.octave_ = $1 > 7 ? 1 : 0;
2084 $$ = m.smobbed_copy ();
2086 | bare_unsigned CHORD_MINUS {
2088 m.notename_ = ($1 - 1) % 7;
2089 m.octave_ = $1 > 7 ? 1 : 0;
2092 $$ = m.smobbed_copy ();
2100 number_expression '+' number_term {
2101 $$ = scm_sum ($1, $3);
2103 | number_expression '-' number_term {
2104 $$ = scm_difference ($1, $3);
2113 | number_factor '*' number_factor {
2114 $$ = scm_product ($1, $3);
2116 | number_factor '/' number_factor {
2117 $$ = scm_divide ($1, $3);
2122 '-' number_factor { /* %prec UNARY_MINUS */
2123 $$ = scm_difference ($2, SCM_UNDEFINED);
2131 $$ = gh_int2scm ($1);
2136 | NUMBER_IDENTIFIER {
2139 | REAL NUMBER_IDENTIFIER {
2140 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2142 | UNSIGNED NUMBER_IDENTIFIER {
2143 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2159 if (scm_integer_p ($1) == SCM_BOOL_T)
2161 int k = gh_scm2int ($1);
2165 THIS->parser_error (_ ("need integer number arg"));
2179 | STRING_IDENTIFIER {
2182 | string '+' string {
2183 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2190 | exclamations '!' { $$ ++; }
2195 | questions '?' { $$ ++; }
2205 { THIS->lexer_->push_markup_state (); }
2208 THIS->lexer_->pop_state ();
2214 $$ = make_simple_markup ($1);
2216 | MARKUP_HEAD_MARKUP0 markup {
2217 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2219 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2220 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2222 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2223 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2228 | MARKUP_HEAD_LIST0 markup_list {
2229 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2231 | MARKUP_HEAD_SCM0 embedded_scm {
2232 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2234 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2235 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2237 | MARKUP_IDENTIFIER {
2244 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2248 '{' markup_list_body '}' {
2251 line = scm_c_eval_string ("line-markup");
2253 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2258 /**/ { $$ = SCM_EOL; }
2259 | markup_list_body markup {
2260 $$ = gh_cons ($2, $1) ;
2268 My_lily_parser::set_yydebug (bool )
2275 extern My_lily_parser * current_parser;
2278 My_lily_parser::do_yyparse ()
2280 current_parser = this;;
2281 yyparse ((void*)this);
2286 Should make this optional? It will also complain when you do
2290 which is entirely legitimate.
2292 Or we can scrap it. Barchecks should detect wrong durations, and
2293 skipTypesetting speeds it up a lot.
2297 My_lily_parser::beam_check (SCM dur)
2299 Duration *d = unsmob_duration (dur);
2300 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2302 Music * m = unsmob_music (last_beam_start_);
2303 m->origin ()->warning (_("Suspect duration found following this beam"));
2305 last_beam_start_ = SCM_EOL;
2313 return gh_pair_p (x)
2314 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2317 It is a little strange, to have this function in this file, but
2318 otherwise, we have to import music classes into the lexer.
2322 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2324 if (gh_string_p (sid)) {
2326 return STRING_IDENTIFIER;
2327 } else if (gh_number_p (sid)) {
2329 return NUMBER_IDENTIFIER;
2330 } else if (unsmob_translator_def (sid)) {
2331 *destination = unsmob_translator_def (sid)->clone_scm();
2332 return TRANSLATOR_IDENTIFIER;
2333 } else if (unsmob_score (sid)) {
2334 Score *sc = new Score (*unsmob_score (sid));
2335 *destination =sc->self_scm ();
2336 return SCORE_IDENTIFIER;
2337 } else if (Music * mus =unsmob_music (sid)) {
2338 *destination = unsmob_music (sid)->clone ()->self_scm();
2339 unsmob_music (*destination)->
2340 set_mus_property ("origin", make_input (last_input_));
2341 return dynamic_cast<Event*> (mus)
2342 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2343 } else if (unsmob_duration (sid)) {
2344 *destination = unsmob_duration (sid)->smobbed_copy();
2345 return DURATION_IDENTIFIER;
2346 } else if (unsmob_music_output_def (sid)) {
2347 Music_output_def *p = unsmob_music_output_def (sid);
2350 *destination = p->self_scm();
2351 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2352 } else if (new_markup_p (sid)) {
2354 return MARKUP_IDENTIFIER;