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 REVERT embedded_scm {
514 unsmob_translator_def ($$)->add_pop_property (
515 scm_string_to_symbol ($2), $4);
517 | translator_spec_body NAME STRING {
518 unsmob_translator_def ($$)->type_name_ = $3;
520 | translator_spec_body CONSISTS STRING {
521 unsmob_translator_def ($$)->add_element ($3);
523 | translator_spec_body ALIAS STRING {
524 Translator_def*td = unsmob_translator_def ($$);
525 td->type_aliases_ = gh_cons ($3, td->type_aliases_);
527 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
528 Translator_def*td = unsmob_translator_def($$);
529 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
530 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
531 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
533 | translator_spec_body CONSISTSEND STRING {
534 unsmob_translator_def ($$)->add_last_element ( $3);
536 | translator_spec_body ACCEPTS STRING {
537 unsmob_translator_def ($$)->set_acceptor ($3,true);
539 | translator_spec_body DENIES STRING {
540 unsmob_translator_def ($$)->set_acceptor ($3,false);
542 | translator_spec_body REMOVE STRING {
543 unsmob_translator_def ($$)->remove_element ($3);
554 /*cont*/ '{' score_body '}' {
557 if (!$$->def_p_arr_.size ())
559 Music_output_def *id =
560 unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
561 $$->add_output (id ? id->clone () : new Paper_def );
570 $$->set_spot (THIS->here_input ());
571 SCM m = $1->self_scm ();
572 scm_gc_unprotect_object (m);
577 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
578 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
579 m = gh_call1 (gh_car (check_funcs), m);
584 $$ = new Score (*unsmob_score ($1));
585 $$->set_spot (THIS->here_input ());
587 | score_body lilypond_header {
588 scm_gc_unprotect_object ($2->self_scm ());
591 | score_body output_def {
604 music_output_def_body '}' {
606 THIS-> lexer_p_-> scope_l_arr_.pop ();
610 music_output_def_body:
612 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultmidi"));
617 p = dynamic_cast<Midi_def*> (id->clone ());
622 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
625 Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
628 p = dynamic_cast<Paper_def*> (id->clone ());
631 THIS-> lexer_p_-> scope_l_arr_.push (p->variable_tab_);
634 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
635 Music_output_def *p = unsmob_music_output_def ($3);
637 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
640 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
641 Music_output_def *p = unsmob_music_output_def ($3);
644 THIS->lexer_p_->scope_l_arr_.push (p->variable_tab_);
647 | music_output_def_body assignment {
650 | music_output_def_body translator_spec_block {
651 $$->assign_translator ($2);
653 | music_output_def_body STYLESHEET embedded_scm {
654 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
656 | music_output_def_body tempo_request {
658 junk this ? there already is tempo stuff in
661 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
662 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
663 Midi_def * md = dynamic_cast<Midi_def*> ($$);
665 md->set_tempo (d->length_mom (), m);
667 | music_output_def_body error {
673 TEMPO steno_duration '=' bare_unsigned {
675 $$->set_mus_property ("duration", $2);
676 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
681 The representation of a list is the
685 to have efficient append.
687 Music_list: /* empty */ {
688 $$ = gh_cons (SCM_EOL, SCM_EOL);
692 SCM c = gh_cons ($2->self_scm (), SCM_EOL);
693 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
694 if (gh_pair_p (ly_cdr (s)))
695 gh_set_cdr_x (ly_cdr (s), c); /* append */
697 gh_set_car_x (s, c); /* set first cons */
698 gh_set_cdr_x (s, c) ; /* remember last cell */
714 | ALTERNATIVE '{' Music_list '}' {
720 REPEAT string bare_unsigned Music Alternative_music
724 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
725 if (times < scm_ilength (alts)) {
726 unsmob_music (gh_car (alts))
727 ->origin ()->warning (
728 _("More alternatives than repeats. Junking excess alternatives."));
729 alts = ly_truncate_list (times, alts);
732 Repeated_music * r = new Repeated_music (SCM_EOL);
735 r-> set_mus_property ("element", beg->self_scm ());
736 scm_gc_unprotect_object (beg->self_scm ());
738 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
740 r-> set_mus_property ("elements",alts);
741 SCM func = scm_primitive_eval (ly_symbol2scm ("repeat-name-to-ctor"));
742 SCM result = gh_call1 (func, $2);
744 set_music_properties (r, result);
746 r->set_spot (*$4->origin ());
752 SEQUENTIAL '{' Music_list '}' {
753 $$ = new Sequential_music (SCM_EOL);
754 $$->set_mus_property ("elements", ly_car ($3));
755 $$->set_spot(THIS->here_input());
757 | '{' Music_list '}' {
758 $$ = new Sequential_music (SCM_EOL);
759 $$->set_mus_property ("elements", ly_car ($2));
760 $$->set_spot(THIS->here_input());
765 SIMULTANEOUS '{' Music_list '}'{
766 $$ = new Simultaneous_music (SCM_EOL);
767 $$->set_mus_property ("elements", ly_car ($3));
768 $$->set_spot(THIS->here_input());
771 | '<' Music_list '>' {
772 $$ = new Simultaneous_music (SCM_EOL);
773 $$->set_mus_property ("elements", ly_car ($2));
774 $$->set_spot(THIS->here_input());
779 request_chord { $$ = $1; }
780 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
782 if (!gh_symbol_p ($3))
784 THIS->parser_error (_ ("Second argument must be a symbol"));
786 /*hould check # args */
787 if (!gh_procedure_p (pred))
789 THIS->parser_error (_ ("First argument must be a procedure taking 1 argument"));
792 Music *m = new Music (SCM_EOL);
793 m->set_mus_property ("predicate", pred);
794 m->set_mus_property ("grob-property", $3);
795 m->set_mus_property ("grob-value", $5);
796 m->set_mus_property ("iterator-ctor",
797 Output_property_music_iterator::constructor_cxx_function);
802 $$ = unsmob_music ($1)->clone ();
804 $$->set_spot (THIS->here_input());
812 CONTEXT STRING Music {
813 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
814 csm->set_mus_property ("element", $3->self_scm ());
815 scm_gc_unprotect_object ($3->self_scm ());
817 csm->set_mus_property ("context-type",$2);
818 csm->set_mus_property ("context-id", ly_str02scm (""));
822 | AUTOCHANGE STRING Music {
823 Music * chm = new Music_wrapper (SCM_EOL);
824 chm->set_mus_property ("element", $3->self_scm ());
825 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_cxx_function);
827 scm_gc_unprotect_object ($3->self_scm ());
828 chm->set_mus_property ("what", $2);
831 chm->set_spot (*$3->origin ());
836 The other version is for easier debugging of
837 Sequential_music_iterator in combination with grace notes.
840 SCM start = THIS->lexer_p_->lookup_identifier ("startGraceMusic");
841 SCM stop = THIS->lexer_p_->lookup_identifier ("stopGraceMusic");
842 Music *startm = unsmob_music (start);
843 Music *stopm = unsmob_music (stop);
847 stopm = stopm->clone ();
848 ms = gh_cons (stopm->self_scm (), ms);
849 scm_gc_unprotect_object (stopm->self_scm ());
851 ms = gh_cons ($2->self_scm (), ms);
852 scm_gc_unprotect_object ($2->self_scm());
854 startm = startm->clone ();
855 ms = gh_cons (startm->self_scm () , ms);
856 scm_gc_unprotect_object (startm->self_scm ());
859 Music* seq = new Sequential_music (SCM_EOL);
860 seq->set_mus_property ("elements", ms);
862 $$ = new Grace_music (SCM_EOL);
863 $$->set_mus_property ("element", seq->self_scm ());
864 scm_gc_unprotect_object (seq->self_scm ());
866 $$ = new Grace_music (SCM_EOL);
867 $$->set_mus_property ("element", $2->self_scm ());
868 scm_gc_unprotect_object ($2->self_scm ());
871 | CONTEXT string '=' string Music {
872 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
873 csm->set_mus_property ("element", $5->self_scm ());
874 scm_gc_unprotect_object ($5->self_scm ());
876 csm->set_mus_property ("context-type", $2);
877 csm->set_mus_property ("context-id", $4);
888 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
890 $$ = new Time_scaled_music (SCM_EOL);
891 $$->set_spot (THIS->pop_spot ());
894 $$->set_mus_property ("element", mp->self_scm ());
895 scm_gc_unprotect_object (mp->self_scm ());
896 $$->set_mus_property ("numerator", gh_int2scm (n));
897 $$->set_mus_property ("denominator", gh_int2scm (d));
898 $$->compress (Moment (Rational (n,d)));
901 | Repeated_music { $$ = $1; }
902 | Simultaneous_music { $$ = $1; }
903 | Sequential_music { $$ = $1; }
904 | TRANSPOSE pitch Music {
905 $$ = new Transposed_music (SCM_EOL);
907 Pitch pit = *unsmob_pitch ($2);
910 $$->set_mus_property ("element", p->self_scm ());
911 scm_gc_unprotect_object (p->self_scm ());
913 | TRANSPOSE steno_tonic_pitch Music {
914 $$ = new Transposed_music (SCM_EOL);
916 Pitch pit = *unsmob_pitch ($2);
919 $$->set_mus_property ("element", p->self_scm ());
920 scm_gc_unprotect_object (p->self_scm ());
923 | APPLY embedded_scm Music {
924 SCM ret = gh_call1 ($2, $3->self_scm ());
925 Music *m = unsmob_music (ret);
927 THIS->parser_error ("\\apply must return a Music");
928 m = new Music (SCM_EOL);
933 { THIS->lexer_p_->push_note_state (); }
936 THIS->lexer_p_->pop_state ();
939 { THIS->lexer_p_->push_figuredbass_state (); }
942 Music * chm = new Untransposable_music () ;
943 chm->set_mus_property ("element", $3->self_scm ());
945 scm_gc_unprotect_object ($3->self_scm());
947 THIS->lexer_p_->pop_state ();
950 { THIS->lexer_p_->push_chord_state (); }
953 Music * chm = new Un_relativable_music ;
954 chm->set_mus_property ("element", $3->self_scm ());
955 scm_gc_unprotect_object ($3->self_scm());
958 THIS->lexer_p_->pop_state ();
961 { THIS->lexer_p_->push_lyric_state (); }
965 THIS->lexer_p_->pop_state ();
967 | relative_music { $$ = $1; }
968 | re_rhythmed_music { $$ = $1; }
969 | part_combined_music { $$ = $1; }
973 RELATIVE absolute_pitch Music {
975 Pitch pit = *unsmob_pitch ($2);
976 $$ = new Relative_octave_music (SCM_EOL);
978 $$->set_mus_property ("element", p->self_scm ());
979 scm_gc_unprotect_object (p->self_scm ());
981 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
987 ADDLYRICS Music Music {
988 Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
989 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
990 scm_gc_unprotect_object ($3->self_scm ());
991 scm_gc_unprotect_object ($2->self_scm ());
997 PARTCOMBINE STRING Music Music {
998 Part_combine_music * p = new Part_combine_music (SCM_EOL);
1000 p->set_mus_property ("what", $2);
1001 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1003 scm_gc_unprotect_object ($3->self_scm ());
1004 scm_gc_unprotect_object ($4->self_scm ());
1011 TRANSLATOR STRING '=' STRING {
1012 Music * t = new Music (SCM_EOL);
1013 t->set_mus_property ("iterator-ctor",
1014 Change_iterator::constructor_cxx_function);
1015 t-> set_mus_property ("change-to-type", $2);
1016 t-> set_mus_property ("change-to-id", $4);
1019 $$->set_spot (THIS->here_input ());
1024 PROPERTY STRING '.' STRING '=' scalar {
1026 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1027 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1029 csm->set_mus_property ("element", t->self_scm ());
1030 scm_gc_unprotect_object (t->self_scm ());
1033 $$->set_spot (THIS->here_input ());
1035 csm-> set_mus_property ("context-type", $2);
1037 | PROPERTY STRING '.' STRING UNSET {
1038 Music *t = new Music (SCM_EOL);
1040 t->set_mus_property ("iterator-ctor",
1041 Property_unset_iterator::constructor_cxx_function);
1042 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1044 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1045 csm->set_mus_property ("element", t->self_scm ());
1046 scm_gc_unprotect_object (t->self_scm ());
1049 $$->set_spot (THIS->here_input ());
1051 csm-> set_mus_property ("context-type", $2);
1053 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1054 Music *t = new Music (SCM_EOL);
1055 t->set_mus_property ("iterator-ctor",
1056 Push_property_iterator::constructor_cxx_function);
1057 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1058 t->set_mus_property ("pop-first", SCM_BOOL_T);
1059 t->set_mus_property ("grob-property", $6);
1060 t->set_mus_property ("grob-value", $8);
1061 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1062 csm->set_mus_property ("element", t->self_scm ());
1063 scm_gc_unprotect_object (t->self_scm ());
1065 $$->set_spot (THIS->here_input ());
1067 csm-> set_mus_property ("context-type", $2);
1069 | PROPERTY STRING '.' STRING OVERRIDE embedded_scm '=' embedded_scm {
1070 Music *t = new Music (SCM_EOL);
1071 t->set_mus_property ("iterator-ctor",
1072 Push_property_iterator::constructor_cxx_function);
1073 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1074 t->set_mus_property ("grob-property", $6);
1075 t->set_mus_property ("grob-value", $8);
1076 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1077 csm->set_mus_property ("element", t->self_scm ());
1078 scm_gc_unprotect_object (t->self_scm ());
1081 $$->set_spot (THIS->here_input ());
1083 csm-> set_mus_property ("context-type", $2);
1085 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1086 Music *t = new Music (SCM_EOL);
1087 t->set_mus_property ("iterator-ctor",
1088 Pop_property_iterator::constructor_cxx_function);
1089 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1090 t->set_mus_property ("grob-property", $6);
1092 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1093 csm->set_mus_property ("element", t->self_scm ());
1094 scm_gc_unprotect_object (t->self_scm ());
1097 $$->set_spot (THIS->here_input ());
1099 csm-> set_mus_property ("context-type", $2);
1105 | bare_int { $$ = gh_int2scm ($1); }
1106 | embedded_scm { $$ = $1; }
1113 } /*cont */ simple_element post_requests {
1114 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1117 for (int i=0; i < $1->size (); i++) {
1118 Music * m = $1->elem (i);
1119 l->append_music (m);
1131 $$ = new Request_chord (SCM_EOL);
1132 $$->set_mus_property ("elements", gh_cons ($1->self_scm (), SCM_EOL));
1133 scm_gc_unprotect_object ($1->self_scm());
1135 $$-> set_spot (THIS->here_input ());
1136 $1-> set_spot (THIS->here_input ());
1139 Span_req *l = new Span_req;
1140 l->set_span_dir (START);
1141 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1142 l->set_spot (THIS->here_input ());
1144 $$ = new Request_chord (SCM_EOL);
1145 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1146 scm_gc_unprotect_object (l->self_scm());
1147 $$->set_spot (THIS->here_input ());
1150 Span_req *l = new Span_req;
1151 l->set_span_dir (STOP);
1152 l->set_mus_property ("span-type", ly_str02scm ("ligature"));
1153 l->set_spot (THIS->here_input ());
1155 $$ = new Request_chord (SCM_EOL);
1156 $$->set_mus_property ("elements", gh_cons (l->self_scm (), SCM_EOL));
1157 $$->set_spot (THIS->here_input ());
1158 scm_gc_unprotect_object (l->self_scm());
1162 $$ = new Music (gh_list (gh_cons (ly_symbol2scm ("name"), ly_symbol2scm ("separator")), SCM_UNDEFINED));
1163 $$->set_spot (THIS->here_input ());
1167 extern Music * get_barcheck();
1168 $$ = get_barcheck ();
1169 $$->set_spot (THIS->here_input ());
1172 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1174 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1175 csm->set_mus_property ("element", t->self_scm ());
1176 scm_gc_unprotect_object (t->self_scm ());
1179 $$->set_spot (THIS->here_input ());
1181 csm->set_mus_property ("context-type", ly_str02scm ("Score"));
1183 | PARTIAL duration_length {
1184 Moment m = - unsmob_duration ($2)->length_mom ();
1185 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1187 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1188 sp->set_mus_property ("element", p->self_scm ());
1189 scm_gc_unprotect_object (p->self_scm ());
1192 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1195 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1196 SCM result = gh_call1 (func, $2);
1199 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1200 Music * p = new Music (SCM_EOL);
1201 set_music_properties (p, ly_car (s));
1202 l = gh_cons (p->self_scm (), l);
1203 scm_gc_unprotect_object (p->self_scm ());
1205 Sequential_music * seq = new Sequential_music (SCM_EOL);
1206 seq->set_mus_property ("elements", l);
1208 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1209 sp->set_mus_property ("element", seq->self_scm ());
1210 scm_gc_unprotect_object (seq->self_scm ());
1213 sp-> set_mus_property ("context-type", ly_str02scm ("Staff"));
1216 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1218 int l = gh_scm2int (ly_car ($2));
1219 int o = gh_scm2int (ly_cdr ($2));
1221 Moment one_beat = Moment (1)/Moment (o);
1222 Moment len = Moment (l) * one_beat;
1225 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1226 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1228 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1229 Sequential_music *seq = new Sequential_music (SCM_EOL);
1230 seq->set_mus_property ("elements", list);
1233 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1234 sp->set_mus_property ("element", seq->self_scm ());
1238 scm_gc_unprotect_object (p3->self_scm ());
1239 scm_gc_unprotect_object (p2->self_scm ());
1240 scm_gc_unprotect_object (p1->self_scm ());
1241 scm_gc_unprotect_object (seq->self_scm ());
1246 TODO: should make alias TimingContext for Score
1249 sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
1254 shorthand_command_req { $$ = $1; }
1255 | verbose_command_req { $$ = $1; }
1258 shorthand_command_req:
1269 Span_req*b= new Span_req;
1270 b->set_span_dir (START);
1271 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1275 THIS->last_beam_start_ = b->self_scm ();
1278 Span_req*b= new Span_req;
1279 b->set_span_dir ( STOP);
1280 b->set_mus_property ("span-type", ly_str02scm ("beam"));
1284 $$ = new Breathing_sign_req;
1287 $$ = new Porrectus_req;
1291 verbose_command_req:
1292 COMMANDSPANREQUEST bare_int STRING { /*TODO: junkme */
1293 Span_req * sp_p = new Span_req;
1294 sp_p-> set_span_dir ( Direction ($2));
1295 sp_p->set_mus_property ("span-type",$3);
1296 sp_p->set_spot (THIS->here_input ());
1300 Mark_req * m = new Mark_req;
1304 Mark_req *m = new Mark_req;
1305 m->set_mus_property ("label", $2);
1310 Break_req * b = new Break_req;
1312 if (!gh_number_p (s))
1315 b->set_mus_property ("penalty", s);
1316 b->set_spot (THIS->here_input ());
1319 | SKIP duration_length {
1320 Skip_req * skip_p = new Skip_req;
1321 skip_p->set_mus_property ("duration", $2);
1329 Key_change_req *key_p= new Key_change_req;
1332 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1333 Key_change_req *key_p= new Key_change_req;
1335 key_p->set_mus_property ("pitch-alist", $3);
1336 ((Music*)key_p)->transpose (* unsmob_pitch ($2));
1343 $$ = new Link_array<Request>;
1345 | post_requests post_request {
1346 $2->set_spot (THIS->here_input ());
1358 request_that_take_dir:
1361 | script_abbreviation {
1362 SCM s = THIS->lexer_p_->lookup_identifier ("dash" + ly_scm2string ($1));
1363 Articulation_req *a = new Articulation_req;
1364 if (gh_string_p (s))
1365 a->set_mus_property ("articulation-type", s);
1366 else THIS->parser_error (_ ("Expecting string as script definition"));
1372 script_dir request_that_take_dir {
1373 if (Script_req * gs = dynamic_cast<Script_req*> ($2))
1374 gs->set_direction (Direction ($1));
1376 $2->origin ()->warning (_ ("Can't specify direction for this request"));
1382 REQUEST_IDENTIFIER {
1383 $$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
1384 $$->set_spot (THIS->here_input ());
1386 | DYNAMICSCRIPT embedded_scm {
1388 TODO: junkme, use text-type == dynamic
1390 Text_script_req *d = new Text_script_req;
1391 SCM dyn = ly_symbol2scm ("dynamic");
1392 d->set_mus_property ("text-type" , dyn);
1393 d->set_mus_property ("text", $2);
1394 d->set_spot (THIS->here_input ());
1397 | SPANREQUEST bare_int STRING {
1398 Span_req * sp_p = new Span_req;
1399 sp_p->set_span_dir ( Direction ($2));
1400 sp_p->set_mus_property ("span-type", $3);
1401 sp_p->set_spot (THIS->here_input ());
1405 Tremolo_req* a = new Tremolo_req;
1406 a->set_spot (THIS->here_input ());
1407 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1411 Articulation_req * a = new Articulation_req;
1412 a->set_mus_property ("articulation-type", $2);
1413 a->set_spot (THIS->here_input ());
1417 duh, junk this syntax from the parser, if possible.
1420 Arpeggio_req *a = new Arpeggio_req;
1421 a->set_spot (THIS->here_input ());
1425 Glissando_req *g = new Glissando_req;
1426 g->set_spot /* No pun intended */ (THIS->here_input ());
1453 | NOTENAME_PITCH sup_quotes {
1454 Pitch p = *unsmob_pitch ($1);
1456 $$ = p.smobbed_copy ();
1458 | NOTENAME_PITCH sub_quotes {
1459 Pitch p =* unsmob_pitch ($1);
1462 $$ = p.smobbed_copy ();
1475 | TONICNAME_PITCH sup_quotes {
1476 Pitch p = *unsmob_pitch ($1);
1478 $$ = p.smobbed_copy ();
1480 | TONICNAME_PITCH sub_quotes {
1481 Pitch p =* unsmob_pitch ($1);
1484 $$ = p.smobbed_copy ();
1499 PITCH embedded_scm {
1501 if (!unsmob_pitch ($2)) {
1502 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1503 $$ = Pitch ().smobbed_copy ();
1509 DURATION embedded_scm {
1511 if (!unsmob_duration ($2))
1513 THIS->parser_error (_ ("Must have duration object"));
1514 $$ = Duration ().smobbed_copy ();
1521 if (!THIS->lexer_p_->lyric_state_b ())
1522 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1523 $$ = new Extender_req;
1529 if (!THIS->lexer_p_->lyric_state_b ())
1530 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1531 $$ = new Hyphen_req;
1536 close_request_parens {
1538 dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
1542 close_request_parens:
1544 Span_req* s= new Span_req;
1546 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1547 s->set_spot (THIS->here_input());
1550 Span_req* s= new Span_req;
1552 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1553 s->set_spot (THIS->here_input());
1556 Span_req*s =new Span_req;
1558 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1559 s->set_spot (THIS->here_input());
1562 Span_req*s =new Span_req;
1564 s->set_mus_property ("span-type", ly_str02scm ("decrescendo"));
1565 s->set_spot (THIS->here_input());
1571 open_request_parens {
1573 dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
1577 open_request_parens:
1579 Span_req *s = new Span_req;
1580 s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
1581 s->set_spot (THIS->here_input());
1586 Span_req* s= new Span_req;
1588 s->set_mus_property ("span-type", ly_str02scm ( "slur"));
1589 s->set_spot (THIS->here_input());
1593 Span_req* s= new Span_req;
1595 s->set_mus_property ("span-type", ly_str02scm ( "phrasing-slur"));
1596 s->set_spot (THIS->here_input());
1602 Text_script_req *t = new Text_script_req;
1603 t->set_mus_property ("text", $1);
1604 t->set_spot (THIS->here_input ());
1608 Text_script_req *t = new Text_script_req;
1609 t->set_mus_property ("text", $1);
1610 t->set_spot (THIS->here_input ());
1614 String ds = to_str ($1);
1615 Text_script_req* t = new Text_script_req;
1616 SCM finger = ly_symbol2scm ("finger");
1617 t->set_mus_property ("text", ly_str02scm (ds.ch_C ()));
1618 t->set_mus_property ("text-type" , finger);
1619 t->set_spot (THIS->here_input ());
1624 script_abbreviation:
1626 $$ = gh_str02scm ("Hat");
1629 $$ = gh_str02scm ("Plus");
1632 $$ = gh_str02scm ("Dash");
1635 $$ = gh_str02scm ("Bar");
1638 $$ = gh_str02scm ("Larger");
1641 $$ = gh_str02scm ("Dot");
1648 | '-' { $$ = CENTER; }
1653 $$ = new Link_array<Request>;
1655 | pre_requests open_request {
1667 multiplied_duration {
1670 | verbose_duration {
1675 optional_notemode_duration:
1677 Duration dd = THIS->default_duration_;
1678 $$ = dd.smobbed_copy ();
1680 THIS->beam_check ($$);
1682 | multiplied_duration {
1684 THIS->default_duration_ = *unsmob_duration ($$);
1686 THIS->beam_check ($$);
1688 | verbose_duration {
1690 THIS->default_duration_ = *unsmob_duration ($$);
1695 bare_unsigned dots {
1697 if (!is_duration_b ($1))
1698 THIS->parser_error (_f ("not a duration: %d", $1));
1702 $$ = Duration (l, $2).smobbed_copy ();
1704 | DURATION_IDENTIFIER dots {
1705 Duration *d =unsmob_duration ($1);
1706 Duration k (d->duration_log (),d->dot_count () + $2);
1707 $$ = k.smobbed_copy ();
1714 multiplied_duration:
1718 | multiplied_duration '*' bare_unsigned {
1719 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1721 | multiplied_duration '*' FRACTION {
1722 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1724 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1729 FRACTION { $$ = $1; }
1730 | UNSIGNED '/' UNSIGNED {
1731 $$ = gh_cons (gh_int2scm ($1), gh_int2scm ($3));
1749 | ':' bare_unsigned {
1750 if (!is_duration_b ($2))
1751 THIS->parser_error (_f ("not a duration: %d", $2));
1770 Bass_figure_req *bfr = new Bass_figure_req;
1771 $$ = bfr->self_scm();
1772 scm_gc_unprotect_object ($$);
1775 Bass_figure_req *bfr = new Bass_figure_req;
1776 $$ = bfr->self_scm();
1778 bfr->set_mus_property ("figure", gh_int2scm ($1));
1780 scm_gc_unprotect_object ($$);
1782 | bass_figure bass_mod {
1783 Music *m = unsmob_music ($1);
1785 SCM salter =m->get_mus_property ("alteration");
1786 int alter = gh_number_p( salter) ? gh_scm2int (salter) : 0;
1787 m->set_mus_property ("alteration",
1788 gh_int2scm (alter + $2));
1790 m->set_mus_property ("alteration", gh_int2scm (0));
1798 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1803 | br_bass_figure ']' {
1805 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1813 | figure_list br_bass_figure {
1814 $$ = gh_cons ($2, $1);
1819 FIGURE_OPEN figure_list FIGURE_CLOSE {
1820 Music * m = new Request_chord (SCM_EOL);
1821 $2 = scm_reverse_x ($2, SCM_EOL);
1822 m->set_mus_property ("elements", $2);
1823 $$ = m->self_scm ();
1834 pitch exclamations questions optional_notemode_duration optional_rest {
1836 Input i = THIS->pop_spot ();
1837 if (!THIS->lexer_p_->note_state_b ())
1838 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1846 n->set_mus_property ("pitch", $1);
1847 n->set_mus_property ("duration", $4);
1851 n->set_mus_property ("cautionary", SCM_BOOL_T);
1852 if ($2 % 2 || $3 % 2)
1853 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1855 Simultaneous_music*v = new Request_chord (SCM_EOL);
1856 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1857 scm_gc_unprotect_object (n->self_scm());
1863 | figure_spec optional_notemode_duration {
1864 Music * m = unsmob_music ($1);
1865 Input i = THIS->pop_spot ();
1867 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1869 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1873 | RESTNAME optional_notemode_duration {
1875 Input i = THIS->pop_spot ();
1876 SCM e = SCM_UNDEFINED;
1877 if (ly_scm2string ($1) =="s") {
1879 Skip_req * skip_p = new Skip_req;
1880 skip_p->set_mus_property ("duration" ,$2);
1881 skip_p->set_spot (i);
1882 e = skip_p->self_scm ();
1885 Rest_req * rest_req_p = new Rest_req;
1886 rest_req_p->set_mus_property ("duration", $2);
1887 rest_req_p->set_spot (i);
1888 e = rest_req_p->self_scm ();
1890 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1891 velt_p-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1892 velt_p->set_spot (i);
1896 | MULTI_MEASURE_REST optional_notemode_duration {
1897 Input i = THIS->pop_spot ();
1899 Skip_req * sk = new Skip_req;
1900 sk->set_mus_property ("duration", $2);
1901 Span_req *sp1 = new Span_req;
1902 Span_req *sp2 = new Span_req;
1903 sp1-> set_span_dir ( START);
1904 sp2-> set_span_dir ( STOP);
1905 SCM r = ly_str02scm ("rest");
1906 sp1->set_mus_property ("span-type", r);
1907 sp2->set_mus_property ("span-type", r);
1909 Request_chord * rqc1 = new Request_chord (SCM_EOL);
1910 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1911 Request_chord * rqc2 = new Request_chord (SCM_EOL);
1912 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1913 Request_chord * rqc3 = new Request_chord (SCM_EOL);
1914 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1916 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1918 $$ = new Sequential_music (SCM_EOL);
1919 $$->set_mus_property ("elements", ms);
1921 | STRING optional_notemode_duration {
1922 Input i = THIS->pop_spot ();
1924 Lyric_req* lreq_p = new Lyric_req;
1925 lreq_p->set_mus_property ("text", $1);
1926 lreq_p->set_mus_property ("duration",$2);
1927 lreq_p->set_spot (i);
1928 Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
1929 velt_p->set_mus_property ("elements", scm_list_n (lreq_p->self_scm (), SCM_UNDEFINED));
1934 Input i = THIS->pop_spot ();
1936 if (!THIS->lexer_p_->chord_state_b ())
1937 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1944 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1945 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1946 $$->set_spot (THIS->here_input ());
1953 | CHORD_COLON chord_notes {
1962 | chord_notes '.' chord_step {
1963 $$ = gh_append2 ($$, $3);
1971 | CHORD_CARET chord_notes {
1981 | '/' steno_tonic_pitch {
1990 | CHORD_BASS steno_tonic_pitch {
1997 $$ = gh_cons ($1, SCM_EOL);
1999 | CHORDMODIFIER_PITCH {
2000 $$ = gh_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2002 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2003 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2011 m.notename_i_ = ($1 - 1) % 7;
2012 m.octave_i_ = $1 > 7 ? 1 : 0;
2013 m.alteration_i_ = 0;
2015 $$ = m.smobbed_copy ();
2017 | bare_unsigned '+' {
2019 m.notename_i_ = ($1 - 1) % 7;
2020 m.octave_i_ = $1 > 7 ? 1 : 0;
2021 m.alteration_i_ = 1;
2024 $$ = m.smobbed_copy ();
2026 | bare_unsigned CHORD_MINUS {
2028 m.notename_i_ = ($1 - 1) % 7;
2029 m.octave_i_ = $1 > 7 ? 1 : 0;
2030 m.alteration_i_ = -1;
2032 $$ = m.smobbed_copy ();
2040 number_expression '+' number_term {
2041 $$ = scm_sum ($1, $3);
2043 | number_expression '-' number_term {
2044 $$ = scm_difference ($1, $3);
2053 | number_factor '*' number_factor {
2054 $$ = scm_product ($1, $3);
2056 | number_factor '/' number_factor {
2057 $$ = scm_divide ($1, $3);
2062 '(' number_expression ')' {
2065 | '-' number_factor { /* %prec UNARY_MINUS */
2066 $$ = scm_difference ($2, SCM_UNDEFINED);
2074 $$ = gh_int2scm ($1);
2079 | NUMBER_IDENTIFIER {
2083 $$ = gh_double2scm (gh_scm2double ($1) CM );
2086 $$ = gh_double2scm (gh_scm2double ($1) PT);
2089 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2092 $$ = gh_double2scm (gh_scm2double ($1) MM);
2095 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2111 if (scm_integer_p ($1) == SCM_BOOL_T)
2113 int k = gh_scm2int ($1);
2117 THIS->parser_error (_ ("need integer number arg"));
2131 | STRING_IDENTIFIER {
2134 | string '+' string {
2135 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2142 | exclamations '!' { $$ ++; }
2147 | questions '?' { $$ ++; }
2154 My_lily_parser::set_yydebug (bool )
2161 extern My_lily_parser * current_parser;
2164 My_lily_parser::do_yyparse ()
2167 current_parser = this;;
2168 yyparse ((void*)this);
2173 Should make this optional? It will also complain when you do
2177 which is entirely legitimate.
2179 Or we can scrap it. Barchecks should detect wrong durations, and
2180 skipTypesetting speeds it up a lot.
2183 My_lily_parser::beam_check (SCM dur)
2185 Duration *d = unsmob_duration (dur);
2186 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2188 Music * m = unsmob_music (last_beam_start_);
2189 m->origin ()->warning (_("Suspect duration found following this beam"));
2191 last_beam_start_ = SCM_EOL;