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
30 #include "translator-def.hh"
31 #include "lily-guile.hh"
32 #include "change-iterator.hh"
34 #include "my-lily-lexer.hh"
35 #include "paper-def.hh"
36 #include "midi-def.hh"
38 #include "file-path.hh"
40 #include "dimensions.hh"
41 #include "command-request.hh"
42 #include "musical-request.hh"
43 #include "my-lily-parser.hh"
44 #include "context-specced-music.hh"
46 #include "music-list.hh"
47 #include "output-property-music-iterator.hh"
48 #include "property-iterator.hh"
49 #include "file-results.hh"
51 #include "relative-music.hh"
52 #include "lyric-combine-music.hh"
53 #include "transposed-music.hh"
54 #include "time-scaled-music.hh"
55 #include "repeated-music.hh"
56 #include "untransposable-music.hh"
57 #include "lilypond-input-version.hh"
58 #include "grace-music.hh"
59 #include "part-combine-music.hh"
60 #include "scm-hash.hh"
61 #include "auto-change-iterator.hh"
62 #include "un-relativable-music.hh"
66 regular_identifier_b (SCM id)
68 String str = ly_scm2string (id);
69 char const *s = str.ch_C() ;
74 v = v && isalpha (*s);
82 set_property_music (SCM sym, SCM value)
84 Music * p = new Music (SCM_EOL);
85 p->set_mus_property ("symbol", sym);
86 p->set_mus_property ("iterator-ctor",
87 Property_iterator::constructor_cxx_function);
89 p->set_mus_property ("value", value);
96 return t && t == 1 << intlog2 (t);
100 set_music_properties (Music *p, SCM a)
102 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
104 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
114 // needed for bison.simple's malloc () and free ()
121 #define YYERROR_VERBOSE 1
123 #define YYPARSE_PARAM my_lily_parser_l
124 #define YYLEX_PARAM my_lily_parser_l
126 ((My_lily_parser *) my_lily_parser_l)
128 #define yyerror THIS->parser_error
129 #define ARRAY_SIZE(a,s) if (a.size () != s) THIS->parser_error (_f ("Expecting %d arguments", s))
133 /* We use SCMs to do strings, because it saves us the trouble of
134 deleting them. Let's hope that a stack overflow doesnt trigger a move
135 of the parse stack onto the heap. */
140 Link_array<Request> *reqvec;
142 String *string; // needed by the lexer as temporary scratch area.
145 Scheme_hash_table *scmhash;
146 Music_output_def * outputdef;
158 yylex (YYSTYPE *s, void * v_l)
160 My_lily_parser *pars_l = (My_lily_parser*) v_l;
161 My_lily_lexer * lex_l = pars_l->lexer_p_;
163 lex_l->lexval_l = (void*) s;
164 return lex_l->yylex ();
172 /* tokens which are not keywords */
182 %token CHORDMODIFIERS
190 %token GROBDESCRIPTIONS
196 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
197 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
207 %token MULTI_MEASURE_REST
219 %token OVERRIDE SET REVERT
232 %token COMMANDSPANREQUEST
234 %token OUTPUTPROPERTY
245 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
246 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
248 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET
252 %type <i> exclamations questions dots optional_rest
253 %type <i> bass_number bass_mod
254 %type <scm> br_bass_figure bass_figure figure_list figure_spec
256 %token <scm> NOTENAME_PITCH
257 %token <scm> TONICNAME_PITCH
258 %token <scm> CHORDMODIFIER_PITCH
259 %token <scm> DURATION_IDENTIFIER
260 %token <scm> FRACTION
261 %token <id> IDENTIFIER
264 %token <scm> SCORE_IDENTIFIER
265 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
267 %token <scm> NUMBER_IDENTIFIER
268 %token <scm> REQUEST_IDENTIFIER
269 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
270 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
271 %token <scm> RESTNAME
277 %type <outputdef> output_def
278 %type <scmhash> lilypond_header lilypond_header_body
279 %type <request> open_request_parens close_request_parens open_request close_request
280 %type <request> request_with_dir request_that_take_dir verbose_request
281 %type <i> sub_quotes sup_quotes
282 %type <music> simple_element request_chord command_element Simple_music Composite_music
283 %type <music> Repeated_music
284 %type <scm> Alternative_music
285 %type <i> tremolo_type
286 %type <i> bare_int bare_unsigned
289 %type <scm> identifier_init
291 %type <scm> steno_duration optional_notemode_duration multiplied_duration
292 %type <scm> verbose_duration
294 %type <reqvec> pre_requests post_requests
295 %type <request> gen_text_def
296 %type <scm> steno_pitch pitch absolute_pitch
297 %type <scm> explicit_pitch steno_tonic_pitch
299 %type <scm> chord_additions chord_subtractions chord_notes chord_step
301 %type <scm> chord_note chord_inversion chord_bass
302 %type <scm> duration_length fraction
304 %type <scm> embedded_scm scalar
305 %type <music> Music Sequential_music Simultaneous_music
306 %type <music> relative_music re_rhythmed_music part_combined_music
307 %type <music> property_def translator_change
308 %type <scm> Music_list
309 %type <outputdef> music_output_def_body
310 %type <request> shorthand_command_req
311 %type <request> post_request
312 %type <music> command_req verbose_command_req
313 %type <request> extender_req
314 %type <request> hyphen_req
315 %type <scm> string bare_number number_expression number_term number_factor
317 %type <score> score_block score_body
319 %type <scm> translator_spec_block translator_spec_body
320 %type <tempo> tempo_request
321 %type <scm> notenames_body notenames_block chordmodifiers_block
322 %type <scm> script_abbreviation
328 /* We don't assign precedence to / and *, because we might need varied
329 prec levels in different prods */
335 lilypond: /* empty */
336 | lilypond toplevel_expression {}
337 | lilypond assignment { }
339 THIS->error_level_i_ = 1;
342 THIS->error_level_i_ = 1;
348 THIS->lexer_p_->pitchname_tab_ = $1;
350 | chordmodifiers_block {
351 THIS->lexer_p_->chordmodifier_tab_ = $1;
355 scm_gc_unprotect_object (global_header_p->self_scm ());
356 global_header_p = $1;
359 score_global_array.push ($1);
362 if (dynamic_cast<Paper_def*> ($1))
363 THIS->lexer_p_->set_identifier (gh_str02scm ("$defaultpaper"), $1->self_scm ());
364 else if (dynamic_cast<Midi_def*> ($1))
365 THIS->lexer_p_->set_identifier (gh_str02scm ("$defaultmidi"), $1->self_scm ());
378 chordmodifiers_block:
379 CHORDMODIFIERS notenames_body { $$ = $2; }
383 PITCHNAMES notenames_body { $$ = $2; }
388 int i = scm_ilength ($1);
390 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
391 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
392 SCM pt = ly_cdar (s);
393 if (!unsmob_pitch (pt))
394 THIS->parser_error ("Need pitch object.");
396 scm_hashq_set_x (tab, ly_caar (s), pt);
403 lilypond_header_body:
405 $$ = new Scheme_hash_table;
406 THIS->lexer_p_-> scope_l_arr_.push ($$);
408 | lilypond_header_body assignment {
414 HEADER '{' lilypond_header_body '}' {
416 THIS->lexer_p_->scope_l_arr_.pop ();
428 /* cont */ '=' identifier_init {
431 Should find generic way of associating input with objects.
433 Input ip = THIS->pop_spot ();
435 if (! regular_identifier_b ($1))
437 ip.warning (_ ("Identifier should have alphabetic characters only"));
440 THIS->lexer_p_->set_identifier ($1, $4);
443 TODO: devise standard for protection in parser.
445 The parser stack lives on the C-stack, which means that
446 all objects can be unprotected as soon as they're here.
456 $$ = $1->self_scm ();
457 scm_gc_unprotect_object ($$);
460 $$ = $1->self_scm ();
461 scm_gc_unprotect_object ($$);
463 | translator_spec_block {
467 $$ = $1->self_scm ();
468 scm_gc_unprotect_object ($$);
471 $$ = $1->self_scm ();
472 scm_gc_unprotect_object ($$);
477 | number_expression {
488 translator_spec_block:
489 TRANSLATOR '{' translator_spec_body '}'
495 translator_spec_body:
496 TRANSLATOR_IDENTIFIER {
497 $$ = unsmob_translator_def ($1)->clone_scm ();
498 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
501 $$ = Translator_def::make_scm ();
502 Translator_def*td = unsmob_translator_def ($$);
503 td->translator_group_type_ = $2;
504 td->set_spot (THIS->here_input ());
506 | translator_spec_body STRING '=' embedded_scm {
507 unsmob_translator_def ($$)->add_property_assign ($2, $4);
509 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
510 unsmob_translator_def ($$)
511 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
513 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
514 unsmob_translator_def ($$)
515 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
517 | translator_spec_body STRING REVERT embedded_scm {
518 unsmob_translator_def ($$)->add_pop_property (
519 scm_string_to_symbol ($2), $4);
521 | translator_spec_body NAME STRING {
522 unsmob_translator_def ($$)->type_name_ = $3;
524 | translator_spec_body CONSISTS STRING {
525 unsmob_translator_def ($$)->add_element ($3);
527 | translator_spec_body ALIAS STRING {
528 Translator_def*td = unsmob_translator_def ($$);
529 td->type_aliases_ = gh_cons ($3, td->type_aliases_);
531 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
532 Translator_def*td = unsmob_translator_def($$);
533 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
534 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
535 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
537 | translator_spec_body CONSISTSEND STRING {
538 unsmob_translator_def ($$)->add_last_element ( $3);
540 | translator_spec_body ACCEPTS STRING {
541 unsmob_translator_def ($$)->set_acceptor ($3,true);
543 | translator_spec_body DENIES STRING {
544 unsmob_translator_def ($$)->set_acceptor ($3,false);
546 | translator_spec_body REMOVE STRING {
547 unsmob_translator_def ($$)->remove_element ($3);
558 /*cont*/ '{' score_body '}' {
561 if (!$$->def_p_arr_.size ())
563 Music_output_def *id =
564 unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
565 $$->add_output (id ? id->clone () : new Paper_def );
574 $$->set_spot (THIS->here_input ());
575 SCM m = $1->self_scm ();
576 scm_gc_unprotect_object (m);
581 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
582 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
583 m = gh_call1 (gh_car (check_funcs), m);
588 $$ = new Score (*unsmob_score ($1));
589 $$->set_spot (THIS->here_input ());
591 | score_body lilypond_header {
592 scm_gc_unprotect_object ($2->self_scm ());
595 | score_body output_def {
608 music_output_def_body '}' {
610 THIS-> lexer_p_-> scope_l_arr_.pop ();
614 music_output_def_body:
616 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultmidi"));
621 p = dynamic_cast<Midi_def*> (id->clone ());
626 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
629 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
632 p = dynamic_cast<Paper_def*> (id->clone ());
635 THIS-> lexer_p_-> scope_l_arr_.push (p->variable_tab_);
638 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
639 Music_output_def *p = unsmob_music_output_def ($3);
641 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
644 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
645 Music_output_def *p = unsmob_music_output_def ($3);
648 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
651 | music_output_def_body assignment {
654 | music_output_def_body translator_spec_block {
655 $$->assign_translator ($2);
657 | music_output_def_body STYLESHEET embedded_scm {
658 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
660 | music_output_def_body tempo_request {
662 junk this ? there already is tempo stuff in
665 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
666 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
667 Midi_def * md = dynamic_cast<Midi_def*> ($$);
669 md->set_tempo (d->length_mom (), m);
671 | music_output_def_body error {
677 TEMPO steno_duration '=' bare_unsigned {
679 $$->set_mus_property ("duration", $2);
680 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
685 The representation of a list is the
689 to have efficient append.
691 Music_list: /* empty */ {
692 $$ = gh_cons (SCM_EOL, SCM_EOL);
696 SCM c = gh_cons ($2->self_scm (), SCM_EOL);
697 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
698 if (gh_pair_p (ly_cdr (s)))
699 gh_set_cdr_x (ly_cdr (s), c); /* append */
701 gh_set_car_x (s, c); /* set first cons */
702 gh_set_cdr_x (s, c) ; /* remember last cell */
718 | ALTERNATIVE '{' Music_list '}' {
724 REPEAT string bare_unsigned Music Alternative_music
728 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
729 if (times < scm_ilength (alts)) {
730 unsmob_music (gh_car (alts))
731 ->origin ()->warning (
732 _("More alternatives than repeats. Junking excess alternatives."));
733 alts = ly_truncate_list (times, alts);
736 Repeated_music * r = new Repeated_music (SCM_EOL);
739 r-> set_mus_property ("element", beg->self_scm ());
740 scm_gc_unprotect_object (beg->self_scm ());
742 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
744 r-> set_mus_property ("elements",alts);
745 SCM func = scm_primitive_eval (ly_symbol2scm ("repeat-name-to-ctor"));
746 SCM result = gh_call1 (func, $2);
748 set_music_properties (r, result);
750 r->set_spot (*$4->origin ());
756 SEQUENTIAL '{' Music_list '}' {
757 $$ = new Sequential_music (SCM_EOL);
758 $$->set_mus_property ("elements", ly_car ($3));
759 $$->set_spot(THIS->here_input());
761 | '{' Music_list '}' {
762 $$ = new Sequential_music (SCM_EOL);
763 $$->set_mus_property ("elements", ly_car ($2));
764 $$->set_spot(THIS->here_input());
769 SIMULTANEOUS '{' Music_list '}'{
770 $$ = new Simultaneous_music (SCM_EOL);
771 $$->set_mus_property ("elements", ly_car ($3));
772 $$->set_spot(THIS->here_input());
775 | '<' Music_list '>' {
776 $$ = new Simultaneous_music (SCM_EOL);
777 $$->set_mus_property ("elements", ly_car ($2));
778 $$->set_spot(THIS->here_input());
783 request_chord { $$ = $1; }
784 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
786 if (!gh_symbol_p ($3))
788 THIS->parser_error (_ ("Second argument must be a symbol"));
790 /*hould check # args */
791 if (!gh_procedure_p (pred))
793 THIS->parser_error (_ ("First argument must be a procedure taking 1 argument"));
796 Music *m = new Music (SCM_EOL);
797 m->set_mus_property ("predicate", pred);
798 m->set_mus_property ("grob-property", $3);
799 m->set_mus_property ("grob-value", $5);
800 m->set_mus_property ("iterator-ctor",
801 Output_property_music_iterator::constructor_cxx_function);
806 $$ = unsmob_music ($1)->clone ();
808 $$->set_spot (THIS->here_input());
816 CONTEXT STRING Music {
817 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
818 csm->set_mus_property ("element", $3->self_scm ());
819 scm_gc_unprotect_object ($3->self_scm ());
821 csm->set_mus_property ("context-type",$2);
822 csm->set_mus_property ("context-id", ly_str02scm (""));
826 | AUTOCHANGE STRING Music {
827 Music * chm = new Music_wrapper (SCM_EOL);
828 chm->set_mus_property ("element", $3->self_scm ());
829 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_cxx_function);
831 scm_gc_unprotect_object ($3->self_scm ());
832 chm->set_mus_property ("what", $2);
835 chm->set_spot (*$3->origin ());
840 The other version is for easier debugging of
841 Sequential_music_iterator in combination with grace notes.
844 SCM start = THIS->lexer_p_->lookup_identifier ("startGraceMusic");
845 SCM stop = THIS->lexer_p_->lookup_identifier ("stopGraceMusic");
846 Music *startm = unsmob_music (start);
847 Music *stopm = unsmob_music (stop);
851 stopm = stopm->clone ();
852 ms = gh_cons (stopm->self_scm (), ms);
853 scm_gc_unprotect_object (stopm->self_scm ());
855 ms = gh_cons ($2->self_scm (), ms);
856 scm_gc_unprotect_object ($2->self_scm());
858 startm = startm->clone ();
859 ms = gh_cons (startm->self_scm () , ms);
860 scm_gc_unprotect_object (startm->self_scm ());
863 Music* seq = new Sequential_music (SCM_EOL);
864 seq->set_mus_property ("elements", ms);
866 $$ = new Grace_music (SCM_EOL);
867 $$->set_mus_property ("element", seq->self_scm ());
868 scm_gc_unprotect_object (seq->self_scm ());
870 $$ = new Grace_music (SCM_EOL);
871 $$->set_mus_property ("element", $2->self_scm ());
872 scm_gc_unprotect_object ($2->self_scm ());
875 | CONTEXT string '=' string Music {
876 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
877 csm->set_mus_property ("element", $5->self_scm ());
878 scm_gc_unprotect_object ($5->self_scm ());
880 csm->set_mus_property ("context-type", $2);
881 csm->set_mus_property ("context-id", $4);
892 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
894 $$ = new Time_scaled_music (SCM_EOL);
895 $$->set_spot (THIS->pop_spot ());
898 $$->set_mus_property ("element", mp->self_scm ());
899 scm_gc_unprotect_object (mp->self_scm ());
900 $$->set_mus_property ("numerator", gh_int2scm (n));
901 $$->set_mus_property ("denominator", gh_int2scm (d));
902 $$->compress (Moment (Rational (n,d)));
905 | Repeated_music { $$ = $1; }
906 | Simultaneous_music { $$ = $1; }
907 | Sequential_music { $$ = $1; }
908 | TRANSPOSE pitch Music {
909 $$ = new Transposed_music (SCM_EOL);
911 Pitch pit = *unsmob_pitch ($2);
914 $$->set_mus_property ("element", p->self_scm ());
915 scm_gc_unprotect_object (p->self_scm ());
917 | TRANSPOSE steno_tonic_pitch Music {
918 $$ = new Transposed_music (SCM_EOL);
920 Pitch pit = *unsmob_pitch ($2);
923 $$->set_mus_property ("element", p->self_scm ());
924 scm_gc_unprotect_object (p->self_scm ());
927 | APPLY embedded_scm Music {
928 SCM ret = gh_call1 ($2, $3->self_scm ());
929 Music *m = unsmob_music (ret);
931 THIS->parser_error ("\\apply must return a Music");
932 m = new Music (SCM_EOL);
937 { THIS->lexer_p_->push_note_state (); }
940 THIS->lexer_p_->pop_state ();
943 { THIS->lexer_p_->push_figuredbass_state (); }
946 Music * chm = new Untransposable_music () ;
947 chm->set_mus_property ("element", $3->self_scm ());
949 scm_gc_unprotect_object ($3->self_scm());
951 THIS->lexer_p_->pop_state ();
954 { THIS->lexer_p_->push_chord_state (); }
957 Music * chm = new Un_relativable_music ;
958 chm->set_mus_property ("element", $3->self_scm ());
959 scm_gc_unprotect_object ($3->self_scm());
962 THIS->lexer_p_->pop_state ();
965 { THIS->lexer_p_->push_lyric_state (); }
969 THIS->lexer_p_->pop_state ();
971 | relative_music { $$ = $1; }
972 | re_rhythmed_music { $$ = $1; }
973 | part_combined_music { $$ = $1; }
977 RELATIVE absolute_pitch Music {
979 Pitch pit = *unsmob_pitch ($2);
980 $$ = new Relative_octave_music (SCM_EOL);
982 $$->set_mus_property ("element", p->self_scm ());
983 scm_gc_unprotect_object (p->self_scm ());
985 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
991 ADDLYRICS Music Music {
992 Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
993 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
994 scm_gc_unprotect_object ($3->self_scm ());
995 scm_gc_unprotect_object ($2->self_scm ());
1000 part_combined_music:
1001 PARTCOMBINE STRING Music Music {
1002 Part_combine_music * p = new Part_combine_music (SCM_EOL);
1004 p->set_mus_property ("what", $2);
1005 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1007 scm_gc_unprotect_object ($3->self_scm ());
1008 scm_gc_unprotect_object ($4->self_scm ());
1015 TRANSLATOR STRING '=' STRING {
1016 Music * t = new Music (SCM_EOL);
1017 t->set_mus_property ("iterator-ctor",
1018 Change_iterator::constructor_cxx_function);
1019 t-> set_mus_property ("change-to-type", $2);
1020 t-> set_mus_property ("change-to-id", $4);
1023 $$->set_spot (THIS->here_input ());
1028 PROPERTY STRING '.' STRING '=' scalar {
1030 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1031 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1033 csm->set_mus_property ("element", t->self_scm ());
1034 scm_gc_unprotect_object (t->self_scm ());
1037 $$->set_spot (THIS->here_input ());
1039 csm-> set_mus_property ("context-type", $2);
1041 | PROPERTY STRING '.' STRING UNSET {
1042 Music *t = new Music (SCM_EOL);
1044 t->set_mus_property ("iterator-ctor",
1045 Property_unset_iterator::constructor_cxx_function);
1046 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1048 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1049 csm->set_mus_property ("element", t->self_scm ());
1050 scm_gc_unprotect_object (t->self_scm ());
1053 $$->set_spot (THIS->here_input ());
1055 csm-> set_mus_property ("context-type", $2);
1057 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1058 Music *t = new Music (SCM_EOL);
1059 t->set_mus_property ("iterator-ctor",
1060 Push_property_iterator::constructor_cxx_function);
1061 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1062 t->set_mus_property ("pop-first", SCM_BOOL_T);
1063 t->set_mus_property ("grob-property", $6);
1064 t->set_mus_property ("grob-value", $8);
1065 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1066 csm->set_mus_property ("element", t->self_scm ());
1067 scm_gc_unprotect_object (t->self_scm ());
1069 $$->set_spot (THIS->here_input ());
1071 csm-> set_mus_property ("context-type", $2);
1073 | PROPERTY STRING '.' STRING OVERRIDE embedded_scm '=' embedded_scm {
1074 Music *t = new Music (SCM_EOL);
1075 t->set_mus_property ("iterator-ctor",
1076 Push_property_iterator::constructor_cxx_function);
1077 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1078 t->set_mus_property ("grob-property", $6);
1079 t->set_mus_property ("grob-value", $8);
1080 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1081 csm->set_mus_property ("element", t->self_scm ());
1082 scm_gc_unprotect_object (t->self_scm ());
1085 $$->set_spot (THIS->here_input ());
1087 csm-> set_mus_property ("context-type", $2);
1089 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1090 Music *t = new Music (SCM_EOL);
1091 t->set_mus_property ("iterator-ctor",
1092 Pop_property_iterator::constructor_cxx_function);
1093 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1094 t->set_mus_property ("grob-property", $6);
1096 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1097 csm->set_mus_property ("element", t->self_scm ());
1098 scm_gc_unprotect_object (t->self_scm ());
1101 $$->set_spot (THIS->here_input ());
1103 csm-> set_mus_property ("context-type", $2);
1109 | bare_int { $$ = gh_int2scm ($1); }
1110 | embedded_scm { $$ = $1; }
1117 } /*cont */ simple_element post_requests {
1118 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1121 for (int i=0; i < $1->size (); i++) {
1122 Music * m = $1->elem (i);
1123 l->append_music (m);
1135 $$ = new Request_chord (SCM_EOL);
1136 $$->set_mus_property ("elements", gh_cons ($1->self_scm (), SCM_EOL));
1137 scm_gc_unprotect_object ($1->self_scm());
1139 $$-> set_spot (THIS->here_input ());
1140 $1-> set_spot (THIS->here_input ());
1143 Span_req *l = new Span_req;
1144 l->set_span_dir (START);
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 scm_gc_unprotect_object (l->self_scm());
1151 $$->set_spot (THIS->here_input ());
1154 Span_req *l = new Span_req;
1155 l->set_span_dir (STOP);
1156 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1157 l->set_spot (THIS->here_input ());
1159 $$ = new Request_chord (SCM_EOL);
1160 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1161 $$->set_spot (THIS->here_input ());
1162 scm_gc_unprotect_object (l->self_scm());
1166 $$ = new Music (gh_list (gh_cons (ly_symbol2scm ("name"), ly_symbol2scm ("separator")), SCM_UNDEFINED));
1167 $$->set_spot (THIS->here_input ());
1171 extern Music * get_barcheck();
1172 $$ = get_barcheck ();
1173 $$->set_spot (THIS->here_input ());
1176 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1178 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
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", ly_str02scm ("Score"));
1187 | PARTIAL duration_length {
1188 Moment m = - unsmob_duration ($2)->length_mom ();
1189 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1191 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1192 sp->set_mus_property ("element", p->self_scm ());
1193 scm_gc_unprotect_object (p->self_scm ());
1196 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1199 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1200 SCM result = gh_call1 (func, $2);
1203 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1204 Music * p = new Music (SCM_EOL);
1205 set_music_properties (p, ly_car (s));
1206 l = gh_cons (p->self_scm (), l);
1207 scm_gc_unprotect_object (p->self_scm ());
1209 Sequential_music * seq = new Sequential_music (SCM_EOL);
1210 seq->set_mus_property ("elements", l);
1212 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1213 sp->set_mus_property ("element", seq->self_scm ());
1214 scm_gc_unprotect_object (seq->self_scm ());
1217 sp-> set_mus_property ("context-type", ly_str02scm ("Staff"));
1220 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1222 int l = gh_scm2int (ly_car ($2));
1223 int o = gh_scm2int (ly_cdr ($2));
1225 Moment one_beat = Moment (1)/Moment (o);
1226 Moment len = Moment (l) * one_beat;
1229 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1230 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1232 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1233 Sequential_music *seq = new Sequential_music (SCM_EOL);
1234 seq->set_mus_property ("elements", list);
1237 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1238 sp->set_mus_property ("element", seq->self_scm ());
1242 scm_gc_unprotect_object (p3->self_scm ());
1243 scm_gc_unprotect_object (p2->self_scm ());
1244 scm_gc_unprotect_object (p1->self_scm ());
1245 scm_gc_unprotect_object (seq->self_scm ());
1250 TODO: should make alias TimingContext for Score
1253 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1258 shorthand_command_req { $$ = $1; }
1259 | verbose_command_req { $$ = $1; }
1262 shorthand_command_req:
1273 Span_req*b= new Span_req;
1274 b->set_span_dir (START);
1275 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1279 THIS->last_beam_start_ = b->self_scm ();
1282 Span_req*b= new Span_req;
1283 b->set_span_dir ( STOP);
1284 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1288 $$ = new Breathing_sign_req;
1291 $$ = new Porrectus_req;
1295 verbose_command_req:
1296 COMMANDSPANREQUEST bare_int STRING { /*TODO: junkme */
1297 Span_req * sp_p = new Span_req;
1298 sp_p-> set_span_dir ( Direction ($2));
1299 sp_p->set_mus_property ("span-type",$3);
1300 sp_p->set_spot (THIS->here_input ());
1304 Mark_req * m = new Mark_req;
1308 Mark_req *m = new Mark_req;
1309 m->set_mus_property ("label", $2);
1314 Break_req * b = new Break_req;
1316 if (!gh_number_p (s))
1319 b->set_mus_property ("penalty", s);
1320 b->set_spot (THIS->here_input ());
1323 | SKIP duration_length {
1324 Skip_req * skip_p = new Skip_req;
1325 skip_p->set_mus_property ("duration", $2);
1333 Key_change_req *key_p= new Key_change_req;
1336 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1337 Key_change_req *key_p= new Key_change_req;
1339 key_p->set_mus_property ("pitch-alist", $3);
1340 ((Music*)key_p)->transpose (* unsmob_pitch ($2));
1347 $$ = new Link_array<Request>;
1349 | post_requests post_request {
1350 $2->set_spot (THIS->here_input ());
1362 request_that_take_dir:
1365 | script_abbreviation {
1366 SCM s = THIS->lexer_p_->lookup_identifier ("dash" + ly_scm2string ($1));
1367 Articulation_req *a = new Articulation_req;
1368 if (gh_string_p (s))
1369 a->set_mus_property ("articulation-type", s);
1370 else THIS->parser_error (_ ("Expecting string as script definition"));
1376 script_dir request_that_take_dir {
1377 if (Script_req * gs = dynamic_cast<Script_req*> ($2))
1378 gs->set_direction (Direction ($1));
1380 $2->origin ()->warning (_ ("Can't specify direction for this request"));
1386 REQUEST_IDENTIFIER {
1387 $$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
1388 $$->set_spot (THIS->here_input ());
1390 | DYNAMICSCRIPT embedded_scm {
1392 TODO: junkme, use text-type == dynamic
1394 Text_script_req *d = new Text_script_req;
1395 SCM dyn = ly_symbol2scm ("dynamic");
1396 d->set_mus_property ("text-type" , dyn);
1397 d->set_mus_property ("text", $2);
1398 d->set_spot (THIS->here_input ());
1401 | SPANREQUEST bare_int STRING {
1402 Span_req * sp_p = new Span_req;
1403 sp_p->set_span_dir ( Direction ($2));
1404 sp_p->set_mus_property ("span-type", $3);
1405 sp_p->set_spot (THIS->here_input ());
1409 Tremolo_req* a = new Tremolo_req;
1410 a->set_spot (THIS->here_input ());
1411 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1415 Articulation_req * a = new Articulation_req;
1416 a->set_mus_property ("articulation-type", $2);
1417 a->set_spot (THIS->here_input ());
1421 duh, junk this syntax from the parser, if possible.
1424 Arpeggio_req *a = new Arpeggio_req;
1425 a->set_spot (THIS->here_input ());
1429 Glissando_req *g = new Glissando_req;
1430 g->set_spot /* No pun intended */ (THIS->here_input ());
1457 | NOTENAME_PITCH sup_quotes {
1458 Pitch p = *unsmob_pitch ($1);
1460 $$ = p.smobbed_copy ();
1462 | NOTENAME_PITCH sub_quotes {
1463 Pitch p =* unsmob_pitch ($1);
1466 $$ = p.smobbed_copy ();
1479 | TONICNAME_PITCH sup_quotes {
1480 Pitch p = *unsmob_pitch ($1);
1482 $$ = p.smobbed_copy ();
1484 | TONICNAME_PITCH sub_quotes {
1485 Pitch p =* unsmob_pitch ($1);
1488 $$ = p.smobbed_copy ();
1503 PITCH embedded_scm {
1505 if (!unsmob_pitch ($2)) {
1506 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1507 $$ = Pitch ().smobbed_copy ();
1513 DURATION embedded_scm {
1515 if (!unsmob_duration ($2))
1517 THIS->parser_error (_ ("Must have duration object"));
1518 $$ = Duration ().smobbed_copy ();
1525 if (!THIS->lexer_p_->lyric_state_b ())
1526 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1527 $$ = new Extender_req;
1533 if (!THIS->lexer_p_->lyric_state_b ())
1534 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1535 $$ = new Hyphen_req;
1540 close_request_parens {
1542 dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
1546 close_request_parens:
1548 Span_req* s= new Span_req;
1550 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1551 s->set_spot (THIS->here_input());
1554 Span_req* s= new Span_req;
1556 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1557 s->set_spot (THIS->here_input());
1560 Span_req*s =new Span_req;
1562 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1563 s->set_spot (THIS->here_input());
1566 Span_req*s =new Span_req;
1568 s->set_mus_property ("span-type", ly_str02scm ("decrescendo"));
1569 s->set_spot (THIS->here_input());
1575 open_request_parens {
1577 dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
1581 open_request_parens:
1583 Span_req *s = new Span_req;
1584 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1585 s->set_spot (THIS->here_input());
1590 Span_req* s= new Span_req;
1592 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1593 s->set_spot (THIS->here_input());
1597 Span_req* s= new Span_req;
1599 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1600 s->set_spot (THIS->here_input());
1606 Text_script_req *t = new Text_script_req;
1607 t->set_mus_property ("text", $1);
1608 t->set_spot (THIS->here_input ());
1612 Text_script_req *t = new Text_script_req;
1613 t->set_mus_property ("text", $1);
1614 t->set_spot (THIS->here_input ());
1618 String ds = to_str ($1);
1619 Text_script_req* t = new Text_script_req;
1620 SCM finger = ly_symbol2scm ("finger");
1621 t->set_mus_property ("text", ly_str02scm (ds.ch_C ()));
1622 t->set_mus_property ("text-type" , finger);
1623 t->set_spot (THIS->here_input ());
1628 script_abbreviation:
1630 $$ = gh_str02scm ("Hat");
1633 $$ = gh_str02scm ("Plus");
1636 $$ = gh_str02scm ("Dash");
1639 $$ = gh_str02scm ("Bar");
1642 $$ = gh_str02scm ("Larger");
1645 $$ = gh_str02scm ("Dot");
1652 | '-' { $$ = CENTER; }
1657 $$ = new Link_array<Request>;
1659 | pre_requests open_request {
1671 multiplied_duration {
1674 | verbose_duration {
1679 optional_notemode_duration:
1681 Duration dd = THIS->default_duration_;
1682 $$ = dd.smobbed_copy ();
1684 THIS->beam_check ($$);
1686 | multiplied_duration {
1688 THIS->default_duration_ = *unsmob_duration ($$);
1690 THIS->beam_check ($$);
1692 | verbose_duration {
1694 THIS->default_duration_ = *unsmob_duration ($$);
1699 bare_unsigned dots {
1701 if (!is_duration_b ($1))
1702 THIS->parser_error (_f ("not a duration: %d", $1));
1706 $$ = Duration (l, $2).smobbed_copy ();
1708 | DURATION_IDENTIFIER dots {
1709 Duration *d =unsmob_duration ($1);
1710 Duration k (d->duration_log (),d->dot_count () + $2);
1711 $$ = k.smobbed_copy ();
1718 multiplied_duration:
1722 | multiplied_duration '*' bare_unsigned {
1723 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1725 | multiplied_duration '*' FRACTION {
1726 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1728 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1733 FRACTION { $$ = $1; }
1734 | UNSIGNED '/' UNSIGNED {
1735 $$ = gh_cons (gh_int2scm ($1), gh_int2scm ($3));
1753 | ':' bare_unsigned {
1754 if (!is_duration_b ($2))
1755 THIS->parser_error (_f ("not a duration: %d", $2));
1774 Bass_figure_req *bfr = new Bass_figure_req;
1775 $$ = bfr->self_scm();
1776 scm_gc_unprotect_object ($$);
1779 Bass_figure_req *bfr = new Bass_figure_req;
1780 $$ = bfr->self_scm();
1782 bfr->set_mus_property ("figure", gh_int2scm ($1));
1784 scm_gc_unprotect_object ($$);
1786 | bass_figure bass_mod {
1787 Music *m = unsmob_music ($1);
1789 SCM salter =m->get_mus_property ("alteration");
1790 int alter = gh_number_p( salter) ? gh_scm2int (salter) : 0;
1791 m->set_mus_property ("alteration",
1792 gh_int2scm (alter + $2));
1794 m->set_mus_property ("alteration", gh_int2scm (0));
1802 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1807 | br_bass_figure ']' {
1809 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1817 | figure_list br_bass_figure {
1818 $$ = gh_cons ($2, $1);
1823 FIGURE_OPEN figure_list FIGURE_CLOSE {
1824 Music * m = new Request_chord (SCM_EOL);
1825 $2 = scm_reverse_x ($2, SCM_EOL);
1826 m->set_mus_property ("elements", $2);
1827 $$ = m->self_scm ();
1838 pitch exclamations questions optional_notemode_duration optional_rest {
1840 Input i = THIS->pop_spot ();
1841 if (!THIS->lexer_p_->note_state_b ())
1842 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1850 n->set_mus_property ("pitch", $1);
1851 n->set_mus_property ("duration", $4);
1855 n->set_mus_property ("cautionary", SCM_BOOL_T);
1856 if ($2 % 2 || $3 % 2)
1857 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1859 Simultaneous_music*v = new Request_chord (SCM_EOL);
1860 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1861 scm_gc_unprotect_object (n->self_scm());
1867 | figure_spec optional_notemode_duration {
1868 Music * m = unsmob_music ($1);
1869 Input i = THIS->pop_spot ();
1871 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1873 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1877 | RESTNAME optional_notemode_duration {
1879 Input i = THIS->pop_spot ();
1880 SCM e = SCM_UNDEFINED;
1881 if (ly_scm2string ($1) =="s") {
1883 Skip_req * skip_p = new Skip_req;
1884 skip_p->set_mus_property ("duration" ,$2);
1885 skip_p->set_spot (i);
1886 e = skip_p->self_scm ();
1889 Rest_req * rest_req_p = new Rest_req;
1890 rest_req_p->set_mus_property ("duration", $2);
1891 rest_req_p->set_spot (i);
1892 e = rest_req_p->self_scm ();
1894 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1895 velt_p-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1896 velt_p->set_spot (i);
1900 | MULTI_MEASURE_REST optional_notemode_duration {
1901 Input i = THIS->pop_spot ();
1903 Skip_req * sk = new Skip_req;
1904 sk->set_mus_property ("duration", $2);
1905 Span_req *sp1 = new Span_req;
1906 Span_req *sp2 = new Span_req;
1907 sp1-> set_span_dir ( START);
1908 sp2-> set_span_dir ( STOP);
1909 SCM r = ly_str02scm ("rest");
1910 sp1->set_mus_property ("span-type", r);
1911 sp2->set_mus_property ("span-type", r);
1913 Request_chord * rqc1 = new Request_chord (SCM_EOL);
1914 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1915 Request_chord * rqc2 = new Request_chord (SCM_EOL);
1916 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1917 Request_chord * rqc3 = new Request_chord (SCM_EOL);
1918 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1920 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1922 $$ = new Sequential_music (SCM_EOL);
1923 $$->set_mus_property ("elements", ms);
1925 | STRING optional_notemode_duration {
1926 Input i = THIS->pop_spot ();
1928 Lyric_req* lreq_p = new Lyric_req;
1929 lreq_p->set_mus_property ("text", $1);
1930 lreq_p->set_mus_property ("duration",$2);
1931 lreq_p->set_spot (i);
1932 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1933 velt_p->set_mus_property ("elements", scm_list_n (lreq_p->self_scm (), SCM_UNDEFINED));
1938 Input i = THIS->pop_spot ();
1940 if (!THIS->lexer_p_->chord_state_b ())
1941 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1948 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1949 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1950 $$->set_spot (THIS->here_input ());
1957 | CHORD_COLON chord_notes {
1966 | chord_notes '.' chord_step {
1967 $$ = gh_append2 ($$, $3);
1975 | CHORD_CARET chord_notes {
1985 | '/' steno_tonic_pitch {
1994 | CHORD_BASS steno_tonic_pitch {
2001 $$ = gh_cons ($1, SCM_EOL);
2003 | CHORDMODIFIER_PITCH {
2004 $$ = gh_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2006 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2007 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2015 m.notename_i_ = ($1 - 1) % 7;
2016 m.octave_i_ = $1 > 7 ? 1 : 0;
2017 m.alteration_i_ = 0;
2019 $$ = m.smobbed_copy ();
2021 | bare_unsigned '+' {
2023 m.notename_i_ = ($1 - 1) % 7;
2024 m.octave_i_ = $1 > 7 ? 1 : 0;
2025 m.alteration_i_ = 1;
2028 $$ = m.smobbed_copy ();
2030 | bare_unsigned CHORD_MINUS {
2032 m.notename_i_ = ($1 - 1) % 7;
2033 m.octave_i_ = $1 > 7 ? 1 : 0;
2034 m.alteration_i_ = -1;
2036 $$ = m.smobbed_copy ();
2044 number_expression '+' number_term {
2045 $$ = scm_sum ($1, $3);
2047 | number_expression '-' number_term {
2048 $$ = scm_difference ($1, $3);
2057 | number_factor '*' number_factor {
2058 $$ = scm_product ($1, $3);
2060 | number_factor '/' number_factor {
2061 $$ = scm_divide ($1, $3);
2066 '(' number_expression ')' {
2069 | '-' number_factor { /* %prec UNARY_MINUS */
2070 $$ = scm_difference ($2, SCM_UNDEFINED);
2078 $$ = gh_int2scm ($1);
2083 | NUMBER_IDENTIFIER {
2087 $$ = gh_double2scm (gh_scm2double ($1) CM );
2090 $$ = gh_double2scm (gh_scm2double ($1) PT);
2093 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2096 $$ = gh_double2scm (gh_scm2double ($1) MM);
2099 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2115 if (scm_integer_p ($1) == SCM_BOOL_T)
2117 int k = gh_scm2int ($1);
2121 THIS->parser_error (_ ("need integer number arg"));
2135 | STRING_IDENTIFIER {
2138 | string '+' string {
2139 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2146 | exclamations '!' { $$ ++; }
2151 | questions '?' { $$ ++; }
2158 My_lily_parser::set_yydebug (bool )
2165 extern My_lily_parser * current_parser;
2168 My_lily_parser::do_yyparse ()
2171 current_parser = this;;
2172 yyparse ((void*)this);
2177 Should make this optional? It will also complain when you do
2181 which is entirely legitimate.
2183 Or we can scrap it. Barchecks should detect wrong durations, and
2184 skipTypesetting speeds it up a lot.
2187 My_lily_parser::beam_check (SCM dur)
2189 Duration *d = unsmob_duration (dur);
2190 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2192 Music * m = unsmob_music (last_beam_start_);
2193 m->origin ()->warning (_("Suspect duration found following this beam"));
2195 last_beam_start_ = SCM_EOL;