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"
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"
63 #include "ly-modules.hh"
66 regular_identifier_b (SCM id)
68 String str = ly_scm2string (id);
69 char const *s = str.to_str0 () ;
74 v = v && isalpha (*s);
84 return t && t == 1 << intlog2 (t);
88 set_music_properties (Music *p, SCM a)
90 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
92 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
98 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
101 set_property_music (SCM sym, SCM value)
103 Music * p = MY_MAKE_MUSIC("PropertySet");
104 p->set_mus_property ("symbol", sym);
105 p->set_mus_property ("value", value);
110 make_span_req (SCM name)
114 proc = scm_c_eval_string ("old-span-request->event");
115 SCM m = scm_call_1 (proc, name);
116 scm_gc_protect_object (m);
117 return unsmob_music (m);
120 // needed for bison.simple's malloc () and free ()
122 // #include <malloc.h>
127 #define YYERROR_VERBOSE 1
129 #define YYPARSE_PARAM my_lily_parser
130 #define YYLEX_PARAM my_lily_parser
132 ((My_lily_parser *) my_lily_parser)
134 #define yyerror THIS->parser_error
138 /* We use SCMs to do strings, because it saves us the trouble of
139 deleting them. Let's hope that a stack overflow doesnt trigger a move
140 of the parse stack onto the heap. */
145 Link_array<Music> *reqvec;
147 String *string; // needed by the lexer as temporary scratch area.
150 Scheme_hash_table *scmhash;
151 Music_output_def * outputdef;
158 yylex (YYSTYPE *s, void * v)
160 My_lily_parser *pars = (My_lily_parser*) v;
161 My_lily_lexer * lex = pars->lexer_;
163 lex->lexval = (void*) s;
164 return lex->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
220 %token OVERRIDE SET REVERT
233 %token COMMANDSPANREQUEST
235 %token OUTPUTPROPERTY
246 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
247 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
249 %token <i> E_UNSIGNED
250 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
253 %type <i> exclamations questions dots optional_rest
254 %type <i> bass_number bass_mod
255 %type <scm> br_bass_figure bass_figure figure_list figure_spec
257 %token <scm> NOTENAME_PITCH
258 %token <scm> TONICNAME_PITCH
259 %token <scm> CHORDMODIFIER_PITCH
260 %token <scm> DURATION_IDENTIFIER
261 %token <scm> FRACTION
262 %token <id> IDENTIFIER
265 %token <scm> SCORE_IDENTIFIER
266 %token <scm> MUSIC_OUTPUT_DEF_IDENTIFIER
268 %token <scm> NUMBER_IDENTIFIER
269 %token <scm> REQUEST_IDENTIFIER
270 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
271 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
272 %token <scm> RESTNAME
278 %type <outputdef> output_def
279 %type <scm> lilypond_header lilypond_header_body
280 %type <music> open_request_parens close_request_parens open_request close_request
281 %type <music> request_with_dir request_that_take_dir verbose_request
282 %type <i> sub_quotes sup_quotes
283 %type <music> simple_element request_chord command_element Simple_music Composite_music
284 %type <music> Repeated_music
285 %type <scm> Alternative_music
286 %type <i> tremolo_type
287 %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 <music> 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 simple_property_def
308 %type <scm> Music_list
309 %type <outputdef> music_output_def_body
310 %type <music> shorthand_command_req
311 %type <music> post_request
312 %type <music> command_req verbose_command_req
313 %type <music> extender_req
314 %type <music> hyphen_req
315 %type <music> string_request
316 %type <scm> string bare_number number_expression number_term number_factor
318 %type <score> score_block score_body
320 %type <scm> translator_spec_block translator_spec_body
321 %type <music> tempo_request
322 %type <scm> notenames_body notenames_block chordmodifiers_block
323 %type <scm> script_abbreviation
329 /* We don't assign precedence to / and *, because we might need varied
330 prec levels in different prods */
336 lilypond: /* empty */
337 | lilypond toplevel_expression {}
338 | lilypond assignment { }
340 THIS->error_level_ = 1;
343 THIS->error_level_ = 1;
349 THIS->lexer_->pitchname_tab_ = $1;
351 | chordmodifiers_block {
352 THIS->lexer_->chordmodifier_tab_ = $1;
355 THIS->input_file_->header_ = $1;
358 THIS->input_file_->scores_.push ($1);
361 if (dynamic_cast<Paper_def*> ($1))
362 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
363 else if (dynamic_cast<Midi_def*> ($1))
364 THIS->lexer_->set_identifier (scm_makfrom0str ("$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 $$ = ly_make_anonymous_module ();
405 THIS->lexer_->add_scope ($$);
407 | lilypond_header_body assignment {
413 HEADER '{' lilypond_header_body '}' {
414 $$ = THIS->lexer_-> remove_scope();
426 /* cont */ '=' identifier_init {
429 Should find generic way of associating input with objects.
431 Input ip = THIS->pop_spot ();
433 if (! regular_identifier_b ($1))
435 ip.warning (_ ("Identifier should have alphabetic characters only"));
438 THIS->lexer_->set_identifier ($1, $4);
441 TODO: devise standard for protection in parser.
443 The parser stack lives on the C-stack, which means that
444 all objects can be unprotected as soon as they're here.
454 $$ = $1->self_scm ();
455 scm_gc_unprotect_object ($$);
458 $$ = $1->self_scm ();
459 scm_gc_unprotect_object ($$);
461 | translator_spec_block {
465 $$ = $1->self_scm ();
466 scm_gc_unprotect_object ($$);
469 $$ = $1->self_scm ();
470 scm_gc_unprotect_object ($$);
475 | number_expression {
486 translator_spec_block:
487 TRANSLATOR '{' translator_spec_body '}'
493 translator_spec_body:
494 TRANSLATOR_IDENTIFIER {
495 $$ = unsmob_translator_def ($1)->clone_scm ();
496 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
499 $$ = Translator_def::make_scm ();
500 Translator_def*td = unsmob_translator_def ($$);
501 td->translator_group_type_ = $2;
502 td->set_spot (THIS->here_input ());
504 | translator_spec_body STRING '=' embedded_scm {
505 unsmob_translator_def ($$)->add_property_assign ($2, $4);
507 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
508 unsmob_translator_def ($$)
509 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
511 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
512 unsmob_translator_def ($$)
513 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
515 | translator_spec_body STRING REVERT embedded_scm {
516 unsmob_translator_def ($$)->add_pop_property (
517 scm_string_to_symbol ($2), $4);
519 | translator_spec_body NAME STRING {
520 unsmob_translator_def ($$)->type_name_ = $3;
522 | translator_spec_body CONSISTS STRING {
523 unsmob_translator_def ($$)->add_element ($3);
525 | translator_spec_body ALIAS STRING {
526 Translator_def*td = unsmob_translator_def ($$);
527 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
529 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
530 Translator_def*td = unsmob_translator_def($$);
531 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
532 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
533 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
535 | translator_spec_body CONSISTSEND STRING {
536 unsmob_translator_def ($$)->add_last_element ( $3);
538 | translator_spec_body ACCEPTS STRING {
539 unsmob_translator_def ($$)->set_acceptor ($3,true);
541 | translator_spec_body DENIES STRING {
542 unsmob_translator_def ($$)->set_acceptor ($3,false);
544 | translator_spec_body REMOVE STRING {
545 unsmob_translator_def ($$)->remove_element ($3);
556 /*cont*/ '{' score_body '}' {
559 if (!$$->defs_.size ())
561 Music_output_def *id =
562 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
563 $$->add_output (id ? id->clone () : new Paper_def );
572 $$->set_spot (THIS->here_input ());
573 SCM m = $1->self_scm ();
574 scm_gc_unprotect_object (m);
579 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
580 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
581 m = gh_call1 (gh_car (check_funcs), m);
586 $$ = new Score (*unsmob_score ($1));
587 $$->set_spot (THIS->here_input ());
589 | score_body lilypond_header {
592 | score_body output_def {
605 music_output_def_body '}' {
607 THIS-> lexer_-> remove_scope ();
611 music_output_def_body:
613 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
618 p = dynamic_cast<Midi_def*> (id->clone ());
623 THIS->lexer_->add_scope (p->scope_);
626 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
629 p = dynamic_cast<Paper_def*> (id->clone ());
632 THIS-> lexer_->add_scope (p->scope_);
635 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
636 Music_output_def *p = unsmob_music_output_def ($3);
638 THIS->lexer_->add_scope (p->scope_);
641 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
642 Music_output_def *p = unsmob_music_output_def ($3);
645 THIS->lexer_->add_scope (p->scope_);
648 | music_output_def_body assignment {
651 | music_output_def_body translator_spec_block {
652 $$->assign_translator ($2);
654 | music_output_def_body STYLESHEET embedded_scm {
655 dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
657 | music_output_def_body tempo_request {
659 junk this ? there already is tempo stuff in
662 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
663 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
664 Midi_def * md = dynamic_cast<Midi_def*> ($$);
666 md->set_tempo (d->length_mom (), m);
668 | music_output_def_body error {
674 TEMPO steno_duration '=' bare_unsigned {
675 $$ = MY_MAKE_MUSIC("TempoEvent");
676 $$->set_mus_property ("duration", $2);
677 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
682 The representation of a list is the
686 to have efficient append.
688 Music_list: /* empty */ {
689 $$ = scm_cons (SCM_EOL, SCM_EOL);
693 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
694 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
695 if (gh_pair_p (ly_cdr (s)))
696 gh_set_cdr_x (ly_cdr (s), c); /* append */
698 gh_set_car_x (s, c); /* set first cons */
699 gh_set_cdr_x (s, c) ; /* remember last cell */
715 | ALTERNATIVE '{' Music_list '}' {
721 REPEAT string bare_unsigned Music Alternative_music
725 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
726 if (times < scm_ilength (alts)) {
727 unsmob_music (gh_car (alts))
728 ->origin ()->warning (
729 _("More alternatives than repeats. Junking excess alternatives."));
730 alts = ly_truncate_list (times, alts);
733 Music *r = MY_MAKE_MUSIC("RepeatedMusic");
736 r-> set_mus_property ("element", beg->self_scm ());
737 scm_gc_unprotect_object (beg->self_scm ());
739 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
741 r-> set_mus_property ("elements",alts);
742 SCM func = scm_primitive_eval (ly_symbol2scm ("repeat-name-to-ctor"));
743 SCM result = gh_call1 (func, $2);
745 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
748 we can not get durations and other stuff correct down the line, so we have to
749 add to the duration log here.
751 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
753 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
755 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
758 set_music_properties (r, result);
760 r->set_spot (*$4->origin ());
767 SEQUENTIAL '{' Music_list '}' {
768 $$ = MY_MAKE_MUSIC("SequentialMusic");
769 $$->set_mus_property ("elements", ly_car ($3));
770 $$->set_spot(THIS->here_input());
772 | '{' Music_list '}' {
773 $$ = MY_MAKE_MUSIC("SequentialMusic");
774 $$->set_mus_property ("elements", ly_car ($2));
775 $$->set_spot(THIS->here_input());
780 SIMULTANEOUS '{' Music_list '}'{
781 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
782 $$->set_mus_property ("elements", ly_car ($3));
783 $$->set_spot(THIS->here_input());
786 | '<' Music_list '>' {
787 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
788 $$->set_mus_property ("elements", ly_car ($2));
789 $$->set_spot(THIS->here_input());
794 request_chord { $$ = $1; }
795 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
797 if (!gh_symbol_p ($3))
799 THIS->parser_error (_ ("Second argument must be a symbol"));
801 /* Should check # args */
802 if (!gh_procedure_p (pred))
804 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
807 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
808 m->set_mus_property ("predicate", pred);
809 m->set_mus_property ("grob-property", $3);
810 m->set_mus_property ("grob-value", $5);
815 $$ = unsmob_music ($1)->clone ();
817 $$->set_spot (THIS->here_input());
825 CONTEXT STRING Music {
826 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
828 csm->set_mus_property ("element", $3->self_scm ());
829 scm_gc_unprotect_object ($3->self_scm ());
831 csm->set_mus_property ("context-type",$2);
832 csm->set_mus_property ("context-id", scm_makfrom0str (""));
836 | AUTOCHANGE STRING Music {
837 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
838 chm->set_mus_property ("element", $3->self_scm ());
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 ());
873 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
874 seq->set_mus_property ("elements", ms);
877 $$ = MY_MAKE_MUSIC("GraceMusic");
878 $$->set_mus_property ("element", seq->self_scm ());
879 scm_gc_unprotect_object (seq->self_scm ());
881 $$ = MY_MAKE_MUSIC("GraceMusic");
882 $$->set_mus_property ("element", $2->self_scm ());
883 scm_gc_unprotect_object ($2->self_scm ());
886 | CONTEXT string '=' string Music {
887 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
889 csm->set_mus_property ("element", $5->self_scm ());
890 scm_gc_unprotect_object ($5->self_scm ());
892 csm->set_mus_property ("context-type", $2);
893 csm->set_mus_property ("context-id", $4);
904 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
906 $$= MY_MAKE_MUSIC("TimeScaledMusic");
907 $$->set_spot (THIS->pop_spot ());
910 $$->set_mus_property ("element", mp->self_scm ());
911 scm_gc_unprotect_object (mp->self_scm ());
912 $$->set_mus_property ("numerator", gh_int2scm (n));
913 $$->set_mus_property ("denominator", gh_int2scm (d));
914 $$->compress (Moment (Rational (n,d)));
917 | Repeated_music { $$ = $1; }
918 | Simultaneous_music { $$ = $1; }
919 | Sequential_music { $$ = $1; }
920 | TRANSPOSE pitch Music {
921 $$ = MY_MAKE_MUSIC("TransposedMusic");
923 Pitch pit = *unsmob_pitch ($2);
926 $$->set_mus_property ("element", p->self_scm ());
927 scm_gc_unprotect_object (p->self_scm ());
929 | TRANSPOSE steno_tonic_pitch Music {
930 $$ = MY_MAKE_MUSIC("TransposedMusic");
932 Pitch pit = *unsmob_pitch ($2);
935 $$->set_mus_property ("element", p->self_scm ());
936 scm_gc_unprotect_object (p->self_scm ());
939 | APPLY embedded_scm Music {
940 SCM ret = gh_call1 ($2, $3->self_scm ());
941 Music *m = unsmob_music (ret);
943 THIS->parser_error ("\\apply must return a Music");
944 m = MY_MAKE_MUSIC("Music");
949 { THIS->lexer_->push_note_state (); }
952 THIS->lexer_->pop_state ();
955 { THIS->lexer_->push_figuredbass_state (); }
958 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
959 chm->set_mus_property ("element", $3->self_scm ());
961 scm_gc_unprotect_object ($3->self_scm());
963 THIS->lexer_->pop_state ();
966 { THIS->lexer_->push_chord_state (); }
969 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
970 chm->set_mus_property ("element", $3->self_scm ());
971 scm_gc_unprotect_object ($3->self_scm());
974 THIS->lexer_->pop_state ();
977 { THIS->lexer_->push_lyric_state (); }
981 THIS->lexer_->pop_state ();
983 | relative_music { $$ = $1; }
984 | re_rhythmed_music { $$ = $1; }
985 | part_combined_music { $$ = $1; }
989 RELATIVE absolute_pitch Music {
991 Pitch pit = *unsmob_pitch ($2);
992 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
994 $$->set_mus_property ("element", p->self_scm ());
995 scm_gc_unprotect_object (p->self_scm ());
997 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
1003 ADDLYRICS Music Music {
1004 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1005 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1006 scm_gc_unprotect_object ($3->self_scm ());
1007 scm_gc_unprotect_object ($2->self_scm ());
1012 part_combined_music:
1013 PARTCOMBINE STRING Music Music {
1014 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1015 p->set_mus_property ("what", $2);
1016 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1018 scm_gc_unprotect_object ($3->self_scm ());
1019 scm_gc_unprotect_object ($4->self_scm ());
1026 TRANSLATOR STRING '=' STRING {
1027 Music*t= MY_MAKE_MUSIC("TranslatorChange");
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 {
1047 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1048 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1050 csm->set_mus_property ("element", t->self_scm ());
1051 scm_gc_unprotect_object (t->self_scm ());
1054 $$->set_spot (THIS->here_input ());
1056 csm-> set_mus_property ("context-type", $2);
1058 | PROPERTY STRING '.' STRING UNSET {
1060 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1061 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1063 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1064 csm->set_mus_property ("element", t->self_scm ());
1065 scm_gc_unprotect_object (t->self_scm ());
1068 $$->set_spot (THIS->here_input ());
1070 csm-> set_mus_property ("context-type", $2);
1072 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1074 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1075 bool itc = internal_type_checking_global_b;
1076 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1078 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1079 t->set_mus_property ("pop-first", SCM_BOOL_T);
1081 internal_type_checking_global_b = false;
1082 t->set_mus_property ("grob-property", $6);
1084 internal_type_checking_global_b = itc;
1085 t->set_mus_property ("grob-value", $8);
1087 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1088 csm->set_mus_property ("element", t->self_scm ());
1089 scm_gc_unprotect_object (t->self_scm ());
1091 $$->set_spot (THIS->here_input ());
1093 csm-> set_mus_property ("context-type", $2);
1095 | PROPERTY STRING '.' STRING OVERRIDE
1096 embedded_scm '=' embedded_scm
1102 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1103 bool itc = internal_type_checking_global_b;
1105 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1106 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1108 internal_type_checking_global_b = false;
1109 t->set_mus_property ("grob-property", $6);
1110 t->set_mus_property ("grob-value", $8);
1112 internal_type_checking_global_b = itc;
1114 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1115 csm->set_mus_property ("element", t->self_scm ());
1116 scm_gc_unprotect_object (t->self_scm ());
1119 $$->set_spot (THIS->here_input ());
1121 csm-> set_mus_property ("context-type", $2);
1124 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1125 Music *t = MY_MAKE_MUSIC("RevertProperty");
1127 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1128 bool itc = internal_type_checking_global_b;
1130 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1132 internal_type_checking_global_b = false;
1133 t->set_mus_property ("grob-property", $6);
1135 internal_type_checking_global_b = itc;
1137 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1138 csm->set_mus_property ("element", t->self_scm ());
1139 scm_gc_unprotect_object (t->self_scm ());
1142 $$->set_spot (THIS->here_input ());
1144 csm-> set_mus_property ("context-type", $2);
1151 | bare_int { $$ = gh_int2scm ($1); }
1152 | embedded_scm { $$ = $1; }
1159 } /*cont */ simple_element post_requests {
1160 Music_sequence *l = dynamic_cast<Music_sequence*> ($3);
1163 for (int i=0; i < $1->size (); i++) {
1164 Music * m = $1->elem (i);
1165 l->append_music (m);
1177 $$ = MY_MAKE_MUSIC("RequestChord");
1178 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1179 scm_gc_unprotect_object ($1->self_scm());
1181 $$-> set_spot (THIS->here_input ());
1182 $1-> set_spot (THIS->here_input ());
1185 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1186 l->set_mus_property ("span-direction", gh_int2scm (START));
1187 l->set_spot (THIS->here_input ());
1189 $$ = MY_MAKE_MUSIC("RequestChord");
1190 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1191 scm_gc_unprotect_object (l->self_scm());
1192 $$->set_spot (THIS->here_input ());
1195 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1196 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1197 l->set_spot (THIS->here_input ());
1199 $$ = MY_MAKE_MUSIC("RequestChord");
1200 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1201 $$->set_spot (THIS->here_input ());
1202 scm_gc_unprotect_object (l->self_scm());
1206 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1207 $$->set_spot (THIS->here_input ());
1211 $$ = MY_MAKE_MUSIC("BarCheck");
1212 $$->set_spot (THIS->here_input ());
1215 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1217 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1218 csm->set_mus_property ("element", t->self_scm ());
1219 scm_gc_unprotect_object (t->self_scm ());
1222 $$->set_spot (THIS->here_input ());
1224 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1226 | PARTIAL duration_length {
1227 Moment m = - unsmob_duration ($2)->length_mom ();
1228 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1230 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1231 sp->set_mus_property ("element", p->self_scm ());
1232 scm_gc_unprotect_object (p->self_scm ());
1235 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1238 SCM func = scm_primitive_eval (ly_symbol2scm ("clef-name-to-properties"));
1239 SCM result = gh_call1 (func, $2);
1242 for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
1243 Music * p = MY_MAKE_MUSIC("Music");
1244 set_music_properties (p, ly_car (s));
1245 l = scm_cons (p->self_scm (), l);
1246 scm_gc_unprotect_object (p->self_scm ());
1248 Music * seq = MY_MAKE_MUSIC("SequentialMusic");
1249 seq->set_mus_property ("elements", l);
1251 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1252 sp->set_mus_property ("element", seq->self_scm ());
1253 scm_gc_unprotect_object (seq->self_scm ());
1256 sp-> set_mus_property ("context-type", scm_makfrom0str ("Staff"));
1259 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1261 int l = gh_scm2int (ly_car ($2));
1262 int o = gh_scm2int (ly_cdr ($2));
1264 Moment one_beat = Moment (1)/Moment (o);
1265 Moment len = Moment (l) * one_beat;
1268 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1269 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1271 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1272 Music *seq = MY_MAKE_MUSIC("SequentialMusic");
1273 seq->set_mus_property ("elements", list);
1276 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1277 sp->set_mus_property ("element", seq->self_scm ());
1279 scm_gc_unprotect_object (p3->self_scm ());
1280 scm_gc_unprotect_object (p2->self_scm ());
1281 scm_gc_unprotect_object (p1->self_scm ());
1282 scm_gc_unprotect_object (seq->self_scm ());
1286 sp-> set_mus_property ("context-type", scm_makfrom0str ( "Timing"));
1291 shorthand_command_req { $$ = $1; }
1292 | verbose_command_req { $$ = $1; }
1295 shorthand_command_req:
1303 $$ = MY_MAKE_MUSIC("TieEvent");
1306 Music *b= MY_MAKE_MUSIC("BeamEvent");
1307 b->set_mus_property ("span-direction", gh_int2scm (START))
1312 THIS->last_beam_start_ = b->self_scm ();
1315 Music *b= MY_MAKE_MUSIC("BeamEvent");
1316 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1320 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1323 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1327 verbose_command_req:
1328 COMMANDSPANREQUEST bare_int STRING {
1329 Music *sp = make_span_req ($3);
1330 sp->set_mus_property ("span-direction", gh_int2scm (Direction ($2)));
1331 sp->set_spot (THIS->here_input ());
1335 Music * m = MY_MAKE_MUSIC("MarkEvent");
1339 Music *m = MY_MAKE_MUSIC("MarkEvent");
1340 m->set_mus_property ("label", $2);
1344 Music * b = MY_MAKE_MUSIC("BreakEvent");
1346 if (!gh_number_p (s))
1349 b->set_mus_property ("penalty", s);
1350 b->set_spot (THIS->here_input ());
1353 | SKIP duration_length {
1354 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1355 skip->set_mus_property ("duration", $2);
1363 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1366 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1367 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1369 key->set_mus_property ("pitch-alist", $3);
1370 ((Music*)key)->transpose (* unsmob_pitch ($2));
1377 $$ = new Link_array<Music>;
1379 | post_requests post_request {
1380 $2->set_spot (THIS->here_input ());
1395 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1396 s->set_mus_property ("string-number", gh_int2scm($1));
1397 s->set_spot (THIS->here_input ());
1403 request_that_take_dir:
1406 | script_abbreviation {
1407 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1408 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1409 if (gh_string_p (s))
1410 a->set_mus_property ("articulation-type", s);
1411 else THIS->parser_error (_ ("Expecting string as script definition"));
1417 script_dir request_that_take_dir {
1418 $2->set_mus_property ("direction", gh_int2scm ($1));
1424 REQUEST_IDENTIFIER {
1425 $$ = unsmob_music ($1)->clone ();
1426 $$->set_spot (THIS->here_input ());
1428 | DYNAMICSCRIPT embedded_scm {
1430 TODO: junkme, use text-type == dynamic
1432 Music *d = MY_MAKE_MUSIC("TextScriptEvent");
1433 SCM dyn = ly_symbol2scm ("dynamic");
1434 d->set_mus_property ("text-type" , dyn);
1435 d->set_mus_property ("text", $2);
1436 d->set_spot (THIS->here_input ());
1439 | SPANREQUEST bare_int STRING {
1441 Music * sp = make_span_req ($3);
1442 sp->set_mus_property ("span-direction", gh_int2scm ( $2));
1443 sp->set_spot (THIS->here_input ());
1447 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1448 a->set_spot (THIS->here_input ());
1449 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1453 Music * a = MY_MAKE_MUSIC("ArticulationEvent");
1454 a->set_mus_property ("articulation-type", $2);
1455 a->set_spot (THIS->here_input ());
1460 duh, junk this syntax from the parser, if possible.
1463 Music *a = MY_MAKE_MUSIC("ArpeggioEvent");
1464 a->set_spot (THIS->here_input ());
1468 Music *g = MY_MAKE_MUSIC("GlissandoEvent");
1469 g->set_spot /* No pun intended */ (THIS->here_input ());
1496 | NOTENAME_PITCH sup_quotes {
1497 Pitch p = *unsmob_pitch ($1);
1499 $$ = p.smobbed_copy ();
1501 | NOTENAME_PITCH sub_quotes {
1502 Pitch p =* unsmob_pitch ($1);
1505 $$ = p.smobbed_copy ();
1518 | TONICNAME_PITCH sup_quotes {
1519 Pitch p = *unsmob_pitch ($1);
1521 $$ = p.smobbed_copy ();
1523 | TONICNAME_PITCH sub_quotes {
1524 Pitch p =* unsmob_pitch ($1);
1527 $$ = p.smobbed_copy ();
1542 PITCH embedded_scm {
1544 if (!unsmob_pitch ($2)) {
1545 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1546 $$ = Pitch ().smobbed_copy ();
1552 DURATION embedded_scm {
1554 if (!unsmob_duration ($2))
1556 THIS->parser_error (_ ("Must have duration object"));
1557 $$ = Duration ().smobbed_copy ();
1564 if (!THIS->lexer_->lyric_state_b ())
1565 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1566 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1572 if (!THIS->lexer_->lyric_state_b ())
1573 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1574 $$ = MY_MAKE_MUSIC("HyphenEvent");
1579 close_request_parens {
1581 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1586 close_request_parens:
1588 Music * s= MY_MAKE_MUSIC("SlurEvent");
1590 s->set_spot (THIS->here_input());
1593 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1595 s->set_spot (THIS->here_input());
1598 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1600 s->set_spot (THIS->here_input());
1603 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1605 s->set_spot (THIS->here_input());
1611 open_request_parens {
1613 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1618 open_request_parens:
1620 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1621 s->set_spot (THIS->here_input());
1626 Music * s= MY_MAKE_MUSIC("SlurEvent");
1628 s->set_spot (THIS->here_input());
1632 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1634 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1635 s->set_spot (THIS->here_input());
1641 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1642 t->set_mus_property ("text", $1);
1643 t->set_spot (THIS->here_input ());
1647 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1648 t->set_mus_property ("text", $1);
1649 t->set_spot (THIS->here_input ());
1653 String ds = to_string ($1);
1654 Music * t = MY_MAKE_MUSIC("TextScriptEvent");
1655 SCM finger = ly_symbol2scm ("finger");
1656 t->set_mus_property ("text", scm_makfrom0str (ds.to_str0 ()));
1657 t->set_mus_property ("text-type" , finger);
1658 t->set_spot (THIS->here_input ());
1663 script_abbreviation:
1665 $$ = scm_makfrom0str ("Hat");
1668 $$ = scm_makfrom0str ("Plus");
1671 $$ = scm_makfrom0str ("Dash");
1674 $$ = scm_makfrom0str ("Bar");
1677 $$ = scm_makfrom0str ("Larger");
1680 $$ = scm_makfrom0str ("Dot");
1683 $$ = scm_makfrom0str ("Underscore");
1690 | '-' { $$ = CENTER; }
1695 $$ = new Link_array<Music>;
1697 | pre_requests open_request {
1709 multiplied_duration {
1712 | verbose_duration {
1717 optional_notemode_duration:
1719 Duration dd = THIS->default_duration_;
1720 $$ = dd.smobbed_copy ();
1722 THIS->beam_check ($$);
1724 | multiplied_duration {
1726 THIS->default_duration_ = *unsmob_duration ($$);
1728 THIS->beam_check ($$);
1730 | verbose_duration {
1732 THIS->default_duration_ = *unsmob_duration ($$);
1737 bare_unsigned dots {
1739 if (!is_duration_b ($1))
1740 THIS->parser_error (_f ("not a duration: %d", $1));
1744 $$ = Duration (l, $2).smobbed_copy ();
1746 | DURATION_IDENTIFIER dots {
1747 Duration *d =unsmob_duration ($1);
1748 Duration k (d->duration_log (),d->dot_count () + $2);
1749 $$ = k.smobbed_copy ();
1756 multiplied_duration:
1760 | multiplied_duration '*' bare_unsigned {
1761 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1763 | multiplied_duration '*' FRACTION {
1764 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1766 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1771 FRACTION { $$ = $1; }
1772 | UNSIGNED '/' UNSIGNED {
1773 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1791 | ':' bare_unsigned {
1792 if (!is_duration_b ($2))
1793 THIS->parser_error (_f ("not a duration: %d", $2));
1812 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1813 $$ = bfr->self_scm();
1814 scm_gc_unprotect_object ($$);
1817 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1818 $$ = bfr->self_scm();
1820 bfr->set_mus_property ("figure", gh_int2scm ($1));
1822 scm_gc_unprotect_object ($$);
1824 | bass_figure bass_mod {
1825 Music *m = unsmob_music ($1);
1827 SCM salter =m->get_mus_property ("alteration");
1828 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1829 m->set_mus_property ("alteration",
1830 gh_int2scm (alter + $2));
1832 m->set_mus_property ("alteration", gh_int2scm (0));
1840 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1845 | br_bass_figure ']' {
1847 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1855 | figure_list br_bass_figure {
1856 $$ = scm_cons ($2, $1);
1861 FIGURE_OPEN figure_list FIGURE_CLOSE {
1862 Music * m = MY_MAKE_MUSIC("RequestChord");
1863 $2 = scm_reverse_x ($2, SCM_EOL);
1864 m->set_mus_property ("elements", $2);
1865 $$ = m->self_scm ();
1876 pitch exclamations questions optional_notemode_duration optional_rest {
1878 Input i = THIS->pop_spot ();
1879 if (!THIS->lexer_->note_state_b ())
1880 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1884 n = MY_MAKE_MUSIC("RestEvent");
1886 n = MY_MAKE_MUSIC("NoteEvent");
1888 n->set_mus_property ("pitch", $1);
1889 n->set_mus_property ("duration", $4);
1893 n->set_mus_property ("cautionary", SCM_BOOL_T);
1894 if ($2 % 2 || $3 % 2)
1895 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1897 Music *v = MY_MAKE_MUSIC("RequestChord");
1898 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1899 scm_gc_unprotect_object (n->self_scm());
1905 | figure_spec optional_notemode_duration {
1906 Music * m = unsmob_music ($1);
1907 Input i = THIS->pop_spot ();
1909 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1911 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1915 | RESTNAME optional_notemode_duration {
1917 Input i = THIS->pop_spot ();
1918 SCM e = SCM_UNDEFINED;
1919 if (ly_scm2string ($1) =="s") {
1921 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1922 skip->set_mus_property ("duration" ,$2);
1924 e = skip->self_scm ();
1927 Music * rest_req = MY_MAKE_MUSIC("RestEvent");
1928 rest_req->set_mus_property ("duration", $2);
1929 rest_req->set_spot (i);
1930 e = rest_req->self_scm ();
1932 Music * velt = MY_MAKE_MUSIC("RequestChord");
1933 velt-> set_mus_property ("elements", scm_list_n (e,SCM_UNDEFINED));
1938 | MULTI_MEASURE_REST optional_notemode_duration {
1941 Music * sk = MY_MAKE_MUSIC("SkipEvent");
1942 sk->set_mus_property ("duration", $2);
1943 Music *sp1 = MY_MAKE_MUSIC("MultiMeasureRestEvent");
1944 Music *sp2 = MY_MAKE_MUSIC("MultiMeasureRestEvent");
1945 sp1-> set_mus_property ("span-direction", gh_int2scm (START))
1947 sp2-> set_mus_property ("span-direction", gh_int2scm (STOP))
1949 Music *rqc1 = MY_MAKE_MUSIC("RequestChord");
1950 rqc1->set_mus_property ("elements", scm_list_n (sp1->self_scm (), SCM_UNDEFINED));
1951 Music *rqc2 = MY_MAKE_MUSIC("RequestChord");
1952 rqc2->set_mus_property ("elements", scm_list_n (sk->self_scm (), SCM_UNDEFINED));;
1953 Music *rqc3 = MY_MAKE_MUSIC("RequestChord");
1954 rqc3->set_mus_property ("elements", scm_list_n (sp2->self_scm (), SCM_UNDEFINED));;
1956 SCM ms = scm_list_n (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
1958 $$ = MY_MAKE_MUSIC("SequentialMusic");
1959 $$->set_mus_property ("elements", ms);
1961 | STRING optional_notemode_duration {
1962 Input i = THIS->pop_spot ();
1964 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1965 lreq->set_mus_property ("text", $1);
1966 lreq->set_mus_property ("duration",$2);
1968 Music * velt = MY_MAKE_MUSIC("RequestChord");
1969 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1976 if (!THIS->lexer_->chord_state_b ())
1977 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1984 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1985 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1986 $$->set_spot (THIS->here_input ());
1993 | CHORD_COLON chord_notes {
2002 | chord_notes '.' chord_step {
2003 $$ = gh_append2 ($$, $3);
2011 | CHORD_CARET chord_notes {
2021 | CHORD_SLASH steno_tonic_pitch {
2030 | CHORD_BASS steno_tonic_pitch {
2037 $$ = scm_cons ($1, SCM_EOL);
2039 | CHORDMODIFIER_PITCH {
2040 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2042 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2043 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2051 m.notename_ = ($1 - 1) % 7;
2052 m.octave_ = $1 > 7 ? 1 : 0;
2055 $$ = m.smobbed_copy ();
2057 | bare_unsigned '+' {
2059 m.notename_ = ($1 - 1) % 7;
2060 m.octave_ = $1 > 7 ? 1 : 0;
2064 $$ = m.smobbed_copy ();
2066 | bare_unsigned CHORD_MINUS {
2068 m.notename_ = ($1 - 1) % 7;
2069 m.octave_ = $1 > 7 ? 1 : 0;
2072 $$ = m.smobbed_copy ();
2080 number_expression '+' number_term {
2081 $$ = scm_sum ($1, $3);
2083 | number_expression '-' number_term {
2084 $$ = scm_difference ($1, $3);
2093 | number_factor '*' number_factor {
2094 $$ = scm_product ($1, $3);
2096 | number_factor '/' number_factor {
2097 $$ = scm_divide ($1, $3);
2102 '(' number_expression ')' {
2105 | '-' number_factor { /* %prec UNARY_MINUS */
2106 $$ = scm_difference ($2, SCM_UNDEFINED);
2114 $$ = gh_int2scm ($1);
2119 | NUMBER_IDENTIFIER {
2123 $$ = gh_double2scm (gh_scm2double ($1) CM );
2126 $$ = gh_double2scm (gh_scm2double ($1) PT);
2129 $$ = gh_double2scm (gh_scm2double ($1) INCH);
2132 $$ = gh_double2scm (gh_scm2double ($1) MM);
2135 $$ = gh_double2scm (gh_scm2double ($1) CHAR);
2151 if (scm_integer_p ($1) == SCM_BOOL_T)
2153 int k = gh_scm2int ($1);
2157 THIS->parser_error (_ ("need integer number arg"));
2171 | STRING_IDENTIFIER {
2174 | string '+' string {
2175 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2182 | exclamations '!' { $$ ++; }
2187 | questions '?' { $$ ++; }
2194 My_lily_parser::set_yydebug (bool )
2201 extern My_lily_parser * current_parser;
2204 My_lily_parser::do_yyparse ()
2207 current_parser = this;;
2208 yyparse ((void*)this);
2213 Should make this optional? It will also complain when you do
2217 which is entirely legitimate.
2219 Or we can scrap it. Barchecks should detect wrong durations, and
2220 skipTypesetting speeds it up a lot.
2223 My_lily_parser::beam_check (SCM dur)
2225 Duration *d = unsmob_duration (dur);
2226 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2228 Music * m = unsmob_music (last_beam_start_);
2229 m->origin ()->warning (_("Suspect duration found following this beam"));
2231 last_beam_start_ = SCM_EOL;