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 "translator-def.hh"
54 #include "lily-guile.hh"
56 #include "my-lily-lexer.hh"
57 #include "paper-def.hh"
58 #include "midi-def.hh"
60 #include "file-path.hh"
62 #include "dimensions.hh"
63 #include "my-lily-parser.hh"
65 #include "input-file-results.hh"
67 #include "lilypond-input-version.hh"
68 #include "scm-hash.hh"
69 #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"
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));
141 set_property_music (SCM sym, SCM value)
143 Music * p = MY_MAKE_MUSIC("PropertySet");
144 p->set_mus_property ("symbol", sym);
145 p->set_mus_property ("value", value);
151 /* We use SCMs to do strings, because it saves us the trouble of
152 deleting them. Let's hope that a stack overflow doesnt trigger a move
153 of the parse stack onto the heap. */
160 Music_output_def * outputdef;
167 yylex (YYSTYPE *s, void * v)
169 My_lily_parser *pars = (My_lily_parser*) v;
170 My_lily_lexer * lex = pars->lexer_;
172 lex->lexval = (void*) s;
173 lex->prepare_for_next_token();
174 return lex->yylex ();
182 /* tokens which are not keywords */
191 %token CHORDMODIFIERS
197 %token GROBDESCRIPTIONS
202 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
203 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
211 %token MULTI_MEASURE_REST
222 %token OVERRIDE SET REVERT
232 %token COMMANDSPANREQUEST
234 %token OUTPUTPROPERTY
249 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
250 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
252 %token <i> E_UNSIGNED
253 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
256 %type <i> exclamations questions dots optional_rest
257 %type <i> bass_number bass_mod
258 %type <scm> br_bass_figure bass_figure figure_list figure_spec
260 %token <scm> NOTENAME_PITCH
261 %token <scm> TONICNAME_PITCH
262 %token <scm> CHORDMODIFIER_PITCH
263 %token <scm> DURATION_IDENTIFIER
264 %token <scm> FRACTION
265 %token <id> IDENTIFIER
266 %token <scm> CHORDNAMES CHORDNAMES_IDENTIFIER
267 %type <scm> chordnames_block chordnames_list chord_scm
270 %token <scm> SCORE_IDENTIFIER
271 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
272 %token <scm> NUMBER_IDENTIFIER
273 %token <scm> EVENT_IDENTIFIER
274 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
275 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
276 %token <scm> RESTNAME
283 %token <scm> MARKUP_HEAD_MARKUP0
284 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
285 %token <scm> MARKUP_HEAD_SCM0
286 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
287 %token <scm> MARKUP_HEAD_SCM0_SCM1
288 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
290 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
291 %type <scm> markup markup_line markup_list markup_list_body full_markup
293 %type <outputdef> output_def
294 %type <scm> lilypond_header lilypond_header_body
295 %type <music> open_event_parens close_event_parens open_event close_event
296 %type <music> event_with_dir event_that_take_dir verbose_event
297 %type <i> sub_quotes sup_quotes
298 %type <music> simple_element event_chord command_element Simple_music Composite_music
299 %type <music> Repeated_music
300 %type <scm> Alternative_music
301 %type <i> tremolo_type
302 %type <i> bare_int bare_unsigned
304 %type <scm> identifier_init
306 %type <music> note_chord_element chord_body chord_body_element
307 %type <scm> chord_body_elements
308 %type <scm> steno_duration optional_notemode_duration multiplied_duration
309 %type <scm> verbose_duration
311 %type <scm> pre_events post_events
312 %type <music> gen_text_def
313 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
314 %type <scm> explicit_pitch steno_tonic_pitch
316 %type <scm> chord_additions chord_subtractions chord_notes chord_step
318 %type <scm> chord_note chord_inversion chord_bass
319 %type <scm> duration_length fraction
321 %type <scm> embedded_scm scalar
322 %type <music> Music Sequential_music Simultaneous_music
323 %type <music> relative_music re_rhythmed_music part_combined_music
324 %type <music> property_def translator_change simple_property_def
325 %type <scm> Music_list
326 %type <outputdef> music_output_def_body
327 %type <music> shorthand_command_req
328 %type <music> post_event
329 %type <music> command_req verbose_command_req
330 %type <music> extender_req
331 %type <music> hyphen_req
332 %type <music> string_event
333 %type <scm> string bare_number number_expression number_term number_factor
334 %type <score> score_block score_body
336 %type <scm> translator_spec_block translator_spec_body
337 %type <music> tempo_event
338 %type <scm> notenames_body notenames_block chordmodifiers_block
339 %type <scm> script_abbreviation
345 /* We don't assign precedence to / and *, because we might need varied
346 prec levels in different prods */
352 lilypond: /* empty */
353 | lilypond toplevel_expression {}
354 | lilypond assignment { }
356 THIS->error_level_ = 1;
359 THIS->error_level_ = 1;
365 THIS->lexer_->pitchname_tab_ = $1;
367 | chordmodifiers_block {
368 THIS->lexer_->chordmodifier_tab_ = $1;
371 THIS->input_file_->header_ = $1;
374 THIS->input_file_->scores_.push ($1);
377 if (dynamic_cast<Paper_def*> ($1))
378 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
379 else if (dynamic_cast<Midi_def*> ($1))
380 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
390 chordmodifiers_block:
391 CHORDMODIFIERS notenames_body { $$ = $2; }
395 PITCHNAMES notenames_body { $$ = $2; }
400 int i = scm_ilength ($1);
402 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
403 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
404 SCM pt = ly_cdar (s);
405 if (!unsmob_pitch (pt))
406 THIS->parser_error ("Need pitch object.");
408 scm_hashq_set_x (tab, ly_caar (s), pt);
414 lilypond_header_body:
416 $$ = ly_make_anonymous_module ();
417 THIS->lexer_->add_scope ($$);
419 | lilypond_header_body assignment {
425 HEADER '{' lilypond_header_body '}' {
426 $$ = THIS->lexer_-> remove_scope();
438 /* cont */ '=' identifier_init {
441 Should find generic way of associating input with objects.
443 Input ip = THIS->pop_spot ();
445 if (! regular_identifier_b ($1))
447 ip.warning (_ ("Identifier should have alphabetic characters only"));
450 THIS->lexer_->set_identifier ($1, $4);
453 TODO: devise standard for protection in parser.
455 The parser stack lives on the C-stack, which means that
456 all objects can be unprotected as soon as they're here.
467 $$ = $1->self_scm ();
468 scm_gc_unprotect_object ($$);
474 $$ = $1->self_scm ();
475 scm_gc_unprotect_object ($$);
477 | translator_spec_block {
481 $$ = $1->self_scm ();
482 scm_gc_unprotect_object ($$);
485 $$ = $1->self_scm ();
486 scm_gc_unprotect_object ($$);
491 | number_expression {
507 { THIS->lexer_->push_chord_state (); }
509 { THIS->lexer_->pop_state (); }
520 | CHORDNAMES_IDENTIFIER chordnames_list {
521 $$ = scm_append (scm_list_2 ($1, $2));
523 | chord_scm '=' full_markup chordnames_list {
524 $$ = scm_cons (scm_cons ($1, $3), $4);
528 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
529 $$ = Chord::tonic_add_sub_to_pitches ($1, $3, $4);
530 /* junk bass and inversion for now */
533 translator_spec_block:
534 TRANSLATOR '{' translator_spec_body '}'
540 translator_spec_body:
541 TRANSLATOR_IDENTIFIER {
543 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
546 $$ = Translator_def::make_scm ();
547 Translator_def*td = unsmob_translator_def ($$);
548 td->translator_group_type_ = $2;
549 td->set_spot (THIS->here_input ());
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("TempoEvent");
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")))
797 we can not get durations and other stuff correct down the line, so we have to
798 add to the duration log here.
800 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
802 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
804 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
806 r->set_spot (*$4->origin ());
813 SEQUENTIAL '{' Music_list '}' {
814 $$ = MY_MAKE_MUSIC("SequentialMusic");
815 $$->set_mus_property ("elements", ly_car ($3));
816 $$->set_spot(THIS->here_input());
818 | '{' Music_list '}' {
819 $$ = MY_MAKE_MUSIC("SequentialMusic");
820 $$->set_mus_property ("elements", ly_car ($2));
821 $$->set_spot(THIS->here_input());
826 SIMULTANEOUS '{' Music_list '}'{
827 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
828 $$->set_mus_property ("elements", ly_car ($3));
829 $$->set_spot(THIS->here_input());
832 | '<' Music_list '>' {
833 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
834 $$->set_mus_property ("elements", ly_car ($2));
835 $$->set_spot(THIS->here_input());
840 event_chord { $$ = $1; }
841 | APPLYCONTEXT embedded_scm {
842 if (!gh_procedure_p ($2))
843 THIS->parser_error (_ ("\applycontext takes function argument"));
844 $$ = MY_MAKE_MUSIC ("ApplyContext");
845 $$->set_mus_property ("procedure", $2);
846 $$->set_spot (THIS->here_input());
848 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
850 if (!gh_symbol_p ($3))
852 THIS->parser_error (_ ("Second argument must be a symbol"));
854 /* Should check # args */
855 if (!gh_procedure_p (pred))
857 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
860 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
861 m->set_mus_property ("predicate", pred);
862 m->set_mus_property ("grob-property", $3);
863 m->set_mus_property ("grob-value", $5);
868 $$ = unsmob_music ($1);
876 CONTEXT STRING Music {
877 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
879 csm->set_mus_property ("element", $3->self_scm ());
880 scm_gc_unprotect_object ($3->self_scm ());
882 csm->set_mus_property ("context-type",$2);
883 csm->set_mus_property ("context-id", scm_makfrom0str (""));
887 | AUTOCHANGE STRING Music {
888 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
889 chm->set_mus_property ("element", $3->self_scm ());
890 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
892 scm_gc_unprotect_object ($3->self_scm ());
893 chm->set_mus_property ("what", $2);
896 chm->set_spot (*$3->origin ());
901 The other version is for easier debugging of
902 Sequential_music_iterator in combination with grace notes.
905 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
906 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
907 Music *startm = unsmob_music (start);
908 Music *stopm = unsmob_music (stop);
912 stopm = stopm->clone ();
913 ms = scm_cons (stopm->self_scm (), ms);
914 scm_gc_unprotect_object (stopm->self_scm ());
916 ms = scm_cons ($2->self_scm (), ms);
917 scm_gc_unprotect_object ($2->self_scm());
919 startm = startm->clone ();
920 ms = scm_cons (startm->self_scm () , ms);
921 scm_gc_unprotect_object (startm->self_scm ());
925 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
926 seq->set_mus_property ("elements", ms);
929 $$ = MY_MAKE_MUSIC("GraceMusic");
930 $$->set_mus_property ("element", seq->self_scm ());
931 scm_gc_unprotect_object (seq->self_scm ());
933 $$ = MY_MAKE_MUSIC("GraceMusic");
934 $$->set_mus_property ("element", $2->self_scm ());
935 scm_gc_unprotect_object ($2->self_scm ());
938 | CONTEXT string '=' string Music {
939 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
941 csm->set_mus_property ("element", $5->self_scm ());
942 scm_gc_unprotect_object ($5->self_scm ());
944 csm->set_mus_property ("context-type", $2);
945 csm->set_mus_property ("context-id", $4);
956 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
958 $$= MY_MAKE_MUSIC("TimeScaledMusic");
959 $$->set_spot (THIS->pop_spot ());
962 $$->set_mus_property ("element", mp->self_scm ());
963 scm_gc_unprotect_object (mp->self_scm ());
964 $$->set_mus_property ("numerator", gh_int2scm (n));
965 $$->set_mus_property ("denominator", gh_int2scm (d));
966 $$->compress (Moment (Rational (n,d)));
969 | Repeated_music { $$ = $1; }
970 | Simultaneous_music { $$ = $1; }
971 | Sequential_music { $$ = $1; }
972 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
973 $$ = MY_MAKE_MUSIC("TransposedMusic");
975 Pitch from = *unsmob_pitch ($2);
976 Pitch to = *unsmob_pitch ($3);
978 p->transpose (interval (from, to));
979 $$->set_mus_property ("element", p->self_scm ());
980 scm_gc_unprotect_object (p->self_scm ());
982 | APPLY embedded_scm Music {
983 SCM ret = gh_call1 ($2, $3->self_scm ());
984 Music *m = unsmob_music (ret);
986 THIS->parser_error ("\\apply must return a Music");
987 m = MY_MAKE_MUSIC("Music");
992 { THIS->lexer_->push_note_state (); }
995 THIS->lexer_->pop_state ();
998 { THIS->lexer_->push_figuredbass_state (); }
1001 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
1002 chm->set_mus_property ("element", $3->self_scm ());
1004 scm_gc_unprotect_object ($3->self_scm());
1006 THIS->lexer_->pop_state ();
1009 { THIS->lexer_->push_chord_state (); }
1012 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
1013 chm->set_mus_property ("element", $3->self_scm ());
1014 scm_gc_unprotect_object ($3->self_scm());
1017 THIS->lexer_->pop_state ();
1020 { THIS->lexer_->push_lyric_state (); }
1024 THIS->lexer_->pop_state ();
1026 | relative_music { $$ = $1; }
1027 | re_rhythmed_music { $$ = $1; }
1028 | part_combined_music { $$ = $1; }
1032 RELATIVE absolute_pitch Music {
1034 Pitch pit = *unsmob_pitch ($2);
1035 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
1037 $$->set_mus_property ("element", p->self_scm ());
1038 scm_gc_unprotect_object (p->self_scm ());
1040 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1046 ADDLYRICS Music Music {
1047 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1048 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1049 scm_gc_unprotect_object ($3->self_scm ());
1050 scm_gc_unprotect_object ($2->self_scm ());
1055 part_combined_music:
1056 PARTCOMBINE STRING Music Music {
1057 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1058 p->set_mus_property ("what", $2);
1059 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1061 scm_gc_unprotect_object ($3->self_scm ());
1062 scm_gc_unprotect_object ($4->self_scm ());
1069 TRANSLATOR STRING '=' STRING {
1070 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1071 t-> set_mus_property ("change-to-type", $2);
1072 t-> set_mus_property ("change-to-id", $4);
1075 $$->set_spot (THIS->here_input ());
1081 | ONCE simple_property_def {
1083 SCM e = $2->get_mus_property ("element");
1084 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1088 simple_property_def:
1089 PROPERTY STRING '.' STRING '=' scalar {
1090 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1091 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1093 csm->set_mus_property ("element", t->self_scm ());
1094 scm_gc_unprotect_object (t->self_scm ());
1097 $$->set_spot (THIS->here_input ());
1099 csm-> set_mus_property ("context-type", $2);
1101 | PROPERTY STRING '.' STRING UNSET {
1103 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1104 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1106 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1107 csm->set_mus_property ("element", t->self_scm ());
1108 scm_gc_unprotect_object (t->self_scm ());
1111 $$->set_spot (THIS->here_input ());
1113 csm-> set_mus_property ("context-type", $2);
1115 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1117 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1118 bool itc = internal_type_checking_global_b;
1119 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1120 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1121 t->set_mus_property ("pop-first", SCM_BOOL_T);
1123 internal_type_checking_global_b = false;
1124 t->set_mus_property ("grob-property", $6);
1126 internal_type_checking_global_b = itc;
1127 t->set_mus_property ("grob-value", $8);
1129 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1130 csm->set_mus_property ("element", t->self_scm ());
1131 scm_gc_unprotect_object (t->self_scm ());
1133 $$->set_spot (THIS->here_input ());
1135 csm-> set_mus_property ("context-type", $2);
1137 | PROPERTY STRING '.' STRING OVERRIDE
1138 embedded_scm '=' embedded_scm
1144 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1145 bool itc = internal_type_checking_global_b;
1147 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1148 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1150 internal_type_checking_global_b = false;
1151 t->set_mus_property ("grob-property", $6);
1152 t->set_mus_property ("grob-value", $8);
1154 internal_type_checking_global_b = itc;
1156 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1157 csm->set_mus_property ("element", t->self_scm ());
1158 scm_gc_unprotect_object (t->self_scm ());
1161 $$->set_spot (THIS->here_input ());
1163 csm-> set_mus_property ("context-type", $2);
1166 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1167 Music *t = MY_MAKE_MUSIC("RevertProperty");
1169 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1170 bool itc = internal_type_checking_global_b;
1172 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1174 internal_type_checking_global_b = false;
1175 t->set_mus_property ("grob-property", $6);
1177 internal_type_checking_global_b = itc;
1179 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1180 csm->set_mus_property ("element", t->self_scm ());
1181 scm_gc_unprotect_object (t->self_scm ());
1184 $$->set_spot (THIS->here_input ());
1186 csm-> set_mus_property ("context-type", $2);
1193 | bare_int { $$ = gh_int2scm ($1); }
1194 | embedded_scm { $$ = $1; }
1195 | full_markup { $$ = $1; }
1202 } /*cont */ simple_element post_events {
1203 SCM elts = $3-> get_mus_property ("elements");
1205 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1206 scm_reverse_x ($4, SCM_EOL));
1208 $3-> set_mus_property ("elements", elts);
1212 | note_chord_element
1217 chord_body optional_notemode_duration post_events
1219 SCM dur = unsmob_duration ($2)->smobbed_copy();
1220 SCM es = $1->get_mus_property ("elements");
1221 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1223 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1224 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1225 es = gh_append2 (es, postevs);
1227 $1-> set_mus_property ("elements", es);
1233 CHORD_OPEN chord_body_elements CHORD_CLOSE
1235 $$ = MY_MAKE_MUSIC("EventChord");
1236 $$->set_mus_property ("elements",
1237 scm_reverse_x ($2, SCM_EOL));
1241 chord_body_elements:
1242 /* empty */ { $$ = SCM_EOL; }
1243 | chord_body_elements chord_body_element {
1244 $$ = gh_cons ($2->self_scm(), $1);
1245 scm_gc_unprotect_object ($2->self_scm());
1250 pitch exclamations questions post_events
1252 Music * n = MY_MAKE_MUSIC("NoteEvent");
1253 n->set_mus_property ("pitch", $1);
1255 n->set_mus_property ("cautionary", SCM_BOOL_T);
1256 if ($2 % 2 || $3 % 2)
1257 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1259 SCM arts = scm_reverse_x ($4, SCM_EOL);
1260 n->set_mus_property ("articulations", arts);
1268 $$ = MY_MAKE_MUSIC("EventChord");
1269 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1270 scm_gc_unprotect_object ($1->self_scm());
1272 $$-> set_spot (THIS->here_input ());
1273 $1-> set_spot (THIS->here_input ());
1276 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1277 l->set_mus_property ("span-direction", gh_int2scm (START));
1278 l->set_spot (THIS->here_input ());
1280 $$ = MY_MAKE_MUSIC("EventChord");
1281 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1282 scm_gc_unprotect_object (l->self_scm());
1283 $$->set_spot (THIS->here_input ());
1286 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1287 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1288 l->set_spot (THIS->here_input ());
1290 $$ = MY_MAKE_MUSIC("EventChord");
1291 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1292 $$->set_spot (THIS->here_input ());
1293 scm_gc_unprotect_object (l->self_scm());
1296 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1297 $$->set_spot (THIS->here_input ());
1301 $$ = MY_MAKE_MUSIC("BarCheck");
1302 $$->set_spot (THIS->here_input ());
1305 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1307 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1308 csm->set_mus_property ("element", t->self_scm ());
1309 scm_gc_unprotect_object (t->self_scm ());
1312 $$->set_spot (THIS->here_input ());
1314 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1316 | PARTIAL duration_length {
1317 Moment m = - unsmob_duration ($2)->get_length ();
1318 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1320 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1321 sp->set_mus_property ("element", p->self_scm ());
1322 scm_gc_unprotect_object (p->self_scm ());
1325 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1330 proc = scm_c_eval_string ("make-clef-set");
1332 SCM result = scm_call_1 (proc, $2);
1333 scm_gc_protect_object (result);
1334 $$ = unsmob_music (result);
1339 proc = scm_c_eval_string ("make-time-signature-set");
1341 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1342 scm_gc_protect_object (result);
1343 $$ = unsmob_music (result);
1348 shorthand_command_req { $$ = $1; }
1349 | verbose_command_req { $$ = $1; }
1352 shorthand_command_req:
1360 $$ = MY_MAKE_MUSIC("TieEvent");
1363 Music *b= MY_MAKE_MUSIC("BeamEvent");
1364 b->set_mus_property ("span-direction", gh_int2scm (START));
1367 THIS->last_beam_start_ = b->self_scm ();
1370 Music *b= MY_MAKE_MUSIC("BeamEvent");
1371 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1375 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1378 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1382 verbose_command_req:
1384 Music * m = MY_MAKE_MUSIC("MarkEvent");
1388 Music *m = MY_MAKE_MUSIC("MarkEvent");
1389 m->set_mus_property ("label", $2);
1392 | SKIP duration_length {
1393 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1394 skip->set_mus_property ("duration", $2);
1402 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1405 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1406 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1408 key->set_mus_property ("pitch-alist", $3);
1409 key->set_mus_property ("tonic", Pitch (0,0,0).smobbed_copy());
1410 ((Music*)key)->transpose (* unsmob_pitch ($2));
1420 | post_events post_event {
1421 $2->set_spot (THIS->here_input ());
1422 $$ = gh_cons ($2->self_scm(), $$);
1423 scm_gc_unprotect_object ($2->self_scm());
1436 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1437 s->set_mus_property ("string-number", gh_int2scm($1));
1438 s->set_spot (THIS->here_input ());
1444 event_that_take_dir:
1450 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1451 m->set_spot (THIS->here_input());
1452 m->set_mus_property ("span-direction" , gh_int2scm (START));
1456 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1457 m->set_spot (THIS->here_input());
1458 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1462 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1463 m->set_spot (THIS->here_input());
1466 | script_abbreviation {
1467 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1468 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1469 if (gh_string_p (s))
1470 a->set_mus_property ("articulation-type", s);
1471 else THIS->parser_error (_ ("Expecting string as script definition"));
1477 script_dir event_that_take_dir {
1478 $2->set_mus_property ("direction", gh_int2scm ($1));
1485 $$ = unsmob_music ($1);
1488 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1489 a->set_spot (THIS->here_input ());
1490 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1517 | NOTENAME_PITCH sup_quotes {
1518 Pitch p = *unsmob_pitch ($1);
1519 p = p.transposed (Pitch ($2,0,0));
1520 $$ = p.smobbed_copy ();
1522 | NOTENAME_PITCH sub_quotes {
1523 Pitch p =* unsmob_pitch ($1);
1524 p = p.transposed (Pitch (-$2,0,0));
1525 $$ = p.smobbed_copy ();
1537 | TONICNAME_PITCH sup_quotes {
1538 Pitch p = *unsmob_pitch ($1);
1539 p = p.transposed (Pitch ($2,0,0));
1540 $$ = p.smobbed_copy ();
1542 | TONICNAME_PITCH sub_quotes {
1543 Pitch p =* unsmob_pitch ($1);
1545 p = p.transposed (Pitch (-$2,0,0));
1546 $$ = 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 (),
2070 Pitch m($1 > 7 ? 1 : 0, ($1 - 1) % 7, 0);
2072 $$ = m.smobbed_copy ();
2074 | bare_unsigned '+' {
2075 Pitch m( $1 > 7 ? 1 : 0,($1 - 1) % 7, 1);
2077 $$ = m.smobbed_copy ();
2079 | bare_unsigned CHORD_MINUS {
2080 Pitch m( $1 > 7 ? 1 : 0,($1 - 1) % 7, -1);
2082 $$ = m.smobbed_copy ();
2090 number_expression '+' number_term {
2091 $$ = scm_sum ($1, $3);
2093 | number_expression '-' number_term {
2094 $$ = scm_difference ($1, $3);
2103 | number_factor '*' number_factor {
2104 $$ = scm_product ($1, $3);
2106 | number_factor '/' number_factor {
2107 $$ = scm_divide ($1, $3);
2112 '-' number_factor { /* %prec UNARY_MINUS */
2113 $$ = scm_difference ($2, SCM_UNDEFINED);
2121 $$ = gh_int2scm ($1);
2126 | NUMBER_IDENTIFIER {
2129 | REAL NUMBER_IDENTIFIER {
2130 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2132 | UNSIGNED NUMBER_IDENTIFIER {
2133 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2149 if (scm_integer_p ($1) == SCM_BOOL_T)
2151 int k = gh_scm2int ($1);
2155 THIS->parser_error (_ ("need integer number arg"));
2169 | STRING_IDENTIFIER {
2172 | string '+' string {
2173 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2180 | exclamations '!' { $$ ++; }
2185 | questions '?' { $$ ++; }
2195 { THIS->lexer_->push_markup_state (); }
2198 THIS->lexer_->pop_state ();
2204 $$ = make_simple_markup ($1);
2206 | MARKUP_HEAD_MARKUP0 markup {
2207 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2209 | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2210 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2212 | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2213 $$ = scm_list_n ($1, $2, $3, SCM_UNDEFINED);
2218 | MARKUP_HEAD_LIST0 markup_list {
2219 $$ = scm_list_n ($1,$2, SCM_UNDEFINED);
2221 | MARKUP_HEAD_SCM0 embedded_scm {
2222 $$ = scm_list_n ($1, $2, SCM_UNDEFINED);
2224 | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2225 $$ = scm_list_n ($1, $2, $3, $4, SCM_UNDEFINED);
2227 | MARKUP_IDENTIFIER {
2234 CHORD_OPEN markup_list_body CHORD_CLOSE { $$ = scm_reverse_x ($2, SCM_EOL); }
2238 '{' markup_list_body '}' {
2241 line = scm_c_eval_string ("line-markup");
2243 $$ = scm_list_n (line, scm_reverse_x ($2, SCM_EOL), SCM_UNDEFINED);
2248 /**/ { $$ = SCM_EOL; }
2249 | markup_list_body markup {
2250 $$ = gh_cons ($2, $1) ;
2258 My_lily_parser::set_yydebug (bool )
2265 extern My_lily_parser * current_parser;
2268 My_lily_parser::do_yyparse ()
2270 current_parser = this;;
2271 yyparse ((void*)this);
2276 Should make this optional? It will also complain when you do
2280 which is entirely legitimate.
2282 Or we can scrap it. Barchecks should detect wrong durations, and
2283 skipTypesetting speeds it up a lot.
2287 My_lily_parser::beam_check (SCM dur)
2289 Duration *d = unsmob_duration (dur);
2290 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2292 Music * m = unsmob_music (last_beam_start_);
2293 m->origin ()->warning (_("Suspect duration found following this beam"));
2295 last_beam_start_ = SCM_EOL;
2303 return gh_pair_p (x)
2304 && SCM_BOOL_F != scm_object_property (gh_car (x), ly_symbol2scm ("markup-signature"));
2307 It is a little strange, to have this function in this file, but
2308 otherwise, we have to import music classes into the lexer.
2312 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2314 if (gh_string_p (sid)) {
2316 return STRING_IDENTIFIER;
2317 } else if (gh_number_p (sid)) {
2319 return NUMBER_IDENTIFIER;
2320 } else if (unsmob_translator_def (sid)) {
2321 *destination = unsmob_translator_def (sid)->clone_scm();
2322 return TRANSLATOR_IDENTIFIER;
2323 } else if (unsmob_score (sid)) {
2324 Score *sc = new Score (*unsmob_score (sid));
2325 *destination =sc->self_scm ();
2326 return SCORE_IDENTIFIER;
2327 } else if (Music * mus =unsmob_music (sid)) {
2328 *destination = unsmob_music (sid)->clone ()->self_scm();
2329 unsmob_music (*destination)->
2330 set_mus_property ("origin", make_input (last_input_));
2331 return dynamic_cast<Event*> (mus)
2332 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2333 } else if (unsmob_duration (sid)) {
2334 *destination = unsmob_duration (sid)->smobbed_copy();
2335 return DURATION_IDENTIFIER;
2336 } else if (unsmob_music_output_def (sid)) {
2337 Music_output_def *p = unsmob_music_output_def (sid);
2340 *destination = p->self_scm();
2341 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2342 } else if (new_markup_p (sid)) {
2344 return MARKUP_IDENTIFIER;