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 "input-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.to_str0 () ;
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_proc);
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 ()
115 // #include <malloc.h>
120 #define YYERROR_VERBOSE 1
122 #define YYPARSE_PARAM my_lily_parser
123 #define YYLEX_PARAM my_lily_parser
125 ((My_lily_parser *) my_lily_parser)
127 #define yyerror THIS->parser_error
131 /* We use SCMs to do strings, because it saves us the trouble of
132 deleting them. Let's hope that a stack overflow doesnt trigger a move
133 of the parse stack onto the heap. */
138 Link_array<Request> *reqvec;
140 String *string; // needed by the lexer as temporary scratch area.
143 Scheme_hash_table *scmhash;
144 Music_output_def * outputdef;
156 yylex (YYSTYPE *s, void * v)
158 My_lily_parser *pars = (My_lily_parser*) v;
159 My_lily_lexer * lex = pars->lexer_;
161 lex->lexval = (void*) s;
162 return lex->yylex ();
170 /* tokens which are not keywords */
180 %token CHORDMODIFIERS
188 %token GROBDESCRIPTIONS
194 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
195 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
205 %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 <i> E_UNSIGNED
248 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
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 <scm> 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
287 %type <scm> identifier_init
289 %type <scm> steno_duration optional_notemode_duration multiplied_duration
290 %type <scm> verbose_duration
292 %type <reqvec> pre_requests post_requests
293 %type <request> gen_text_def
294 %type <scm> steno_pitch pitch absolute_pitch
295 %type <scm> explicit_pitch steno_tonic_pitch
297 %type <scm> chord_additions chord_subtractions chord_notes chord_step
299 %type <scm> chord_note chord_inversion chord_bass
300 %type <scm> duration_length fraction
302 %type <scm> embedded_scm scalar
303 %type <music> Music Sequential_music Simultaneous_music
304 %type <music> relative_music re_rhythmed_music part_combined_music
305 %type <music> property_def translator_change simple_property_def
306 %type <scm> Music_list
307 %type <outputdef> music_output_def_body
308 %type <request> shorthand_command_req
309 %type <request> post_request
310 %type <music> command_req verbose_command_req
311 %type <request> extender_req
312 %type <request> hyphen_req
313 %type <request> string_request
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_ = 1;
341 THIS->error_level_ = 1;
347 THIS->lexer_->pitchname_tab_ = $1;
349 | chordmodifiers_block {
350 THIS->lexer_->chordmodifier_tab_ = $1;
353 THIS->input_file_->header_ = $1;
356 THIS->input_file_->scores_.push ($1);
359 if (dynamic_cast<Paper_def*> ($1))
360 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
361 else if (dynamic_cast<Midi_def*> ($1))
362 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
375 chordmodifiers_block:
376 CHORDMODIFIERS notenames_body { $$ = $2; }
380 PITCHNAMES notenames_body { $$ = $2; }
385 int i = scm_ilength ($1);
387 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
388 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
389 SCM pt = ly_cdar (s);
390 if (!unsmob_pitch (pt))
391 THIS->parser_error ("Need pitch object.");
393 scm_hashq_set_x (tab, ly_caar (s), pt);
400 lilypond_header_body:
402 $$ = ly_make_anonymous_module ();
403 THIS->lexer_->add_scope ($$);
405 | lilypond_header_body assignment {
411 HEADER '{' lilypond_header_body '}' {
412 $$ = THIS->lexer_-> remove_scope();
424 /* cont */ '=' identifier_init {
427 Should find generic way of associating input with objects.
429 Input ip = THIS->pop_spot ();
431 if (! regular_identifier_b ($1))
433 ip.warning (_ ("Identifier should have alphabetic characters only"));
436 THIS->lexer_->set_identifier ($1, $4);
439 TODO: devise standard for protection in parser.
441 The parser stack lives on the C-stack, which means that
442 all objects can be unprotected as soon as they're here.
452 $$ = $1->self_scm ();
453 scm_gc_unprotect_object ($$);
456 $$ = $1->self_scm ();
457 scm_gc_unprotect_object ($$);
459 | translator_spec_block {
463 $$ = $1->self_scm ();
464 scm_gc_unprotect_object ($$);
467 $$ = $1->self_scm ();
468 scm_gc_unprotect_object ($$);
473 | number_expression {
484 translator_spec_block:
485 TRANSLATOR '{' translator_spec_body '}'
491 translator_spec_body:
492 TRANSLATOR_IDENTIFIER {
493 $$ = unsmob_translator_def ($1)->clone_scm ();
494 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
497 $$ = Translator_def::make_scm ();
498 Translator_def*td = unsmob_translator_def ($$);
499 td->translator_group_type_ = $2;
500 td->set_spot (THIS->here_input ());
502 | translator_spec_body STRING '=' embedded_scm {
503 unsmob_translator_def ($$)->add_property_assign ($2, $4);
505 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
506 unsmob_translator_def ($$)
507 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
509 | translator_spec_body STRING SET 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_ = scm_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 (!$$->defs_.size ())
559 Music_output_def *id =
560 unsmob_music_output_def (THIS->lexer_->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 {
590 | score_body output_def {
603 music_output_def_body '}' {
605 THIS-> lexer_-> remove_scope ();
609 music_output_def_body:
611 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
616 p = dynamic_cast<Midi_def*> (id->clone ());
621 THIS->lexer_->add_scope (p->scope_);
624 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
627 p = dynamic_cast<Paper_def*> (id->clone ());
630 THIS-> lexer_->add_scope (p->scope_);
633 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
634 Music_output_def *p = unsmob_music_output_def ($3);
636 THIS->lexer_->add_scope (p->scope_);
639 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
640 Music_output_def *p = unsmob_music_output_def ($3);
643 THIS->lexer_->add_scope (p->scope_);
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 $$ = scm_cons (SCM_EOL, SCM_EOL);
691 SCM c = scm_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 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
746 we can not get durations and other stuff correct down the line, so we have to
747 add to the duration log here.
749 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
751 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
753 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
756 set_music_properties (r, result);
758 r->set_spot (*$4->origin ());
765 SEQUENTIAL '{' Music_list '}' {
766 $$ = new Sequential_music (SCM_EOL);
767 $$->set_mus_property ("elements", ly_car ($3));
768 $$->set_spot(THIS->here_input());
770 | '{' Music_list '}' {
771 $$ = new Sequential_music (SCM_EOL);
772 $$->set_mus_property ("elements", ly_car ($2));
773 $$->set_spot(THIS->here_input());
778 SIMULTANEOUS '{' Music_list '}'{
779 $$ = new Simultaneous_music (SCM_EOL);
780 $$->set_mus_property ("elements", ly_car ($3));
781 $$->set_spot(THIS->here_input());
784 | '<' Music_list '>' {
785 $$ = new Simultaneous_music (SCM_EOL);
786 $$->set_mus_property ("elements", ly_car ($2));
787 $$->set_spot(THIS->here_input());
792 request_chord { $$ = $1; }
793 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
795 if (!gh_symbol_p ($3))
797 THIS->parser_error (_ ("Second argument must be a symbol"));
799 /* Should check # args */
800 if (!gh_procedure_p (pred))
802 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
805 Music *m = new Music (SCM_EOL);
806 m->set_mus_property ("predicate", pred);
807 m->set_mus_property ("grob-property", $3);
808 m->set_mus_property ("grob-value", $5);
809 m->set_mus_property ("iterator-ctor",
810 Output_property_music_iterator::constructor_proc);
815 $$ = unsmob_music ($1)->clone ();
817 $$->set_spot (THIS->here_input());
825 CONTEXT STRING Music {
826 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
827 csm->set_mus_property ("element", $3->self_scm ());
828 scm_gc_unprotect_object ($3->self_scm ());
830 csm->set_mus_property ("context-type",$2);
831 csm->set_mus_property ("context-id", scm_makfrom0str (""));
835 | AUTOCHANGE STRING Music {
836 Music * chm = new Music_wrapper (SCM_EOL);
837 chm->set_mus_property ("element", $3->self_scm ());
838 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
840 scm_gc_unprotect_object ($3->self_scm ());
841 chm->set_mus_property ("what", $2);
844 chm->set_spot (*$3->origin ());
849 The other version is for easier debugging of
850 Sequential_music_iterator in combination with grace notes.
853 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
854 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
855 Music *startm = unsmob_music (start);
856 Music *stopm = unsmob_music (stop);
860 stopm = stopm->clone ();
861 ms = scm_cons (stopm->self_scm (), ms);
862 scm_gc_unprotect_object (stopm->self_scm ());
864 ms = scm_cons ($2->self_scm (), ms);
865 scm_gc_unprotect_object ($2->self_scm());
867 startm = startm->clone ();
868 ms = scm_cons (startm->self_scm () , ms);
869 scm_gc_unprotect_object (startm->self_scm ());
872 Music* seq = new Sequential_music (SCM_EOL);
873 seq->set_mus_property ("elements", ms);
875 $$ = new Grace_music (SCM_EOL);
876 $$->set_mus_property ("element", seq->self_scm ());
877 scm_gc_unprotect_object (seq->self_scm ());
879 $$ = new Grace_music (SCM_EOL);
880 $$->set_mus_property ("element", $2->self_scm ());
881 scm_gc_unprotect_object ($2->self_scm ());
884 | CONTEXT string '=' string Music {
885 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
886 csm->set_mus_property ("element", $5->self_scm ());
887 scm_gc_unprotect_object ($5->self_scm ());
889 csm->set_mus_property ("context-type", $2);
890 csm->set_mus_property ("context-id", $4);
901 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
903 $$ = new Time_scaled_music (SCM_EOL);
904 $$->set_spot (THIS->pop_spot ());
907 $$->set_mus_property ("element", mp->self_scm ());
908 scm_gc_unprotect_object (mp->self_scm ());
909 $$->set_mus_property ("numerator", gh_int2scm (n));
910 $$->set_mus_property ("denominator", gh_int2scm (d));
911 $$->compress (Moment (Rational (n,d)));
914 | Repeated_music { $$ = $1; }
915 | Simultaneous_music { $$ = $1; }
916 | Sequential_music { $$ = $1; }
917 | TRANSPOSE 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 ());
926 | TRANSPOSE steno_tonic_pitch Music {
927 $$ = new Transposed_music (SCM_EOL);
929 Pitch pit = *unsmob_pitch ($2);
932 $$->set_mus_property ("element", p->self_scm ());
933 scm_gc_unprotect_object (p->self_scm ());
936 | APPLY embedded_scm Music {
937 SCM ret = gh_call1 ($2, $3->self_scm ());
938 Music *m = unsmob_music (ret);
940 THIS->parser_error ("\\apply must return a Music");
941 m = new Music (SCM_EOL);
946 { THIS->lexer_->push_note_state (); }
949 THIS->lexer_->pop_state ();
952 { THIS->lexer_->push_figuredbass_state (); }
955 Music * chm = new Untransposable_music () ;
956 chm->set_mus_property ("element", $3->self_scm ());
958 scm_gc_unprotect_object ($3->self_scm());
960 THIS->lexer_->pop_state ();
963 { THIS->lexer_->push_chord_state (); }
966 Music * chm = new Un_relativable_music ;
967 chm->set_mus_property ("element", $3->self_scm ());
968 scm_gc_unprotect_object ($3->self_scm());
971 THIS->lexer_->pop_state ();
974 { THIS->lexer_->push_lyric_state (); }
978 THIS->lexer_->pop_state ();
980 | relative_music { $$ = $1; }
981 | re_rhythmed_music { $$ = $1; }
982 | part_combined_music { $$ = $1; }
986 RELATIVE absolute_pitch Music {
988 Pitch pit = *unsmob_pitch ($2);
989 $$ = new Relative_octave_music (SCM_EOL);
991 $$->set_mus_property ("element", p->self_scm ());
992 scm_gc_unprotect_object (p->self_scm ());
994 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1000 ADDLYRICS Music Music {
1001 Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
1002 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1003 scm_gc_unprotect_object ($3->self_scm ());
1004 scm_gc_unprotect_object ($2->self_scm ());
1009 part_combined_music:
1010 PARTCOMBINE STRING Music Music {
1011 Part_combine_music * p = new Part_combine_music (SCM_EOL);
1013 p->set_mus_property ("what", $2);
1014 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1016 scm_gc_unprotect_object ($3->self_scm ());
1017 scm_gc_unprotect_object ($4->self_scm ());
1024 TRANSLATOR STRING '=' STRING {
1025 Music * t = new Music (SCM_EOL);
1026 t->set_mus_property ("iterator-ctor",
1027 Change_iterator::constructor_proc);
1028 t-> set_mus_property ("change-to-type", $2);
1029 t-> set_mus_property ("change-to-id", $4);
1032 $$->set_spot (THIS->here_input ());
1038 | ONCE simple_property_def {
1040 SCM e = $2->get_mus_property ("element");
1041 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1045 simple_property_def:
1046 PROPERTY STRING '.' STRING '=' scalar {
1048 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1049 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1051 csm->set_mus_property ("element", t->self_scm ());
1052 scm_gc_unprotect_object (t->self_scm ());
1055 $$->set_spot (THIS->here_input ());
1057 csm-> set_mus_property ("context-type", $2);
1059 | PROPERTY STRING '.' STRING UNSET {
1060 Music *t = new Music (SCM_EOL);
1062 t->set_mus_property ("iterator-ctor",
1063 Property_unset_iterator::constructor_proc);
1064 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1066 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1067 csm->set_mus_property ("element", t->self_scm ());
1068 scm_gc_unprotect_object (t->self_scm ());
1071 $$->set_spot (THIS->here_input ());
1073 csm-> set_mus_property ("context-type", $2);
1075 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1077 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1078 bool itc = internal_type_checking_global_b;
1079 Music *t = new Music (SCM_EOL);
1080 t->set_mus_property ("iterator-ctor",
1081 Push_property_iterator::constructor_proc);
1082 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1083 t->set_mus_property ("pop-first", SCM_BOOL_T);
1085 internal_type_checking_global_b = false;
1086 t->set_mus_property ("grob-property", $6);
1088 internal_type_checking_global_b = itc;
1089 t->set_mus_property ("grob-value", $8);
1090 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1091 csm->set_mus_property ("element", t->self_scm ());
1092 scm_gc_unprotect_object (t->self_scm ());
1094 $$->set_spot (THIS->here_input ());
1096 csm-> set_mus_property ("context-type", $2);
1098 | PROPERTY STRING '.' STRING OVERRIDE
1099 embedded_scm '=' embedded_scm
1105 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1106 bool itc = internal_type_checking_global_b;
1108 Music *t = new Music (SCM_EOL);
1109 t->set_mus_property ("iterator-ctor",
1110 Push_property_iterator::constructor_proc);
1111 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1114 internal_type_checking_global_b = false;
1115 t->set_mus_property ("grob-property", $6);
1116 t->set_mus_property ("grob-value", $8);
1118 internal_type_checking_global_b = itc;
1120 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1121 csm->set_mus_property ("element", t->self_scm ());
1122 scm_gc_unprotect_object (t->self_scm ());
1125 $$->set_spot (THIS->here_input ());
1127 csm-> set_mus_property ("context-type", $2);
1130 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1131 Music *t = new Music (SCM_EOL);
1133 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1134 bool itc = internal_type_checking_global_b;
1136 t->set_mus_property ("iterator-ctor",
1137 Pop_property_iterator::constructor_proc);
1138 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1140 internal_type_checking_global_b = false;
1141 t->set_mus_property ("grob-property", $6);
1143 internal_type_checking_global_b = itc;
1145 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1146 csm->set_mus_property ("element", t->self_scm ());
1147 scm_gc_unprotect_object (t->self_scm ());
1150 $$->set_spot (THIS->here_input ());
1152 csm-> set_mus_property ("context-type", $2);
1159 | bare_int { $$ = gh_int2scm ($1); }
1160 | embedded_scm { $$ = $1; }
1167 } /*cont */ simple_element post_requests {
1168 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1171 for (int i=0; i < $1->size (); i++) {
1172 Music * m = $1->elem (i);
1173 l->append_music (m);
1185 $$ = new Request_chord (SCM_EOL);
1186 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1187 scm_gc_unprotect_object ($1->self_scm());
1189 $$-> set_spot (THIS->here_input ());
1190 $1-> set_spot (THIS->here_input ());
1193 Span_req *l = new Span_req;
1194 l->set_span_dir (START);
1195 l->set_mus_property ("span-type", scm_makfrom0str ("ligature"));
1196 l->set_spot (THIS->here_input ());
1198 $$ = new Request_chord (SCM_EOL);
1199 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1200 scm_gc_unprotect_object (l->self_scm());
1201 $$->set_spot (THIS->here_input ());
1204 Span_req *l = new Span_req;
1205 l->set_span_dir (STOP);
1206 l->set_mus_property ("span-type", scm_makfrom0str ("ligature"));
1207 l->set_spot (THIS->here_input ());
1209 $$ = new Request_chord (SCM_EOL);
1210 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1211 $$->set_spot (THIS->here_input ());
1212 scm_gc_unprotect_object (l->self_scm());
1216 $$ = new Music (gh_list (scm_cons (ly_symbol2scm ("name"), ly_symbol2scm ("separator")), SCM_UNDEFINED));
1217 $$->set_spot (THIS->here_input ());
1221 extern Music * get_barcheck();
1222 $$ = get_barcheck ();
1223 $$->set_spot (THIS->here_input ());
1226 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1228 Context_specced_music *csm = new Context_specced_music (SCM_EOL);
1229 csm->set_mus_property ("element", t->self_scm ());
1230 scm_gc_unprotect_object (t->self_scm ());
1233 $$->set_spot (THIS->here_input ());
1235 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1237 | PARTIAL duration_length {
1238 Moment m = - unsmob_duration ($2)->length_mom ();
1239 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1241 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1242 sp->set_mus_property ("element", p->self_scm ());
1243 scm_gc_unprotect_object (p->self_scm ());
1246 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1249 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1250 SCM result = gh_call1 (func, $2);
1253 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1254 Music * p = new Music (SCM_EOL);
1255 set_music_properties (p, ly_car (s));
1256 l = scm_cons (p->self_scm (), l);
1257 scm_gc_unprotect_object (p->self_scm ());
1259 Sequential_music * seq = new Sequential_music (SCM_EOL);
1260 seq->set_mus_property ("elements", l);
1262 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1263 sp->set_mus_property ("element", seq->self_scm ());
1264 scm_gc_unprotect_object (seq->self_scm ());
1267 sp-> set_mus_property ("context-type", scm_makfrom0str ("Staff"));
1270 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1272 int l = gh_scm2int (ly_car ($2));
1273 int o = gh_scm2int (ly_cdr ($2));
1275 Moment one_beat = Moment (1)/Moment (o);
1276 Moment len = Moment (l) * one_beat;
1279 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1280 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1282 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1283 Sequential_music *seq = new Sequential_music (SCM_EOL);
1284 seq->set_mus_property ("elements", list);
1287 Context_specced_music * sp = new Context_specced_music (SCM_EOL);
1288 sp->set_mus_property ("element", seq->self_scm ());
1290 scm_gc_unprotect_object (p3->self_scm ());
1291 scm_gc_unprotect_object (p2->self_scm ());
1292 scm_gc_unprotect_object (p1->self_scm ());
1293 scm_gc_unprotect_object (seq->self_scm ());
1297 sp-> set_mus_property ("context-type", scm_makfrom0str ( "Timing"));
1302 shorthand_command_req { $$ = $1; }
1303 | verbose_command_req { $$ = $1; }
1306 shorthand_command_req:
1317 Span_req*b= new Span_req;
1318 b->set_span_dir (START);
1319 b->set_mus_property ("span-type", scm_makfrom0str ("beam"));
1323 THIS->last_beam_start_ = b->self_scm ();
1326 Span_req*b= new Span_req;
1327 b->set_span_dir ( STOP);
1328 b->set_mus_property ("span-type", scm_makfrom0str ("beam"));
1332 $$ = new Breathing_sign_req;
1335 $$ = new Porrectus_req;
1339 verbose_command_req:
1340 COMMANDSPANREQUEST bare_int STRING { /*TODO: junkme */
1341 Span_req * sp = new Span_req;
1342 sp-> set_span_dir ( Direction ($2));
1343 sp->set_mus_property ("span-type",$3);
1344 sp->set_spot (THIS->here_input ());
1348 Mark_req * m = new Mark_req;
1352 Mark_req *m = new Mark_req;
1353 m->set_mus_property ("label", $2);
1357 Break_req * b = new Break_req;
1359 if (!gh_number_p (s))
1362 b->set_mus_property ("penalty", s);
1363 b->set_spot (THIS->here_input ());
1366 | SKIP duration_length {
1367 Skip_req * skip = new Skip_req;
1368 skip->set_mus_property ("duration", $2);
1376 Key_change_req *key= new Key_change_req;
1379 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1380 Key_change_req *key= new Key_change_req;
1382 key->set_mus_property ("pitch-alist", $3);
1383 ((Music*)key)->transpose (* unsmob_pitch ($2));
1390 $$ = new Link_array<Request>;
1392 | post_requests post_request {
1393 $2->set_spot (THIS->here_input ());
1408 String_number_req* s = new String_number_req;
1409 s->set_mus_property ("string-number", gh_int2scm($1));
1410 s->set_spot (THIS->here_input ());
1416 request_that_take_dir:
1419 | script_abbreviation {
1420 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1421 Articulation_req *a = new Articulation_req;
1422 if (gh_string_p (s))
1423 a->set_mus_property ("articulation-type", s);
1424 else THIS->parser_error (_ ("Expecting string as script definition"));
1430 script_dir request_that_take_dir {
1431 if (Script_req * gs = dynamic_cast<Script_req*> ($2))
1432 gs->set_direction (Direction ($1));
1434 $2->origin ()->warning (_ ("Can't specify direction for this request"));
1440 REQUEST_IDENTIFIER {
1441 $$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
1442 $$->set_spot (THIS->here_input ());
1444 | DYNAMICSCRIPT embedded_scm {
1446 TODO: junkme, use text-type == dynamic
1448 Text_script_req *d = new Text_script_req;
1449 SCM dyn = ly_symbol2scm ("dynamic");
1450 d->set_mus_property ("text-type" , dyn);
1451 d->set_mus_property ("text", $2);
1452 d->set_spot (THIS->here_input ());
1455 | SPANREQUEST bare_int STRING {
1456 Span_req * sp = new Span_req;
1457 sp->set_span_dir ( Direction ($2));
1458 sp->set_mus_property ("span-type", $3);
1459 sp->set_spot (THIS->here_input ());
1463 Tremolo_req* a = new Tremolo_req;
1464 a->set_spot (THIS->here_input ());
1465 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1469 Articulation_req * a = new Articulation_req;
1470 a->set_mus_property ("articulation-type", $2);
1471 a->set_spot (THIS->here_input ());
1475 duh, junk this syntax from the parser, if possible.
1478 Arpeggio_req *a = new Arpeggio_req;
1479 a->set_spot (THIS->here_input ());
1483 Glissando_req *g = new Glissando_req;
1484 g->set_spot /* No pun intended */ (THIS->here_input ());
1511 | NOTENAME_PITCH sup_quotes {
1512 Pitch p = *unsmob_pitch ($1);
1514 $$ = p.smobbed_copy ();
1516 | NOTENAME_PITCH sub_quotes {
1517 Pitch p =* unsmob_pitch ($1);
1520 $$ = p.smobbed_copy ();
1533 | TONICNAME_PITCH sup_quotes {
1534 Pitch p = *unsmob_pitch ($1);
1536 $$ = p.smobbed_copy ();
1538 | TONICNAME_PITCH sub_quotes {
1539 Pitch p =* unsmob_pitch ($1);
1542 $$ = p.smobbed_copy ();
1557 PITCH embedded_scm {
1559 if (!unsmob_pitch ($2)) {
1560 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1561 $$ = Pitch ().smobbed_copy ();
1567 DURATION embedded_scm {
1569 if (!unsmob_duration ($2))
1571 THIS->parser_error (_ ("Must have duration object"));
1572 $$ = Duration ().smobbed_copy ();
1579 if (!THIS->lexer_->lyric_state_b ())
1580 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1581 $$ = new Extender_req;
1587 if (!THIS->lexer_->lyric_state_b ())
1588 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1589 $$ = new Hyphen_req;
1594 close_request_parens {
1596 dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
1600 close_request_parens:
1602 Span_req* s= new Span_req;
1604 s->set_mus_property ("span-type", scm_makfrom0str ( "slur"));
1605 s->set_spot (THIS->here_input());
1608 Span_req* s= new Span_req;
1610 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1611 s->set_spot (THIS->here_input());
1614 Span_req*s =new Span_req;
1616 s->set_mus_property ("span-type", scm_makfrom0str ( "crescendo"));
1617 s->set_spot (THIS->here_input());
1620 Span_req*s =new Span_req;
1622 s->set_mus_property ("span-type", scm_makfrom0str ("decrescendo"));
1623 s->set_spot (THIS->here_input());
1629 open_request_parens {
1631 dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
1635 open_request_parens:
1637 Span_req *s = new Span_req;
1638 s->set_mus_property ("span-type", scm_makfrom0str ( "crescendo"));
1639 s->set_spot (THIS->here_input());
1644 Span_req* s= new Span_req;
1646 s->set_mus_property ("span-type", scm_makfrom0str ( "slur"));
1647 s->set_spot (THIS->here_input());
1651 Span_req* s= new Span_req;
1653 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1654 s->set_spot (THIS->here_input());
1660 Text_script_req *t = new Text_script_req;
1661 t->set_mus_property ("text", $1);
1662 t->set_spot (THIS->here_input ());
1666 Text_script_req *t = new Text_script_req;
1667 t->set_mus_property ("text", $1);
1668 t->set_spot (THIS->here_input ());
1672 String ds = to_string ($1);
1673 Text_script_req* t = new Text_script_req;
1674 SCM finger = ly_symbol2scm ("finger");
1675 t->set_mus_property ("text", scm_makfrom0str (ds.to_str0 ()));
1676 t->set_mus_property ("text-type" , finger);
1677 t->set_spot (THIS->here_input ());
1682 script_abbreviation:
1684 $$ = scm_makfrom0str ("Hat");
1687 $$ = scm_makfrom0str ("Plus");
1690 $$ = scm_makfrom0str ("Dash");
1693 $$ = scm_makfrom0str ("Bar");
1696 $$ = scm_makfrom0str ("Larger");
1699 $$ = scm_makfrom0str ("Dot");
1702 $$ = scm_makfrom0str ("Underscore");
1709 | '-' { $$ = CENTER; }
1714 $$ = new Link_array<Request>;
1716 | pre_requests open_request {
1728 multiplied_duration {
1731 | verbose_duration {
1736 optional_notemode_duration:
1738 Duration dd = THIS->default_duration_;
1739 $$ = dd.smobbed_copy ();
1741 THIS->beam_check ($$);
1743 | multiplied_duration {
1745 THIS->default_duration_ = *unsmob_duration ($$);
1747 THIS->beam_check ($$);
1749 | verbose_duration {
1751 THIS->default_duration_ = *unsmob_duration ($$);
1756 bare_unsigned dots {
1758 if (!is_duration_b ($1))
1759 THIS->parser_error (_f ("not a duration: %d", $1));
1763 $$ = Duration (l, $2).smobbed_copy ();
1765 | DURATION_IDENTIFIER dots {
1766 Duration *d =unsmob_duration ($1);
1767 Duration k (d->duration_log (),d->dot_count () + $2);
1768 $$ = k.smobbed_copy ();
1775 multiplied_duration:
1779 | multiplied_duration '*' bare_unsigned {
1780 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1782 | multiplied_duration '*' FRACTION {
1783 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1785 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1790 FRACTION { $$ = $1; }
1791 | UNSIGNED '/' UNSIGNED {
1792 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1810 | ':' bare_unsigned {
1811 if (!is_duration_b ($2))
1812 THIS->parser_error (_f ("not a duration: %d", $2));
1831 Bass_figure_req *bfr = new Bass_figure_req;
1832 $$ = bfr->self_scm();
1833 scm_gc_unprotect_object ($$);
1836 Bass_figure_req *bfr = new Bass_figure_req;
1837 $$ = bfr->self_scm();
1839 bfr->set_mus_property ("figure", gh_int2scm ($1));
1841 scm_gc_unprotect_object ($$);
1843 | bass_figure bass_mod {
1844 Music *m = unsmob_music ($1);
1846 SCM salter =m->get_mus_property ("alteration");
1847 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1848 m->set_mus_property ("alteration",
1849 gh_int2scm (alter + $2));
1851 m->set_mus_property ("alteration", gh_int2scm (0));
1859 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1864 | br_bass_figure ']' {
1866 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1874 | figure_list br_bass_figure {
1875 $$ = scm_cons ($2, $1);
1880 FIGURE_OPEN figure_list FIGURE_CLOSE {
1881 Music * m = new Request_chord (SCM_EOL);
1882 $2 = scm_reverse_x ($2, SCM_EOL);
1883 m->set_mus_property ("elements", $2);
1884 $$ = m->self_scm ();
1895 pitch exclamations questions optional_notemode_duration optional_rest {
1897 Input i = THIS->pop_spot ();
1898 if (!THIS->lexer_->note_state_b ())
1899 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1907 n->set_mus_property ("pitch", $1);
1908 n->set_mus_property ("duration", $4);
1912 n->set_mus_property ("cautionary", SCM_BOOL_T);
1913 if ($2 % 2 || $3 % 2)
1914 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1916 Simultaneous_music*v = new Request_chord (SCM_EOL);
1917 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1918 scm_gc_unprotect_object (n->self_scm());
1924 | figure_spec optional_notemode_duration {
1925 Music * m = unsmob_music ($1);
1926 Input i = THIS->pop_spot ();
1928 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1930 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1934 | RESTNAME optional_notemode_duration {
1936 Input i = THIS->pop_spot ();
1937 SCM e = SCM_UNDEFINED;
1938 if (ly_scm2string ($1) =="s") {
1940 Skip_req * skip = new Skip_req;
1941 skip->set_mus_property ("duration" ,$2);
1943 e = skip->self_scm ();
1946 Rest_req * rest_req = new Rest_req;
1947 rest_req->set_mus_property ("duration", $2);
1948 rest_req->set_spot (i);
1949 e = rest_req->self_scm ();
1951 Simultaneous_music* velt = new Request_chord (SCM_EOL);
1952 velt-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1957 | MULTI_MEASURE_REST optional_notemode_duration {
1960 Skip_req * sk = new Skip_req;
1961 sk->set_mus_property ("duration", $2);
1962 Span_req *sp1 = new Span_req;
1963 Span_req *sp2 = new Span_req;
1964 sp1-> set_span_dir ( START);
1965 sp2-> set_span_dir ( STOP);
1966 SCM r = scm_makfrom0str ("rest");
1967 sp1->set_mus_property ("span-type", r);
1968 sp2->set_mus_property ("span-type", r);
1970 Request_chord * rqc1 = new Request_chord (SCM_EOL);
1971 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1972 Request_chord * rqc2 = new Request_chord (SCM_EOL);
1973 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1974 Request_chord * rqc3 = new Request_chord (SCM_EOL);
1975 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1977 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1979 $$ = new Sequential_music (SCM_EOL);
1980 $$->set_mus_property ("elements", ms);
1982 | STRING optional_notemode_duration {
1983 Input i = THIS->pop_spot ();
1985 Lyric_req* lreq = new Lyric_req;
1986 lreq->set_mus_property ("text", $1);
1987 lreq->set_mus_property ("duration",$2);
1989 Simultaneous_music* velt = new Request_chord (SCM_EOL);
1990 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1995 Input i = THIS->pop_spot ();
1997 if (!THIS->lexer_->chord_state_b ())
1998 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2005 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
2006 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
2007 $$->set_spot (THIS->here_input ());
2014 | CHORD_COLON chord_notes {
2023 | chord_notes '.' chord_step {
2024 $$ = gh_append2 ($$, $3);
2032 | CHORD_CARET chord_notes {
2042 | CHORD_SLASH steno_tonic_pitch {
2051 | CHORD_BASS steno_tonic_pitch {
2058 $$ = scm_cons ($1, SCM_EOL);
2060 | CHORDMODIFIER_PITCH {
2061 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2063 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2064 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2072 m.notename_ = ($1 - 1) % 7;
2073 m.octave_ = $1 > 7 ? 1 : 0;
2076 $$ = m.smobbed_copy ();
2078 | bare_unsigned '+' {
2080 m.notename_ = ($1 - 1) % 7;
2081 m.octave_ = $1 > 7 ? 1 : 0;
2085 $$ = m.smobbed_copy ();
2087 | bare_unsigned CHORD_MINUS {
2089 m.notename_ = ($1 - 1) % 7;
2090 m.octave_ = $1 > 7 ? 1 : 0;
2093 $$ = m.smobbed_copy ();
2101 number_expression '+' number_term {
2102 $$ = scm_sum ($1, $3);
2104 | number_expression '-' number_term {
2105 $$ = scm_difference ($1, $3);
2114 | number_factor '*' number_factor {
2115 $$ = scm_product ($1, $3);
2117 | number_factor '/' number_factor {
2118 $$ = scm_divide ($1, $3);
2123 '(' number_expression ')' {
2126 | '-' number_factor { /* %prec UNARY_MINUS */
2127 $$ = scm_difference ($2, SCM_UNDEFINED);
2135 $$ = gh_int2scm ($1);
2140 | NUMBER_IDENTIFIER {
2144 $$ = gh_double2scm (gh_scm2double ($1) CM );
2147 $$ = gh_double2scm (gh_scm2double ($1) PT);
2150 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2153 $$ = gh_double2scm (gh_scm2double ($1) MM);
2156 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2172 if (scm_integer_p ($1) == SCM_BOOL_T)
2174 int k = gh_scm2int ($1);
2178 THIS->parser_error (_ ("need integer number arg"));
2192 | STRING_IDENTIFIER {
2195 | string '+' string {
2196 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2203 | exclamations '!' { $$ ++; }
2208 | questions '?' { $$ ++; }
2215 My_lily_parser::set_yydebug (bool )
2222 extern My_lily_parser * current_parser;
2225 My_lily_parser::do_yyparse ()
2228 current_parser = this;;
2229 yyparse ((void*)this);
2234 Should make this optional? It will also complain when you do
2238 which is entirely legitimate.
2240 Or we can scrap it. Barchecks should detect wrong durations, and
2241 skipTypesetting speeds it up a lot.
2244 My_lily_parser::beam_check (SCM dur)
2246 Duration *d = unsmob_duration (dur);
2247 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2249 Music * m = unsmob_music (last_beam_start_);
2250 m->origin ()->warning (_("Suspect duration found following this beam"));
2252 last_beam_start_ = SCM_EOL;