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);
576 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
577 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
578 m = gh_call1 (gh_car (check_funcs), m);
583 $$ = new Score (*unsmob_score ($1));
584 $$->set_spot (THIS->here_input ());
586 | score_body lilypond_header {
587 scm_gc_unprotect_object ($2->self_scm ());
590 | score_body output_def {
603 music_output_def_body '}' {
605 THIS-> lexer_p_-> scope_l_arr_.pop ();
609 music_output_def_body:
611 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultmidi"));
616 p = dynamic_cast<Midi_def*> (id->clone ());
621 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
624 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
627 p = dynamic_cast<Paper_def*> (id->clone ());
630 THIS-> lexer_p_-> scope_l_arr_.push (p->variable_tab_);
633 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
634 Music_output_def *p = unsmob_music_output_def ($3);
636 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
639 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
640 Music_output_def *p = unsmob_music_output_def ($3);
643 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
646 | music_output_def_body assignment {
649 | music_output_def_body translator_spec_block {
650 $$->assign_translator ($2);
652 | music_output_def_body STYLESHEET embedded_scm {
653 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
655 | music_output_def_body tempo_request {
657 junk this ? there already is tempo stuff in
660 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
661 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
662 Midi_def * md = dynamic_cast<Midi_def*> ($$);
664 md->set_tempo (d->length_mom (), m);
666 | music_output_def_body error {
672 TEMPO steno_duration '=' bare_unsigned {
674 $$->set_mus_property ("duration", $2);
675 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
680 The representation of a list is the
684 to have efficient append.
686 Music_list: /* empty */ {
687 $$ = gh_cons (SCM_EOL, SCM_EOL);
691 SCM c = gh_cons ($2->self_scm (), SCM_EOL);
692 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
693 if (gh_pair_p (ly_cdr (s)))
694 gh_set_cdr_x (ly_cdr (s), c); /* append */
696 gh_set_car_x (s, c); /* set first cons */
697 gh_set_cdr_x (s, c) ; /* remember last cell */
713 | ALTERNATIVE '{' Music_list '}' {
719 REPEAT string bare_unsigned Music Alternative_music
723 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
724 if (times < scm_ilength (alts)) {
725 unsmob_music (gh_car (alts))
726 ->origin ()->warning (
727 _("More alternatives than repeats. Junking excess alternatives."));
728 alts = ly_truncate_list (times, alts);
731 Repeated_music * r = new Repeated_music (SCM_EOL);
734 r-> set_mus_property ("element", beg->self_scm ());
735 scm_gc_unprotect_object (beg->self_scm ());
737 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
739 r-> set_mus_property ("elements",alts);
740 SCM func = scm_primitive_eval (ly_symbol2scm ("repeat-name-to-ctor"));
741 SCM result = gh_call1 (func, $2);
743 set_music_properties (r, result);
745 r->set_spot (*$4->origin ());
751 SEQUENTIAL '{' Music_list '}' {
752 $$ = new Sequential_music (SCM_EOL);
753 $$->set_mus_property ("elements", ly_car ($3));
754 $$->set_spot(THIS->here_input());
756 | '{' Music_list '}' {
757 $$ = new Sequential_music (SCM_EOL);
758 $$->set_mus_property ("elements", ly_car ($2));
759 $$->set_spot(THIS->here_input());
764 SIMULTANEOUS '{' Music_list '}'{
765 $$ = new Simultaneous_music (SCM_EOL);
766 $$->set_mus_property ("elements", ly_car ($3));
767 $$->set_spot(THIS->here_input());
770 | '<' Music_list '>' {
771 $$ = new Simultaneous_music (SCM_EOL);
772 $$->set_mus_property ("elements", ly_car ($2));
773 $$->set_spot(THIS->here_input());
778 request_chord { $$ = $1; }
779 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
781 if (!gh_symbol_p ($3))
783 THIS->parser_error (_ ("Second argument must be a symbol"));
785 /*hould check # args */
786 if (!gh_procedure_p (pred))
788 THIS->parser_error (_ ("First argument must be a procedure taking 1 argument"));
791 Music *m = new Music (SCM_EOL);
792 m->set_mus_property ("predicate", pred);
793 m->set_mus_property ("grob-property", $3);
794 m->set_mus_property ("grob-value", $5);
795 m->set_mus_property ("iterator-ctor",
796 Output_property_music_iterator::constructor_cxx_function);
801 $$ = unsmob_music ($1)->clone ();
803 $$->set_spot (THIS->here_input());
811 CONTEXT STRING Music {
812 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
813 csm->set_mus_property ("element", $3->self_scm ());
814 scm_gc_unprotect_object ($3->self_scm ());
816 csm->set_mus_property ("context-type",$2);
817 csm->set_mus_property ("context-id", ly_str02scm (""));
821 | AUTOCHANGE STRING Music {
822 Music * chm = new Music_wrapper (SCM_EOL);
823 chm->set_mus_property ("element", $3->self_scm ());
824 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_cxx_function);
826 scm_gc_unprotect_object ($3->self_scm ());
827 chm->set_mus_property ("what", $2);
830 chm->set_spot (*$3->origin ());
835 The other version is for easier debugging of
836 Sequential_music_iterator in combination with grace notes.
839 SCM start = THIS->lexer_p_->lookup_identifier ("startGraceMusic");
840 SCM stop = THIS->lexer_p_->lookup_identifier ("stopGraceMusic");
841 Music *startm = unsmob_music (start);
842 Music *stopm = unsmob_music (stop);
846 stopm = stopm->clone ();
847 ms = gh_cons (stopm->self_scm (), ms);
848 scm_gc_unprotect_object (stopm->self_scm ());
850 ms = gh_cons ($2->self_scm (), ms);
851 scm_gc_unprotect_object ($2->self_scm());
853 startm = startm->clone ();
854 ms = gh_cons (startm->self_scm () , ms);
855 scm_gc_unprotect_object (startm->self_scm ());
858 Music* seq = new Sequential_music (SCM_EOL);
859 seq->set_mus_property ("elements", ms);
861 $$ = new Grace_music (SCM_EOL);
862 $$->set_mus_property ("element", seq->self_scm ());
863 scm_gc_unprotect_object (seq->self_scm ());
865 $$ = new Grace_music (SCM_EOL);
866 $$->set_mus_property ("element", $2->self_scm ());
867 scm_gc_unprotect_object ($2->self_scm ());
870 | CONTEXT string '=' string Music {
871 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
872 csm->set_mus_property ("element", $5->self_scm ());
873 scm_gc_unprotect_object ($5->self_scm ());
875 csm->set_mus_property ("context-type", $2);
876 csm->set_mus_property ("context-id", $4);
887 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
889 $$ = new Time_scaled_music (SCM_EOL);
890 $$->set_spot (THIS->pop_spot ());
893 $$->set_mus_property ("element", mp->self_scm ());
894 scm_gc_unprotect_object (mp->self_scm ());
895 $$->set_mus_property ("numerator", gh_int2scm (n));
896 $$->set_mus_property ("denominator", gh_int2scm (d));
897 $$->compress (Moment (Rational (n,d)));
900 | Repeated_music { $$ = $1; }
901 | Simultaneous_music { $$ = $1; }
902 | Sequential_music { $$ = $1; }
903 | TRANSPOSE pitch Music {
904 $$ = new Transposed_music (SCM_EOL);
906 Pitch pit = *unsmob_pitch ($2);
909 $$->set_mus_property ("element", p->self_scm ());
910 scm_gc_unprotect_object (p->self_scm ());
912 | TRANSPOSE steno_tonic_pitch Music {
913 $$ = new Transposed_music (SCM_EOL);
915 Pitch pit = *unsmob_pitch ($2);
918 $$->set_mus_property ("element", p->self_scm ());
919 scm_gc_unprotect_object (p->self_scm ());
922 | APPLY embedded_scm Music {
923 SCM ret = gh_call1 ($2, $3->self_scm ());
924 Music *m = unsmob_music (ret);
926 THIS->parser_error ("\\apply must return a Music");
927 m = new Music (SCM_EOL);
932 { THIS->lexer_p_->push_note_state (); }
935 THIS->lexer_p_->pop_state ();
938 { THIS->lexer_p_->push_figuredbass_state (); }
941 Music * chm = new Untransposable_music () ;
942 chm->set_mus_property ("element", $3->self_scm ());
944 scm_gc_unprotect_object ($3->self_scm());
946 THIS->lexer_p_->pop_state ();
949 { THIS->lexer_p_->push_chord_state (); }
952 Music * chm = new Un_relativable_music ;
953 chm->set_mus_property ("element", $3->self_scm ());
954 scm_gc_unprotect_object ($3->self_scm());
957 THIS->lexer_p_->pop_state ();
960 { THIS->lexer_p_->push_lyric_state (); }
964 THIS->lexer_p_->pop_state ();
966 | relative_music { $$ = $1; }
967 | re_rhythmed_music { $$ = $1; }
968 | part_combined_music { $$ = $1; }
972 RELATIVE absolute_pitch Music {
974 Pitch pit = *unsmob_pitch ($2);
975 $$ = new Relative_octave_music (SCM_EOL);
977 $$->set_mus_property ("element", p->self_scm ());
978 scm_gc_unprotect_object (p->self_scm ());
980 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
986 ADDLYRICS Music Music {
987 Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
988 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
989 scm_gc_unprotect_object ($3->self_scm ());
990 scm_gc_unprotect_object ($2->self_scm ());
996 PARTCOMBINE STRING Music Music {
997 Part_combine_music * p = new Part_combine_music (SCM_EOL);
999 p->set_mus_property ("what", $2);
1000 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1002 scm_gc_unprotect_object ($3->self_scm ());
1003 scm_gc_unprotect_object ($4->self_scm ());
1010 TRANSLATOR STRING '=' STRING {
1011 Music * t = new Music (SCM_EOL);
1012 t->set_mus_property ("iterator-ctor",
1013 Change_iterator::constructor_cxx_function);
1014 t-> set_mus_property ("change-to-type", $2);
1015 t-> set_mus_property ("change-to-id", $4);
1018 $$->set_spot (THIS->here_input ());
1023 PROPERTY STRING '.' STRING '=' scalar {
1025 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1026 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1028 csm->set_mus_property ("element", t->self_scm ());
1029 scm_gc_unprotect_object (t->self_scm ());
1032 $$->set_spot (THIS->here_input ());
1034 csm-> set_mus_property ("context-type", $2);
1036 | PROPERTY STRING '.' STRING UNSET {
1037 Music *t = new Music (SCM_EOL);
1039 t->set_mus_property ("iterator-ctor",
1040 Property_unset_iterator::constructor_cxx_function);
1041 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1043 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1044 csm->set_mus_property ("element", t->self_scm ());
1045 scm_gc_unprotect_object (t->self_scm ());
1048 $$->set_spot (THIS->here_input ());
1050 csm-> set_mus_property ("context-type", $2);
1052 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1053 Music *t = new Music (SCM_EOL);
1054 t->set_mus_property ("iterator-ctor",
1055 Push_property_iterator::constructor_cxx_function);
1056 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1057 t->set_mus_property ("pop-first", SCM_BOOL_T);
1058 t->set_mus_property ("grob-property", $6);
1059 t->set_mus_property ("grob-value", $8);
1060 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1061 csm->set_mus_property ("element", t->self_scm ());
1062 scm_gc_unprotect_object (t->self_scm ());
1064 $$->set_spot (THIS->here_input ());
1066 csm-> set_mus_property ("context-type", $2);
1068 | PROPERTY STRING '.' STRING OVERRIDE embedded_scm '=' embedded_scm {
1069 Music *t = new Music (SCM_EOL);
1070 t->set_mus_property ("iterator-ctor",
1071 Push_property_iterator::constructor_cxx_function);
1072 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1073 t->set_mus_property ("grob-property", $6);
1074 t->set_mus_property ("grob-value", $8);
1075 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1076 csm->set_mus_property ("element", t->self_scm ());
1077 scm_gc_unprotect_object (t->self_scm ());
1080 $$->set_spot (THIS->here_input ());
1082 csm-> set_mus_property ("context-type", $2);
1084 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1085 Music *t = new Music (SCM_EOL);
1086 t->set_mus_property ("iterator-ctor",
1087 Pop_property_iterator::constructor_cxx_function);
1088 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1089 t->set_mus_property ("grob-property", $6);
1091 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1092 csm->set_mus_property ("element", t->self_scm ());
1093 scm_gc_unprotect_object (t->self_scm ());
1096 $$->set_spot (THIS->here_input ());
1098 csm-> set_mus_property ("context-type", $2);
1104 | bare_int { $$ = gh_int2scm ($1); }
1105 | embedded_scm { $$ = $1; }
1112 } /*cont */ simple_element post_requests {
1113 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1116 for (int i=0; i < $1->size (); i++) {
1117 Music * m = $1->elem (i);
1118 l->append_music (m);
1130 $$ = new Request_chord (SCM_EOL);
1131 $$->set_mus_property ("elements", gh_cons ($1->self_scm (), SCM_EOL));
1132 scm_gc_unprotect_object ($1->self_scm());
1134 $$-> set_spot (THIS->here_input ());
1135 $1-> set_spot (THIS->here_input ());
1138 Span_req *l = new Span_req;
1139 l->set_span_dir (START);
1140 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1141 l->set_spot (THIS->here_input ());
1143 $$ = new Request_chord (SCM_EOL);
1144 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1145 scm_gc_unprotect_object (l->self_scm());
1146 $$->set_spot (THIS->here_input ());
1149 Span_req *l = new Span_req;
1150 l->set_span_dir (STOP);
1151 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1152 l->set_spot (THIS->here_input ());
1154 $$ = new Request_chord (SCM_EOL);
1155 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1156 $$->set_spot (THIS->here_input ());
1157 scm_gc_unprotect_object (l->self_scm());
1161 $$ = new Music (gh_list (gh_cons (ly_symbol2scm ("name"), ly_symbol2scm ("separator")), SCM_UNDEFINED));
1162 $$->set_spot (THIS->here_input ());
1166 extern Music * get_barcheck();
1167 $$ = get_barcheck ();
1168 $$->set_spot (THIS->here_input ());
1171 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1173 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1174 csm->set_mus_property ("element", t->self_scm ());
1175 scm_gc_unprotect_object (t->self_scm ());
1178 $$->set_spot (THIS->here_input ());
1180 csm->set_mus_property ("context-type", ly_str02scm ("Score"));
1182 | PARTIAL duration_length {
1183 Moment m = - unsmob_duration ($2)->length_mom ();
1184 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1186 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1187 sp->set_mus_property ("element", p->self_scm ());
1188 scm_gc_unprotect_object (p->self_scm ());
1191 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1194 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1195 SCM result = gh_call1 (func, $2);
1198 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1199 Music * p = new Music (SCM_EOL);
1200 set_music_properties (p, ly_car (s));
1201 l = gh_cons (p->self_scm (), l);
1202 scm_gc_unprotect_object (p->self_scm ());
1204 Sequential_music * seq = new Sequential_music (SCM_EOL);
1205 seq->set_mus_property ("elements", l);
1207 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1208 sp->set_mus_property ("element", seq->self_scm ());
1209 scm_gc_unprotect_object (seq->self_scm ());
1212 sp-> set_mus_property ("context-type", ly_str02scm ("Staff"));
1215 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1217 int l = gh_scm2int (ly_car ($2));
1218 int o = gh_scm2int (ly_cdr ($2));
1220 Moment one_beat = Moment (1)/Moment (o);
1221 Moment len = Moment (l) * one_beat;
1224 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1225 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1227 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1228 Sequential_music *seq = new Sequential_music (SCM_EOL);
1229 seq->set_mus_property ("elements", list);
1232 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1233 sp->set_mus_property ("element", seq->self_scm ());
1237 scm_gc_unprotect_object (p3->self_scm ());
1238 scm_gc_unprotect_object (p2->self_scm ());
1239 scm_gc_unprotect_object (p1->self_scm ());
1240 scm_gc_unprotect_object (seq->self_scm ());
1245 TODO: should make alias TimingContext for Score
1248 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1253 shorthand_command_req { $$ = $1; }
1254 | verbose_command_req { $$ = $1; }
1257 shorthand_command_req:
1268 Span_req*b= new Span_req;
1269 b->set_span_dir (START);
1270 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1274 THIS->last_beam_start_ = b->self_scm ();
1277 Span_req*b= new Span_req;
1278 b->set_span_dir ( STOP);
1279 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1283 $$ = new Breathing_sign_req;
1286 $$ = new Porrectus_req;
1290 verbose_command_req:
1291 COMMANDSPANREQUEST bare_int STRING { /*TODO: junkme */
1292 Span_req * sp_p = new Span_req;
1293 sp_p-> set_span_dir ( Direction ($2));
1294 sp_p->set_mus_property ("span-type",$3);
1295 sp_p->set_spot (THIS->here_input ());
1299 Mark_req * m = new Mark_req;
1303 Mark_req *m = new Mark_req;
1304 m->set_mus_property ("label", $2);
1309 Break_req * b = new Break_req;
1311 if (!gh_number_p (s))
1314 b->set_mus_property ("penalty", s);
1315 b->set_spot (THIS->here_input ());
1318 | SKIP duration_length {
1319 Skip_req * skip_p = new Skip_req;
1320 skip_p->set_mus_property ("duration", $2);
1328 Key_change_req *key_p= new Key_change_req;
1331 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1332 Key_change_req *key_p= new Key_change_req;
1334 key_p->set_mus_property ("pitch-alist", $3);
1335 ((Music*)key_p)->transpose (* unsmob_pitch ($2));
1342 $$ = new Link_array<Request>;
1344 | post_requests post_request {
1345 $2->set_spot (THIS->here_input ());
1357 request_that_take_dir:
1360 | script_abbreviation {
1361 SCM s = THIS->lexer_p_->lookup_identifier ("dash" + ly_scm2string ($1));
1362 Articulation_req *a = new Articulation_req;
1363 if (gh_string_p (s))
1364 a->set_mus_property ("articulation-type", s);
1365 else THIS->parser_error (_ ("Expecting string as script definition"));
1371 script_dir request_that_take_dir {
1372 if (Script_req * gs = dynamic_cast<Script_req*> ($2))
1373 gs->set_direction (Direction ($1));
1375 $2->origin ()->warning (_ ("Can't specify direction for this request"));
1381 REQUEST_IDENTIFIER {
1382 $$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
1383 $$->set_spot (THIS->here_input ());
1385 | DYNAMICSCRIPT embedded_scm {
1387 TODO: junkme, use text-type == dynamic
1389 Text_script_req *d = new Text_script_req;
1390 SCM dyn = ly_symbol2scm ("dynamic");
1391 d->set_mus_property ("text-type" , dyn);
1392 d->set_mus_property ("text", $2);
1393 d->set_spot (THIS->here_input ());
1396 | SPANREQUEST bare_int STRING {
1397 Span_req * sp_p = new Span_req;
1398 sp_p->set_span_dir ( Direction ($2));
1399 sp_p->set_mus_property ("span-type", $3);
1400 sp_p->set_spot (THIS->here_input ());
1404 Tremolo_req* a = new Tremolo_req;
1405 a->set_spot (THIS->here_input ());
1406 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1410 Articulation_req * a = new Articulation_req;
1411 a->set_mus_property ("articulation-type", $2);
1412 a->set_spot (THIS->here_input ());
1416 duh, junk this syntax from the parser, if possible.
1419 Arpeggio_req *a = new Arpeggio_req;
1420 a->set_spot (THIS->here_input ());
1424 Glissando_req *g = new Glissando_req;
1425 g->set_spot /* No pun intended */ (THIS->here_input ());
1452 | NOTENAME_PITCH sup_quotes {
1453 Pitch p = *unsmob_pitch ($1);
1455 $$ = p.smobbed_copy ();
1457 | NOTENAME_PITCH sub_quotes {
1458 Pitch p =* unsmob_pitch ($1);
1461 $$ = p.smobbed_copy ();
1474 | TONICNAME_PITCH sup_quotes {
1475 Pitch p = *unsmob_pitch ($1);
1477 $$ = p.smobbed_copy ();
1479 | TONICNAME_PITCH sub_quotes {
1480 Pitch p =* unsmob_pitch ($1);
1483 $$ = p.smobbed_copy ();
1498 PITCH embedded_scm {
1500 if (!unsmob_pitch ($2)) {
1501 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1502 $$ = Pitch ().smobbed_copy ();
1508 DURATION embedded_scm {
1510 if (!unsmob_duration ($2))
1512 THIS->parser_error (_ ("Must have duration object"));
1513 $$ = Duration ().smobbed_copy ();
1520 if (!THIS->lexer_p_->lyric_state_b ())
1521 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1522 $$ = new Extender_req;
1528 if (!THIS->lexer_p_->lyric_state_b ())
1529 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1530 $$ = new Hyphen_req;
1535 close_request_parens {
1537 dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
1541 close_request_parens:
1543 Span_req* s= new Span_req;
1545 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1546 s->set_spot (THIS->here_input());
1549 Span_req* s= new Span_req;
1551 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1552 s->set_spot (THIS->here_input());
1555 Span_req*s =new Span_req;
1557 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1558 s->set_spot (THIS->here_input());
1561 Span_req*s =new Span_req;
1563 s->set_mus_property ("span-type", ly_str02scm ("decrescendo"));
1564 s->set_spot (THIS->here_input());
1570 open_request_parens {
1572 dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
1576 open_request_parens:
1578 Span_req *s = new Span_req;
1579 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1580 s->set_spot (THIS->here_input());
1585 Span_req* s= new Span_req;
1587 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1588 s->set_spot (THIS->here_input());
1592 Span_req* s= new Span_req;
1594 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1595 s->set_spot (THIS->here_input());
1601 Text_script_req *t = new Text_script_req;
1602 t->set_mus_property ("text", $1);
1603 t->set_spot (THIS->here_input ());
1607 Text_script_req *t = new Text_script_req;
1608 t->set_mus_property ("text", $1);
1609 t->set_spot (THIS->here_input ());
1613 String ds = to_str ($1);
1614 Text_script_req* t = new Text_script_req;
1615 SCM finger = ly_symbol2scm ("finger");
1616 t->set_mus_property ("text", ly_str02scm (ds.ch_C ()));
1617 t->set_mus_property ("text-type" , finger);
1618 t->set_spot (THIS->here_input ());
1623 script_abbreviation:
1625 $$ = gh_str02scm ("Hat");
1628 $$ = gh_str02scm ("Plus");
1631 $$ = gh_str02scm ("Dash");
1634 $$ = gh_str02scm ("Bar");
1637 $$ = gh_str02scm ("Larger");
1640 $$ = gh_str02scm ("Dot");
1647 | '-' { $$ = CENTER; }
1652 $$ = new Link_array<Request>;
1654 | pre_requests open_request {
1666 multiplied_duration {
1669 | verbose_duration {
1674 optional_notemode_duration:
1676 Duration dd = THIS->default_duration_;
1677 $$ = dd.smobbed_copy ();
1679 THIS->beam_check ($$);
1681 | multiplied_duration {
1683 THIS->default_duration_ = *unsmob_duration ($$);
1685 THIS->beam_check ($$);
1687 | verbose_duration {
1689 THIS->default_duration_ = *unsmob_duration ($$);
1694 bare_unsigned dots {
1696 if (!is_duration_b ($1))
1697 THIS->parser_error (_f ("not a duration: %d", $1));
1701 $$ = Duration (l, $2).smobbed_copy ();
1703 | DURATION_IDENTIFIER dots {
1704 Duration *d =unsmob_duration ($1);
1705 Duration k (d->duration_log (),d->dot_count () + $2);
1706 $$ = k.smobbed_copy ();
1713 multiplied_duration:
1717 | multiplied_duration '*' bare_unsigned {
1718 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1720 | multiplied_duration '*' FRACTION {
1721 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1723 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1728 FRACTION { $$ = $1; }
1729 | UNSIGNED '/' UNSIGNED {
1730 $$ = gh_cons (gh_int2scm ($1), gh_int2scm ($3));
1748 | ':' bare_unsigned {
1749 if (!is_duration_b ($2))
1750 THIS->parser_error (_f ("not a duration: %d", $2));
1769 Bass_figure_req *bfr = new Bass_figure_req;
1770 $$ = bfr->self_scm();
1771 scm_gc_unprotect_object ($$);
1774 Bass_figure_req *bfr = new Bass_figure_req;
1775 $$ = bfr->self_scm();
1777 bfr->set_mus_property ("figure", gh_int2scm ($1));
1779 scm_gc_unprotect_object ($$);
1781 | bass_figure bass_mod {
1782 Music *m = unsmob_music ($1);
1784 SCM salter =m->get_mus_property ("alteration");
1785 int alter = gh_number_p( salter) ? gh_scm2int (salter) : 0;
1786 m->set_mus_property ("alteration",
1787 gh_int2scm (alter + $2));
1789 m->set_mus_property ("alteration", gh_int2scm (0));
1797 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1802 | br_bass_figure ']' {
1804 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1812 | figure_list br_bass_figure {
1813 $$ = gh_cons ($2, $1);
1818 FIGURE_OPEN figure_list FIGURE_CLOSE {
1819 Music * m = new Request_chord (SCM_EOL);
1820 $2 = scm_reverse_x ($2, SCM_EOL);
1821 m->set_mus_property ("elements", $2);
1822 $$ = m->self_scm ();
1833 pitch exclamations questions optional_notemode_duration optional_rest {
1835 Input i = THIS->pop_spot ();
1836 if (!THIS->lexer_p_->note_state_b ())
1837 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1845 n->set_mus_property ("pitch", $1);
1846 n->set_mus_property ("duration", $4);
1850 n->set_mus_property ("cautionary", SCM_BOOL_T);
1851 if ($2 % 2 || $3 % 2)
1852 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1854 Simultaneous_music*v = new Request_chord (SCM_EOL);
1855 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1856 scm_gc_unprotect_object (n->self_scm());
1862 | figure_spec optional_notemode_duration {
1863 Music * m = unsmob_music ($1);
1864 Input i = THIS->pop_spot ();
1866 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1868 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1872 | RESTNAME optional_notemode_duration {
1874 Input i = THIS->pop_spot ();
1875 SCM e = SCM_UNDEFINED;
1876 if (ly_scm2string ($1) =="s") {
1878 Skip_req * skip_p = new Skip_req;
1879 skip_p->set_mus_property ("duration" ,$2);
1880 skip_p->set_spot (i);
1881 e = skip_p->self_scm ();
1884 Rest_req * rest_req_p = new Rest_req;
1885 rest_req_p->set_mus_property ("duration", $2);
1886 rest_req_p->set_spot (i);
1887 e = rest_req_p->self_scm ();
1889 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1890 velt_p-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1891 velt_p->set_spot (i);
1895 | MULTI_MEASURE_REST optional_notemode_duration {
1896 Input i = THIS->pop_spot ();
1898 Skip_req * sk = new Skip_req;
1899 sk->set_mus_property ("duration", $2);
1900 Span_req *sp1 = new Span_req;
1901 Span_req *sp2 = new Span_req;
1902 sp1-> set_span_dir ( START);
1903 sp2-> set_span_dir ( STOP);
1904 SCM r = ly_str02scm ("rest");
1905 sp1->set_mus_property ("span-type", r);
1906 sp2->set_mus_property ("span-type", r);
1908 Request_chord * rqc1 = new Request_chord (SCM_EOL);
1909 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1910 Request_chord * rqc2 = new Request_chord (SCM_EOL);
1911 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1912 Request_chord * rqc3 = new Request_chord (SCM_EOL);
1913 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1915 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1917 $$ = new Sequential_music (SCM_EOL);
1918 $$->set_mus_property ("elements", ms);
1920 | STRING optional_notemode_duration {
1921 Input i = THIS->pop_spot ();
1923 Lyric_req* lreq_p = new Lyric_req;
1924 lreq_p->set_mus_property ("text", $1);
1925 lreq_p->set_mus_property ("duration",$2);
1926 lreq_p->set_spot (i);
1927 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1928 velt_p->set_mus_property ("elements", scm_list_n (lreq_p->self_scm (), SCM_UNDEFINED));
1933 Input i = THIS->pop_spot ();
1935 if (!THIS->lexer_p_->chord_state_b ())
1936 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1943 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1944 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1945 $$->set_spot (THIS->here_input ());
1952 | CHORD_COLON chord_notes {
1961 | chord_notes '.' chord_step {
1962 $$ = gh_append2 ($$, $3);
1970 | CHORD_CARET chord_notes {
1980 | '/' steno_tonic_pitch {
1989 | CHORD_BASS steno_tonic_pitch {
1996 $$ = gh_cons ($1, SCM_EOL);
1998 | CHORDMODIFIER_PITCH {
1999 $$ = gh_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2001 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2002 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2010 m.notename_i_ = ($1 - 1) % 7;
2011 m.octave_i_ = $1 > 7 ? 1 : 0;
2012 m.alteration_i_ = 0;
2014 $$ = m.smobbed_copy ();
2016 | bare_unsigned '+' {
2018 m.notename_i_ = ($1 - 1) % 7;
2019 m.octave_i_ = $1 > 7 ? 1 : 0;
2020 m.alteration_i_ = 1;
2023 $$ = m.smobbed_copy ();
2025 | bare_unsigned CHORD_MINUS {
2027 m.notename_i_ = ($1 - 1) % 7;
2028 m.octave_i_ = $1 > 7 ? 1 : 0;
2029 m.alteration_i_ = -1;
2031 $$ = m.smobbed_copy ();
2039 number_expression '+' number_term {
2040 $$ = scm_sum ($1, $3);
2042 | number_expression '-' number_term {
2043 $$ = scm_difference ($1, $3);
2052 | number_factor '*' number_factor {
2053 $$ = scm_product ($1, $3);
2055 | number_factor '/' number_factor {
2056 $$ = scm_divide ($1, $3);
2061 '(' number_expression ')' {
2064 | '-' number_factor { /* %prec UNARY_MINUS */
2065 $$ = scm_difference ($2, SCM_UNDEFINED);
2073 $$ = gh_int2scm ($1);
2078 | NUMBER_IDENTIFIER {
2082 $$ = gh_double2scm (gh_scm2double ($1) CM );
2085 $$ = gh_double2scm (gh_scm2double ($1) PT);
2088 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2091 $$ = gh_double2scm (gh_scm2double ($1) MM);
2094 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2110 if (scm_integer_p ($1) == SCM_BOOL_T)
2112 int k = gh_scm2int ($1);
2116 THIS->parser_error (_ ("need integer number arg"));
2130 | STRING_IDENTIFIER {
2133 | string '+' string {
2134 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2141 | exclamations '!' { $$ ++; }
2146 | questions '?' { $$ ++; }
2153 My_lily_parser::set_yydebug (bool )
2160 extern My_lily_parser * current_parser;
2163 My_lily_parser::do_yyparse ()
2166 current_parser = this;;
2167 yyparse ((void*)this);
2172 Should make this optional? It will also complain when you do
2176 which is entirely legitimate.
2178 Or we can scrap it. Barchecks should detect wrong durations, and
2179 skipTypesetting speeds it up a lot.
2182 My_lily_parser::beam_check (SCM dur)
2184 Duration *d = unsmob_duration (dur);
2185 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2187 Music * m = unsmob_music (last_beam_start_);
2188 m->origin ()->warning (_("Suspect duration found following this beam"));
2190 last_beam_start_ = SCM_EOL;