1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
20 the rules for who is protecting what are very shady. TODO: uniformise
29 #include "translator-def.hh"
30 #include "lily-guile.hh"
31 #include "change-iterator.hh"
33 #include "my-lily-lexer.hh"
34 #include "paper-def.hh"
35 #include "midi-def.hh"
37 #include "file-path.hh"
39 #include "dimensions.hh"
40 #include "command-request.hh"
41 #include "musical-request.hh"
42 #include "my-lily-parser.hh"
43 #include "context-specced-music.hh"
45 #include "music-list.hh"
46 #include "output-property-music-iterator.hh"
47 #include "property-iterator.hh"
48 #include "file-results.hh"
50 #include "relative-music.hh"
51 #include "lyric-combine-music.hh"
52 #include "transposed-music.hh"
53 #include "time-scaled-music.hh"
54 #include "repeated-music.hh"
55 #include "untransposable-music.hh"
56 #include "lilypond-input-version.hh"
57 #include "grace-music.hh"
58 #include "part-combine-music.hh"
59 #include "scm-hash.hh"
60 #include "auto-change-iterator.hh"
61 #include "un-relativable-music.hh"
65 regular_identifier_b (SCM id)
67 String str = ly_scm2string (id);
68 char const *s = str.ch_C() ;
73 v = v && isalpha (*s);
81 set_property_music (SCM sym, SCM value)
83 Music * p = new Music (SCM_EOL);
84 p->set_mus_property ("symbol", sym);
85 p->set_mus_property ("iterator-ctor",
86 Property_iterator::constructor_cxx_function);
88 p->set_mus_property ("value", value);
95 return t && t == 1 << intlog2 (t);
99 set_music_properties (Music *p, SCM a)
101 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
103 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
113 // needed for bison.simple's malloc () and free ()
120 #define YYERROR_VERBOSE 1
122 #define YYPARSE_PARAM my_lily_parser_l
123 #define YYLEX_PARAM my_lily_parser_l
125 ((My_lily_parser *) my_lily_parser_l)
127 #define yyerror THIS->parser_error
128 #define ARRAY_SIZE(a,s) if (a.size () != s) THIS->parser_error (_f ("Expecting %d arguments", s))
132 /* We use SCMs to do strings, because it saves us the trouble of
133 deleting them. Let's hope that a stack overflow doesnt trigger a move
134 of the parse stack onto the heap. */
139 Link_array<Request> *reqvec;
141 String *string; // needed by the lexer as temporary scratch area.
144 Scheme_hash_table *scmhash;
145 Music_output_def * outputdef;
157 yylex (YYSTYPE *s, void * v_l)
159 My_lily_parser *pars_l = (My_lily_parser*) v_l;
160 My_lily_lexer * lex_l = pars_l->lexer_p_;
162 lex_l->lexval_l = (void*) s;
163 return lex_l->yylex ();
171 /* tokens which are not keywords */
181 %token CHORDMODIFIERS
189 %token GROBDESCRIPTIONS
195 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
196 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
206 %token MULTI_MEASURE_REST
218 %token OVERRIDE SET REVERT
231 %token COMMANDSPANREQUEST
233 %token OUTPUTPROPERTY
244 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
245 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
247 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET
251 %type <i> exclamations questions dots optional_rest
252 %type <i> bass_number bass_mod
253 %type <scm> br_bass_figure bass_figure figure_list figure_spec
255 %token <scm> NOTENAME_PITCH
256 %token <scm> TONICNAME_PITCH
257 %token <scm> CHORDMODIFIER_PITCH
258 %token <scm> DURATION_IDENTIFIER
259 %token <scm> FRACTION
260 %token <id> IDENTIFIER
263 %token <scm> SCORE_IDENTIFIER
264 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
266 %token <scm> NUMBER_IDENTIFIER
267 %token <scm> REQUEST_IDENTIFIER
268 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
269 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
270 %token <scm> RESTNAME
276 %type <outputdef> output_def
277 %type <scmhash> lilypond_header lilypond_header_body
278 %type <request> open_request_parens close_request_parens open_request close_request
279 %type <request> request_with_dir request_that_take_dir verbose_request
280 %type <i> sub_quotes sup_quotes
281 %type <music> simple_element request_chord command_element Simple_music Composite_music
282 %type <music> Repeated_music
283 %type <scm> Alternative_music
284 %type <i> tremolo_type
285 %type <i> bare_int bare_unsigned
288 %type <scm> identifier_init
290 %type <scm> steno_duration optional_notemode_duration multiplied_duration
291 %type <scm> verbose_duration
293 %type <reqvec> pre_requests post_requests
294 %type <request> gen_text_def
295 %type <scm> steno_pitch pitch absolute_pitch
296 %type <scm> explicit_pitch steno_tonic_pitch
298 %type <scm> chord_additions chord_subtractions chord_notes chord_step
300 %type <scm> chord_note chord_inversion chord_bass
301 %type <scm> duration_length fraction
303 %type <scm> embedded_scm scalar
304 %type <music> Music Sequential_music Simultaneous_music
305 %type <music> relative_music re_rhythmed_music part_combined_music
306 %type <music> property_def translator_change
307 %type <scm> Music_list
308 %type <outputdef> music_output_def_body
309 %type <request> shorthand_command_req
310 %type <request> post_request
311 %type <music> command_req verbose_command_req
312 %type <request> extender_req
313 %type <request> hyphen_req
314 %type <scm> string bare_number number_expression number_term number_factor
316 %type <score> score_block score_body
318 %type <scm> translator_spec_block translator_spec_body
319 %type <tempo> tempo_request
320 %type <scm> notenames_body notenames_block chordmodifiers_block
321 %type <scm> script_abbreviation
327 /* We don't assign precedence to / and *, because we might need varied
328 prec levels in different prods */
334 lilypond: /* empty */
335 | lilypond toplevel_expression {}
336 | lilypond assignment { }
338 THIS->error_level_i_ = 1;
341 THIS->error_level_i_ = 1;
347 THIS->lexer_p_->pitchname_tab_ = $1;
349 | chordmodifiers_block {
350 THIS->lexer_p_->chordmodifier_tab_ = $1;
354 scm_gc_unprotect_object (global_header_p->self_scm ());
355 global_header_p = $1;
358 score_global_array.push ($1);
361 if (dynamic_cast<Paper_def*> ($1))
362 THIS->lexer_p_->set_identifier (gh_str02scm ("$defaultpaper"), $1->self_scm ());
363 else if (dynamic_cast<Midi_def*> ($1))
364 THIS->lexer_p_->set_identifier (gh_str02scm ("$defaultmidi"), $1->self_scm ());
377 chordmodifiers_block:
378 CHORDMODIFIERS notenames_body { $$ = $2; }
382 PITCHNAMES notenames_body { $$ = $2; }
387 int i = scm_ilength ($1);
389 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
390 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
391 SCM pt = ly_cdar (s);
392 if (!unsmob_pitch (pt))
393 THIS->parser_error ("Need pitch object.");
395 scm_hashq_set_x (tab, ly_caar (s), pt);
402 lilypond_header_body:
404 $$ = new Scheme_hash_table;
405 THIS->lexer_p_-> scope_l_arr_.push ($$);
407 | lilypond_header_body assignment {
413 HEADER '{' lilypond_header_body '}' {
415 THIS->lexer_p_->scope_l_arr_.pop ();
427 /* cont */ '=' identifier_init {
430 Should find generic way of associating input with objects.
432 Input ip = THIS->pop_spot ();
434 if (! regular_identifier_b ($1))
436 ip.warning (_ ("Identifier should have alphabetic characters only"));
439 THIS->lexer_p_->set_identifier ($1, $4);
442 TODO: devise standard for protection in parser.
444 The parser stack lives on the C-stack, which means that
445 all objects can be unprotected as soon as they're here.
455 $$ = $1->self_scm ();
456 scm_gc_unprotect_object ($$);
459 $$ = $1->self_scm ();
460 scm_gc_unprotect_object ($$);
462 | translator_spec_block {
466 $$ = $1->self_scm ();
467 scm_gc_unprotect_object ($$);
470 $$ = $1->self_scm ();
471 scm_gc_unprotect_object ($$);
476 | number_expression {
487 translator_spec_block:
488 TRANSLATOR '{' translator_spec_body '}'
494 translator_spec_body:
495 TRANSLATOR_IDENTIFIER {
496 $$ = unsmob_translator_def ($1)->clone_scm ();
497 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
500 $$ = Translator_def::make_scm ();
501 Translator_def*td = unsmob_translator_def ($$);
502 td->translator_group_type_ = $2;
503 td->set_spot (THIS->here_input ());
505 | translator_spec_body STRING '=' embedded_scm {
506 unsmob_translator_def ($$)->add_property_assign ($2, $4);
508 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
509 unsmob_translator_def ($$)
510 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
512 | translator_spec_body STRING REVERT embedded_scm {
513 unsmob_translator_def ($$)->add_pop_property (
514 scm_string_to_symbol ($2), $4);
516 | translator_spec_body NAME STRING {
517 unsmob_translator_def ($$)->type_name_ = $3;
519 | translator_spec_body CONSISTS STRING {
520 unsmob_translator_def ($$)->add_element ($3);
522 | translator_spec_body ALIAS STRING {
523 Translator_def*td = unsmob_translator_def ($$);
524 td->type_aliases_ = gh_cons ($3, td->type_aliases_);
526 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
527 Translator_def*td = unsmob_translator_def($$);
528 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
529 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
530 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
532 | translator_spec_body CONSISTSEND STRING {
533 unsmob_translator_def ($$)->add_last_element ( $3);
535 | translator_spec_body ACCEPTS STRING {
536 unsmob_translator_def ($$)->set_acceptor ($3,true);
538 | translator_spec_body DENIES STRING {
539 unsmob_translator_def ($$)->set_acceptor ($3,false);
541 | translator_spec_body REMOVE STRING {
542 unsmob_translator_def ($$)->remove_element ($3);
553 /*cont*/ '{' score_body '}' {
556 if (!$$->def_p_arr_.size ())
558 Music_output_def *id =
559 unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
560 $$->add_output (id ? id->clone () : new Paper_def );
569 $$->set_spot (THIS->here_input ());
570 SCM m = $1->self_scm ();
571 scm_gc_unprotect_object (m);
577 SCM check_func = scm_c_eval_string ("check-start-chords");
578 gh_call1 (check_func, m);
582 $$ = new Score (*unsmob_score ($1));
583 $$->set_spot (THIS->here_input ());
585 | score_body lilypond_header {
586 scm_gc_unprotect_object ($2->self_scm ());
589 | score_body output_def {
602 music_output_def_body '}' {
604 THIS-> lexer_p_-> scope_l_arr_.pop ();
608 music_output_def_body:
610 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultmidi"));
615 p = dynamic_cast<Midi_def*> (id->clone ());
620 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
623 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
626 p = dynamic_cast<Paper_def*> (id->clone ());
629 THIS-> lexer_p_-> scope_l_arr_.push (p->variable_tab_);
632 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
633 Music_output_def *p = unsmob_music_output_def ($3);
635 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
638 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
639 Music_output_def *p = unsmob_music_output_def ($3);
642 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
645 | music_output_def_body assignment {
648 | music_output_def_body translator_spec_block {
649 $$->assign_translator ($2);
651 | music_output_def_body STYLESHEET embedded_scm {
652 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
654 | music_output_def_body tempo_request {
656 junk this ? there already is tempo stuff in
659 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
660 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
661 Midi_def * md = dynamic_cast<Midi_def*> ($$);
663 md->set_tempo (d->length_mom (), m);
665 | music_output_def_body error {
671 TEMPO steno_duration '=' bare_unsigned {
673 $$->set_mus_property ("duration", $2);
674 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
679 The representation of a list is the
683 to have efficient append.
685 Music_list: /* empty */ {
686 $$ = gh_cons (SCM_EOL, SCM_EOL);
690 SCM c = gh_cons ($2->self_scm (), SCM_EOL);
691 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
692 if (gh_pair_p (ly_cdr (s)))
693 gh_set_cdr_x (ly_cdr (s), c); /* append */
695 gh_set_car_x (s, c); /* set first cons */
696 gh_set_cdr_x (s, c) ; /* remember last cell */
712 | ALTERNATIVE '{' Music_list '}' {
718 REPEAT string bare_unsigned Music Alternative_music
722 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
723 if (times < scm_ilength (alts)) {
724 unsmob_music (gh_car (alts))
725 ->origin ()->warning (
726 _("More alternatives than repeats. Junking excess alternatives."));
727 alts = ly_truncate_list (times, alts);
730 Repeated_music * r = new Repeated_music (SCM_EOL);
733 r-> set_mus_property ("element", beg->self_scm ());
734 scm_gc_unprotect_object (beg->self_scm ());
736 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
738 r-> set_mus_property ("elements",alts);
739 SCM func = scm_primitive_eval (ly_symbol2scm ("repeat-name-to-ctor"));
740 SCM result = gh_call1 (func, $2);
742 set_music_properties (r, result);
744 r->set_spot (*$4->origin ());
750 SEQUENTIAL '{' Music_list '}' {
751 $$ = new Sequential_music (SCM_EOL);
752 $$->set_mus_property ("elements", ly_car ($3));
753 $$->set_spot(THIS->here_input());
755 | '{' Music_list '}' {
756 $$ = new Sequential_music (SCM_EOL);
757 $$->set_mus_property ("elements", ly_car ($2));
758 $$->set_spot(THIS->here_input());
763 SIMULTANEOUS '{' Music_list '}'{
764 $$ = new Simultaneous_music (SCM_EOL);
765 $$->set_mus_property ("elements", ly_car ($3));
766 $$->set_spot(THIS->here_input());
769 | '<' Music_list '>' {
770 $$ = new Simultaneous_music (SCM_EOL);
771 $$->set_mus_property ("elements", ly_car ($2));
772 $$->set_spot(THIS->here_input());
777 request_chord { $$ = $1; }
778 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
780 if (!gh_symbol_p ($3))
782 THIS->parser_error (_ ("Second argument must be a symbol"));
784 /*hould check # args */
785 if (!gh_procedure_p (pred))
787 THIS->parser_error (_ ("First argument must be a procedure taking 1 argument"));
790 Music *m = new Music (SCM_EOL);
791 m->set_mus_property ("predicate", pred);
792 m->set_mus_property ("grob-property", $3);
793 m->set_mus_property ("grob-value", $5);
794 m->set_mus_property ("iterator-ctor",
795 Output_property_music_iterator::constructor_cxx_function);
800 $$ = unsmob_music ($1)->clone ();
802 $$->set_spot (THIS->here_input());
810 CONTEXT STRING Music {
811 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
812 csm->set_mus_property ("element", $3->self_scm ());
813 scm_gc_unprotect_object ($3->self_scm ());
815 csm->set_mus_property ("context-type",$2);
816 csm->set_mus_property ("context-id", ly_str02scm (""));
820 | AUTOCHANGE STRING Music {
821 Music * chm = new Music_wrapper (SCM_EOL);
822 chm->set_mus_property ("element", $3->self_scm ());
823 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_cxx_function);
825 scm_gc_unprotect_object ($3->self_scm ());
826 chm->set_mus_property ("what", $2);
829 chm->set_spot (*$3->origin ());
834 The other version is for easier debugging of
835 Sequential_music_iterator in combination with grace notes.
838 SCM start = THIS->lexer_p_->lookup_identifier ("startGraceMusic");
839 SCM stop = THIS->lexer_p_->lookup_identifier ("stopGraceMusic");
840 Music *startm = unsmob_music (start);
841 Music *stopm = unsmob_music (stop);
845 stopm = stopm->clone ();
846 ms = gh_cons (stopm->self_scm (), ms);
847 scm_gc_unprotect_object (stopm->self_scm ());
849 ms = gh_cons ($2->self_scm (), ms);
850 scm_gc_unprotect_object ($2->self_scm());
852 startm = startm->clone ();
853 ms = gh_cons (startm->self_scm () , ms);
854 scm_gc_unprotect_object (startm->self_scm ());
857 Music* seq = new Sequential_music (SCM_EOL);
858 seq->set_mus_property ("elements", ms);
860 $$ = new Grace_music (SCM_EOL);
861 $$->set_mus_property ("element", seq->self_scm ());
862 scm_gc_unprotect_object (seq->self_scm ());
864 $$ = new Grace_music (SCM_EOL);
865 $$->set_mus_property ("element", $2->self_scm ());
866 scm_gc_unprotect_object ($2->self_scm ());
869 | CONTEXT string '=' string Music {
870 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
871 csm->set_mus_property ("element", $5->self_scm ());
872 scm_gc_unprotect_object ($5->self_scm ());
874 csm->set_mus_property ("context-type", $2);
875 csm->set_mus_property ("context-id", $4);
886 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
888 $$ = new Time_scaled_music (SCM_EOL);
889 $$->set_spot (THIS->pop_spot ());
892 $$->set_mus_property ("element", mp->self_scm ());
893 scm_gc_unprotect_object (mp->self_scm ());
894 $$->set_mus_property ("numerator", gh_int2scm (n));
895 $$->set_mus_property ("denominator", gh_int2scm (d));
896 $$->compress (Moment (Rational (n,d)));
899 | Repeated_music { $$ = $1; }
900 | Simultaneous_music { $$ = $1; }
901 | Sequential_music { $$ = $1; }
902 | TRANSPOSE pitch Music {
903 $$ = new Transposed_music (SCM_EOL);
905 Pitch pit = *unsmob_pitch ($2);
908 $$->set_mus_property ("element", p->self_scm ());
909 scm_gc_unprotect_object (p->self_scm ());
911 | TRANSPOSE steno_tonic_pitch Music {
912 $$ = new Transposed_music (SCM_EOL);
914 Pitch pit = *unsmob_pitch ($2);
917 $$->set_mus_property ("element", p->self_scm ());
918 scm_gc_unprotect_object (p->self_scm ());
921 | APPLY embedded_scm Music {
922 SCM ret = gh_call1 ($2, $3->self_scm ());
923 Music *m = unsmob_music (ret);
925 THIS->parser_error ("\\apply must return a Music");
926 m = new Music (SCM_EOL);
931 { THIS->lexer_p_->push_note_state (); }
934 THIS->lexer_p_->pop_state ();
937 { THIS->lexer_p_->push_figuredbass_state (); }
940 Music * chm = new Untransposable_music () ;
941 chm->set_mus_property ("element", $3->self_scm ());
944 THIS->lexer_p_->pop_state ();
947 { THIS->lexer_p_->push_chord_state (); }
950 Music * chm = new Un_relativable_music ;
951 chm->set_mus_property ("element", $3->self_scm ());
954 THIS->lexer_p_->pop_state ();
957 { THIS->lexer_p_->push_lyric_state (); }
961 THIS->lexer_p_->pop_state ();
963 | relative_music { $$ = $1; }
964 | re_rhythmed_music { $$ = $1; }
965 | part_combined_music { $$ = $1; }
969 RELATIVE absolute_pitch Music {
971 Pitch pit = *unsmob_pitch ($2);
972 $$ = new Relative_octave_music (SCM_EOL);
974 $$->set_mus_property ("element", p->self_scm ());
975 scm_gc_unprotect_object (p->self_scm ());
977 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
983 ADDLYRICS Music Music {
984 Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
985 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
986 scm_gc_unprotect_object ($3->self_scm ());
987 scm_gc_unprotect_object ($2->self_scm ());
993 PARTCOMBINE STRING Music Music {
994 Part_combine_music * p = new Part_combine_music (SCM_EOL);
996 p->set_mus_property ("what", $2);
997 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
999 scm_gc_unprotect_object ($3->self_scm ());
1000 scm_gc_unprotect_object ($4->self_scm ());
1007 TRANSLATOR STRING '=' STRING {
1008 Music * t = new Music (SCM_EOL);
1009 t->set_mus_property ("iterator-ctor",
1010 Change_iterator::constructor_cxx_function);
1011 t-> set_mus_property ("change-to-type", $2);
1012 t-> set_mus_property ("change-to-id", $4);
1015 $$->set_spot (THIS->here_input ());
1020 PROPERTY STRING '.' STRING '=' scalar {
1022 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1023 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1025 csm->set_mus_property ("element", t->self_scm ());
1026 scm_gc_unprotect_object (t->self_scm ());
1029 $$->set_spot (THIS->here_input ());
1031 csm-> set_mus_property ("context-type", $2);
1033 | PROPERTY STRING '.' STRING UNSET {
1034 Music *t = new Music (SCM_EOL);
1036 t->set_mus_property ("iterator-ctor",
1037 Property_unset_iterator::constructor_cxx_function);
1038 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1040 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1041 csm->set_mus_property ("element", t->self_scm ());
1042 scm_gc_unprotect_object (t->self_scm ());
1045 $$->set_spot (THIS->here_input ());
1047 csm-> set_mus_property ("context-type", $2);
1049 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1050 Music *t = new Music (SCM_EOL);
1051 t->set_mus_property ("iterator-ctor",
1052 Push_property_iterator::constructor_cxx_function);
1053 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1054 t->set_mus_property ("pop-first", SCM_BOOL_T);
1055 t->set_mus_property ("grob-property", $6);
1056 t->set_mus_property ("grob-value", $8);
1057 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1058 csm->set_mus_property ("element", t->self_scm ());
1059 scm_gc_unprotect_object (t->self_scm ());
1061 $$->set_spot (THIS->here_input ());
1063 csm-> set_mus_property ("context-type", $2);
1065 | PROPERTY STRING '.' STRING OVERRIDE embedded_scm '=' embedded_scm {
1066 Music *t = new Music (SCM_EOL);
1067 t->set_mus_property ("iterator-ctor",
1068 Push_property_iterator::constructor_cxx_function);
1069 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1070 t->set_mus_property ("grob-property", $6);
1071 t->set_mus_property ("grob-value", $8);
1072 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1073 csm->set_mus_property ("element", t->self_scm ());
1074 scm_gc_unprotect_object (t->self_scm ());
1077 $$->set_spot (THIS->here_input ());
1079 csm-> set_mus_property ("context-type", $2);
1081 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1082 Music *t = new Music (SCM_EOL);
1083 t->set_mus_property ("iterator-ctor",
1084 Pop_property_iterator::constructor_cxx_function);
1085 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1086 t->set_mus_property ("grob-property", $6);
1088 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1089 csm->set_mus_property ("element", t->self_scm ());
1090 scm_gc_unprotect_object (t->self_scm ());
1093 $$->set_spot (THIS->here_input ());
1095 csm-> set_mus_property ("context-type", $2);
1101 | bare_int { $$ = gh_int2scm ($1); }
1102 | embedded_scm { $$ = $1; }
1109 } /*cont */ simple_element post_requests {
1110 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1113 for (int i=0; i < $1->size (); i++) {
1114 Music * m = $1->elem (i);
1115 l->append_music (m);
1127 $$ = new Request_chord (SCM_EOL);
1128 $$->set_mus_property ("elements", gh_cons ($1->self_scm (), SCM_EOL));
1129 $$-> set_spot (THIS->here_input ());
1130 $1-> set_spot (THIS->here_input ());
1133 Span_req *l = new Span_req;
1134 l->set_span_dir (START);
1135 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1136 l->set_spot (THIS->here_input ());
1138 $$ = new Request_chord (SCM_EOL);
1139 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1140 $$->set_spot (THIS->here_input ());
1143 Span_req *l = new Span_req;
1144 l->set_span_dir (STOP);
1145 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1146 l->set_spot (THIS->here_input ());
1148 $$ = new Request_chord (SCM_EOL);
1149 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1150 $$->set_spot (THIS->here_input ());
1153 $$ = new Music (gh_list (gh_cons (ly_symbol2scm ("name"), ly_symbol2scm ("separator")), SCM_UNDEFINED));
1154 $$->set_spot (THIS->here_input ());
1158 extern Music * get_barcheck();
1159 $$ = get_barcheck ();
1160 $$->set_spot (THIS->here_input ());
1163 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1165 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1166 csm->set_mus_property ("element", t->self_scm ());
1167 scm_gc_unprotect_object (t->self_scm ());
1170 $$->set_spot (THIS->here_input ());
1172 csm->set_mus_property ("context-type", ly_str02scm ("Score"));
1174 | PARTIAL duration_length {
1175 Moment m = - unsmob_duration ($2)->length_mom ();
1176 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1178 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1179 sp->set_mus_property ("element", p->self_scm ());
1180 scm_gc_unprotect_object (p->self_scm ());
1183 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1186 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1187 SCM result = gh_call1 (func, $2);
1190 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1191 Music * p = new Music (SCM_EOL);
1192 set_music_properties (p, ly_car (s));
1193 l = gh_cons (p->self_scm (), l);
1194 scm_gc_unprotect_object (p->self_scm ());
1196 Sequential_music * seq = new Sequential_music (SCM_EOL);
1197 seq->set_mus_property ("elements", l);
1199 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1200 sp->set_mus_property ("element", seq->self_scm ());
1201 scm_gc_unprotect_object (seq->self_scm ());
1204 sp-> set_mus_property ("context-type", ly_str02scm ("Staff"));
1207 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1209 int l = gh_scm2int (ly_car ($2));
1210 int o = gh_scm2int (ly_cdr ($2));
1212 Moment one_beat = Moment (1)/Moment (o);
1213 Moment len = Moment (l) * one_beat;
1216 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1217 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1219 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1220 Sequential_music *seq = new Sequential_music (SCM_EOL);
1221 seq->set_mus_property ("elements", list);
1224 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1225 sp->set_mus_property ("element", seq->self_scm ());
1229 scm_gc_unprotect_object (p3->self_scm ());
1230 scm_gc_unprotect_object (p2->self_scm ());
1231 scm_gc_unprotect_object (p1->self_scm ());
1232 scm_gc_unprotect_object (seq->self_scm ());
1237 TODO: should make alias TimingContext for Score
1240 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1245 shorthand_command_req { $$ = $1; }
1246 | verbose_command_req { $$ = $1; }
1249 shorthand_command_req:
1260 Span_req*b= new Span_req;
1261 b->set_span_dir (START);
1262 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1266 THIS->last_beam_start_ = b->self_scm ();
1269 Span_req*b= new Span_req;
1270 b->set_span_dir ( STOP);
1271 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1275 $$ = new Breathing_sign_req;
1278 $$ = new Porrectus_req;
1282 verbose_command_req:
1283 COMMANDSPANREQUEST bare_int STRING { /*TODO: junkme */
1284 Span_req * sp_p = new Span_req;
1285 sp_p-> set_span_dir ( Direction ($2));
1286 sp_p->set_mus_property ("span-type",$3);
1287 sp_p->set_spot (THIS->here_input ());
1291 Mark_req * m = new Mark_req;
1295 Mark_req *m = new Mark_req;
1296 m->set_mus_property ("label", $2);
1301 Break_req * b = new Break_req;
1303 if (!gh_number_p (s))
1306 b->set_mus_property ("penalty", s);
1307 b->set_spot (THIS->here_input ());
1310 | SKIP duration_length {
1311 Skip_req * skip_p = new Skip_req;
1312 skip_p->set_mus_property ("duration", $2);
1320 Key_change_req *key_p= new Key_change_req;
1323 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1324 Key_change_req *key_p= new Key_change_req;
1326 key_p->set_mus_property ("pitch-alist", $3);
1327 ((Music*)key_p)->transpose (* unsmob_pitch ($2));
1334 $$ = new Link_array<Request>;
1336 | post_requests post_request {
1337 $2->set_spot (THIS->here_input ());
1349 request_that_take_dir:
1352 | script_abbreviation {
1353 SCM s = THIS->lexer_p_->lookup_identifier ("dash" + ly_scm2string ($1));
1354 Articulation_req *a = new Articulation_req;
1355 if (gh_string_p (s))
1356 a->set_mus_property ("articulation-type", s);
1357 else THIS->parser_error (_ ("Expecting string as script definition"));
1363 script_dir request_that_take_dir {
1364 if (Script_req * gs = dynamic_cast<Script_req*> ($2))
1365 gs->set_direction (Direction ($1));
1367 $2->origin ()->warning (_ ("Can't specify direction for this request"));
1373 REQUEST_IDENTIFIER {
1374 $$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
1375 $$->set_spot (THIS->here_input ());
1377 | DYNAMICSCRIPT embedded_scm {
1379 TODO: junkme, use text-type == dynamic
1381 Text_script_req *d = new Text_script_req;
1382 SCM dyn = ly_symbol2scm ("dynamic");
1383 d->set_mus_property ("text-type" , dyn);
1384 d->set_mus_property ("text", $2);
1385 d->set_spot (THIS->here_input ());
1388 | SPANREQUEST bare_int STRING {
1389 Span_req * sp_p = new Span_req;
1390 sp_p->set_span_dir ( Direction ($2));
1391 sp_p->set_mus_property ("span-type", $3);
1392 sp_p->set_spot (THIS->here_input ());
1396 Tremolo_req* a = new Tremolo_req;
1397 a->set_spot (THIS->here_input ());
1398 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1402 Articulation_req * a = new Articulation_req;
1403 a->set_mus_property ("articulation-type", $2);
1404 a->set_spot (THIS->here_input ());
1408 duh, junk this syntax from the parser, if possible.
1411 Arpeggio_req *a = new Arpeggio_req;
1412 a->set_spot (THIS->here_input ());
1416 Glissando_req *g = new Glissando_req;
1417 g->set_spot /* No pun intended */ (THIS->here_input ());
1444 | NOTENAME_PITCH sup_quotes {
1445 Pitch p = *unsmob_pitch ($1);
1447 $$ = p.smobbed_copy ();
1449 | NOTENAME_PITCH sub_quotes {
1450 Pitch p =* unsmob_pitch ($1);
1453 $$ = p.smobbed_copy ();
1466 | TONICNAME_PITCH sup_quotes {
1467 Pitch p = *unsmob_pitch ($1);
1469 $$ = p.smobbed_copy ();
1471 | TONICNAME_PITCH sub_quotes {
1472 Pitch p =* unsmob_pitch ($1);
1475 $$ = p.smobbed_copy ();
1490 PITCH embedded_scm {
1492 if (!unsmob_pitch ($2)) {
1493 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1494 $$ = Pitch ().smobbed_copy ();
1500 DURATION embedded_scm {
1502 if (!unsmob_duration ($2))
1504 THIS->parser_error (_ ("Must have duration object"));
1505 $$ = Duration ().smobbed_copy ();
1512 if (!THIS->lexer_p_->lyric_state_b ())
1513 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1514 $$ = new Extender_req;
1520 if (!THIS->lexer_p_->lyric_state_b ())
1521 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1522 $$ = new Hyphen_req;
1527 close_request_parens {
1529 dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
1533 close_request_parens:
1535 Span_req* s= new Span_req;
1537 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1538 s->set_spot (THIS->here_input());
1541 Span_req* s= new Span_req;
1543 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1544 s->set_spot (THIS->here_input());
1547 Span_req*s =new Span_req;
1549 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1550 s->set_spot (THIS->here_input());
1553 Span_req*s =new Span_req;
1555 s->set_mus_property ("span-type", ly_str02scm ("decrescendo"));
1556 s->set_spot (THIS->here_input());
1562 open_request_parens {
1564 dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
1568 open_request_parens:
1570 Span_req *s = new Span_req;
1571 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1572 s->set_spot (THIS->here_input());
1577 Span_req* s= new Span_req;
1579 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1580 s->set_spot (THIS->here_input());
1584 Span_req* s= new Span_req;
1586 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1587 s->set_spot (THIS->here_input());
1593 Text_script_req *t = new Text_script_req;
1594 t->set_mus_property ("text", $1);
1595 t->set_spot (THIS->here_input ());
1599 Text_script_req *t = new Text_script_req;
1600 t->set_mus_property ("text", $1);
1601 t->set_spot (THIS->here_input ());
1605 String ds = to_str ($1);
1606 Text_script_req* t = new Text_script_req;
1607 SCM finger = ly_symbol2scm ("finger");
1608 t->set_mus_property ("text", ly_str02scm (ds.ch_C ()));
1609 t->set_mus_property ("text-type" , finger);
1610 t->set_spot (THIS->here_input ());
1615 script_abbreviation:
1617 $$ = gh_str02scm ("Hat");
1620 $$ = gh_str02scm ("Plus");
1623 $$ = gh_str02scm ("Dash");
1626 $$ = gh_str02scm ("Bar");
1629 $$ = gh_str02scm ("Larger");
1632 $$ = gh_str02scm ("Dot");
1639 | '-' { $$ = CENTER; }
1644 $$ = new Link_array<Request>;
1646 | pre_requests open_request {
1658 multiplied_duration {
1661 | verbose_duration {
1666 optional_notemode_duration:
1668 Duration dd = THIS->default_duration_;
1669 $$ = dd.smobbed_copy ();
1671 THIS->beam_check ($$);
1673 | multiplied_duration {
1675 THIS->default_duration_ = *unsmob_duration ($$);
1677 THIS->beam_check ($$);
1679 | verbose_duration {
1681 THIS->default_duration_ = *unsmob_duration ($$);
1686 bare_unsigned dots {
1688 if (!is_duration_b ($1))
1689 THIS->parser_error (_f ("not a duration: %d", $1));
1693 $$ = Duration (l, $2).smobbed_copy ();
1695 | DURATION_IDENTIFIER dots {
1696 Duration *d =unsmob_duration ($1);
1697 Duration k (d->duration_log (),d->dot_count () + $2);
1698 $$ = k.smobbed_copy ();
1705 multiplied_duration:
1709 | multiplied_duration '*' bare_unsigned {
1710 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1712 | multiplied_duration '*' FRACTION {
1713 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1715 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1720 FRACTION { $$ = $1; }
1721 | UNSIGNED '/' UNSIGNED {
1722 $$ = gh_cons (gh_int2scm ($1), gh_int2scm ($3));
1740 | ':' bare_unsigned {
1741 if (!is_duration_b ($2))
1742 THIS->parser_error (_f ("not a duration: %d", $2));
1761 Bass_figure_req *bfr = new Bass_figure_req;
1762 $$ = bfr->self_scm();
1763 scm_gc_unprotect_object ($$);
1766 Bass_figure_req *bfr = new Bass_figure_req;
1767 $$ = bfr->self_scm();
1769 bfr->set_mus_property ("figure", gh_int2scm ($1));
1771 scm_gc_unprotect_object ($$);
1773 | bass_figure bass_mod {
1774 Music *m = unsmob_music ($1);
1776 SCM salter =m->get_mus_property ("alteration");
1777 int alter = gh_number_p( salter) ? gh_scm2int (salter) : 0;
1778 m->set_mus_property ("alteration",
1779 gh_int2scm (alter + $2));
1781 m->set_mus_property ("alteration", gh_int2scm (0));
1789 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1794 | br_bass_figure ']' {
1796 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1804 | figure_list br_bass_figure {
1805 $$ = gh_cons ($2, $1);
1810 FIGURE_OPEN figure_list FIGURE_CLOSE {
1811 Music * m = new Request_chord (SCM_EOL);
1812 $2 = scm_reverse_x ($2, SCM_EOL);
1813 m->set_mus_property ("elements", $2);
1814 $$ = m->self_scm ();
1825 pitch exclamations questions optional_notemode_duration optional_rest {
1827 Input i = THIS->pop_spot ();
1828 if (!THIS->lexer_p_->note_state_b ())
1829 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1837 n->set_mus_property ("pitch", $1);
1838 n->set_mus_property ("duration", $4);
1842 n->set_mus_property ("cautionary", SCM_BOOL_T);
1843 if ($2 % 2 || $3 % 2)
1844 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1846 Simultaneous_music*v = new Request_chord (SCM_EOL);
1847 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1853 | figure_spec optional_notemode_duration {
1854 Music * m = unsmob_music ($1);
1855 Input i = THIS->pop_spot ();
1857 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1859 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1863 | RESTNAME optional_notemode_duration {
1865 Input i = THIS->pop_spot ();
1866 SCM e = SCM_UNDEFINED;
1867 if (ly_scm2string ($1) =="s") {
1869 Skip_req * skip_p = new Skip_req;
1870 skip_p->set_mus_property ("duration" ,$2);
1871 skip_p->set_spot (i);
1872 e = skip_p->self_scm ();
1875 Rest_req * rest_req_p = new Rest_req;
1876 rest_req_p->set_mus_property ("duration", $2);
1877 rest_req_p->set_spot (i);
1878 e = rest_req_p->self_scm ();
1880 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1881 velt_p-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1882 velt_p->set_spot (i);
1886 | MULTI_MEASURE_REST optional_notemode_duration {
1887 Input i = THIS->pop_spot ();
1889 Skip_req * sk = new Skip_req;
1890 sk->set_mus_property ("duration", $2);
1891 Span_req *sp1 = new Span_req;
1892 Span_req *sp2 = new Span_req;
1893 sp1-> set_span_dir ( START);
1894 sp2-> set_span_dir ( STOP);
1895 SCM r = ly_str02scm ("rest");
1896 sp1->set_mus_property ("span-type", r);
1897 sp2->set_mus_property ("span-type", r);
1899 Request_chord * rqc1 = new Request_chord (SCM_EOL);
1900 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1901 Request_chord * rqc2 = new Request_chord (SCM_EOL);
1902 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1903 Request_chord * rqc3 = new Request_chord (SCM_EOL);
1904 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1906 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1908 $$ = new Sequential_music (SCM_EOL);
1909 $$->set_mus_property ("elements", ms);
1911 | STRING optional_notemode_duration {
1912 Input i = THIS->pop_spot ();
1914 Lyric_req* lreq_p = new Lyric_req;
1915 lreq_p->set_mus_property ("text", $1);
1916 lreq_p->set_mus_property ("duration",$2);
1917 lreq_p->set_spot (i);
1918 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1919 velt_p->set_mus_property ("elements", scm_list_n (lreq_p->self_scm (), SCM_UNDEFINED));
1924 Input i = THIS->pop_spot ();
1926 if (!THIS->lexer_p_->chord_state_b ())
1927 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1934 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1935 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1936 $$->set_spot (THIS->here_input ());
1943 | CHORD_COLON chord_notes {
1952 | chord_notes '.' chord_step {
1953 $$ = gh_append2 ($$, $3);
1961 | CHORD_CARET chord_notes {
1971 | '/' steno_tonic_pitch {
1980 | CHORD_BASS steno_tonic_pitch {
1987 $$ = gh_cons ($1, SCM_EOL);
1989 | CHORDMODIFIER_PITCH {
1990 $$ = gh_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
1992 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
1993 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2001 m.notename_i_ = ($1 - 1) % 7;
2002 m.octave_i_ = $1 > 7 ? 1 : 0;
2003 m.alteration_i_ = 0;
2005 $$ = m.smobbed_copy ();
2007 | bare_unsigned '+' {
2009 m.notename_i_ = ($1 - 1) % 7;
2010 m.octave_i_ = $1 > 7 ? 1 : 0;
2011 m.alteration_i_ = 1;
2014 $$ = m.smobbed_copy ();
2016 | bare_unsigned CHORD_MINUS {
2018 m.notename_i_ = ($1 - 1) % 7;
2019 m.octave_i_ = $1 > 7 ? 1 : 0;
2020 m.alteration_i_ = -1;
2022 $$ = m.smobbed_copy ();
2030 number_expression '+' number_term {
2031 $$ = scm_sum ($1, $3);
2033 | number_expression '-' number_term {
2034 $$ = scm_difference ($1, $3);
2043 | number_factor '*' number_factor {
2044 $$ = scm_product ($1, $3);
2046 | number_factor '/' number_factor {
2047 $$ = scm_divide ($1, $3);
2052 '(' number_expression ')' {
2055 | '-' number_factor { /* %prec UNARY_MINUS */
2056 $$ = scm_difference ($2, SCM_UNDEFINED);
2064 $$ = gh_int2scm ($1);
2069 | NUMBER_IDENTIFIER {
2073 $$ = gh_double2scm (gh_scm2double ($1) CM );
2076 $$ = gh_double2scm (gh_scm2double ($1) PT);
2079 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2082 $$ = gh_double2scm (gh_scm2double ($1) MM);
2085 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2101 if (scm_integer_p ($1) == SCM_BOOL_T)
2103 int k = gh_scm2int ($1);
2107 THIS->parser_error (_ ("need integer number arg"));
2121 | STRING_IDENTIFIER {
2124 | string '+' string {
2125 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2132 | exclamations '!' { $$ ++; }
2137 | questions '?' { $$ ++; }
2144 My_lily_parser::set_yydebug (bool )
2151 extern My_lily_parser * current_parser;
2154 My_lily_parser::do_yyparse ()
2157 current_parser = this;;
2158 yyparse ((void*)this);
2163 Should make this optional? It will also complain when you do
2167 which is entirely legitimate.
2169 Or we can scrap it. Barchecks should detect wrong durations, and
2170 skipTypesetting speeds it up a lot.
2173 My_lily_parser::beam_check (SCM dur)
2175 Duration *d = unsmob_duration (dur);
2176 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2178 Music * m = unsmob_music (last_beam_start_);
2179 m->origin ()->warning (_("Suspect duration found following this beam"));
2181 last_beam_start_ = SCM_EOL;