1 %{ // -*-Fundamental-*-
4 parser.yy -- Bison/C++ parser for lilypond
6 source file of the GNU LilyPond music typesetter
8 (c) 1997--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
9 Jan Nieuwenhuizen <janneke@gnu.org>
13 Two shift/reduce problems:
25 "bar" -> String -> Lyric -> Music
31 \repeat .. \alternative
34 \repeat { \repeat .. \alternative }
38 \repeat { \repeat } \alternative
50 * The rules for who is protecting what are very shady. Uniformise
53 * There are too many lexical modes.
60 #include "translator-def.hh"
61 #include "lily-guile.hh"
63 #include "my-lily-lexer.hh"
64 #include "paper-def.hh"
65 #include "midi-def.hh"
67 #include "file-path.hh"
69 #include "dimensions.hh"
70 #include "my-lily-parser.hh"
72 #include "input-file-results.hh"
74 #include "lilypond-input-version.hh"
75 #include "scm-hash.hh"
76 #include "auto-change-iterator.hh"
78 #include "ly-modules.hh"
79 #include "music-sequence.hh"
80 #include "input-smob.hh"
84 regular_identifier_b (SCM id)
86 String str = ly_scm2string (id);
87 char const *s = str.to_str0 () ;
92 v = v && isalpha (*s);
101 is_duration_b (int t)
103 return t && t == 1 << intlog2 (t);
107 set_music_properties (Music *p, SCM a)
109 for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
111 p->internal_set_mus_property (ly_caar (k), ly_cdar (k));
117 #define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
120 set_property_music (SCM sym, SCM value)
122 Music * p = MY_MAKE_MUSIC("PropertySet");
123 p->set_mus_property ("symbol", sym);
124 p->set_mus_property ("value", value);
129 // needed for bison.simple's malloc () and free ()
131 // #include <malloc.h>
136 #define YYERROR_VERBOSE 1
138 My_lily_parser* my_lily_parser;
139 #define YYPARSE_PARAM my_lily_parser
140 #define YYLEX_PARAM my_lily_parser
142 ((My_lily_parser *) my_lily_parser)
144 #define yyerror THIS->parser_error
148 /* We use SCMs to do strings, because it saves us the trouble of
149 deleting them. Let's hope that a stack overflow doesnt trigger a move
150 of the parse stack onto the heap. */
157 Music_output_def * outputdef;
164 yylex (YYSTYPE *s, void * v)
166 My_lily_parser *pars = (My_lily_parser*) v;
167 My_lily_lexer * lex = pars->lexer_;
169 lex->lexval = (void*) s;
170 lex->prepare_for_next_token();
171 return lex->yylex ();
179 /* tokens which are not keywords */
187 %token CHORDMODIFIERS
193 %token GROBDESCRIPTIONS
198 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
199 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
207 %token MULTI_MEASURE_REST
218 %token OVERRIDE SET REVERT
228 %token COMMANDSPANREQUEST
230 %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 <i> E_UNSIGNED
249 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
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
266 %token <scm> NUMBER_IDENTIFIER
267 %token <scm> EVENT_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 <music> open_event_parens close_event_parens open_event close_event
279 %type <music> event_with_dir event_that_take_dir verbose_event
280 %type <i> sub_quotes sup_quotes
281 %type <music> simple_element event_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 <music> note_chord_element chord_body chord_body_element
290 %type <scm> chord_body_elements
291 %type <scm> steno_duration optional_notemode_duration multiplied_duration
292 %type <scm> verbose_duration
294 %type <scm> pre_events post_events
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_event
312 %type <music> command_req verbose_command_req
313 %type <music> extender_req
314 %type <music> hyphen_req
315 %type <music> string_event
316 %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 <music> tempo_event
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_ = 1;
342 THIS->error_level_ = 1;
348 THIS->lexer_->pitchname_tab_ = $1;
350 | chordmodifiers_block {
351 THIS->lexer_->chordmodifier_tab_ = $1;
354 THIS->input_file_->header_ = $1;
357 THIS->input_file_->scores_.push ($1);
360 if (dynamic_cast<Paper_def*> ($1))
361 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultpaper"), $1->self_scm ());
362 else if (dynamic_cast<Midi_def*> ($1))
363 THIS->lexer_->set_identifier (scm_makfrom0str ("$defaultmidi"), $1->self_scm ());
373 chordmodifiers_block:
374 CHORDMODIFIERS notenames_body { $$ = $2; }
378 PITCHNAMES notenames_body { $$ = $2; }
383 int i = scm_ilength ($1);
385 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
386 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
387 SCM pt = ly_cdar (s);
388 if (!unsmob_pitch (pt))
389 THIS->parser_error ("Need pitch object.");
391 scm_hashq_set_x (tab, ly_caar (s), pt);
398 lilypond_header_body:
400 $$ = ly_make_anonymous_module ();
401 THIS->lexer_->add_scope ($$);
403 | lilypond_header_body assignment {
409 HEADER '{' lilypond_header_body '}' {
410 $$ = THIS->lexer_-> remove_scope();
422 /* cont */ '=' identifier_init {
425 Should find generic way of associating input with objects.
427 Input ip = THIS->pop_spot ();
429 if (! regular_identifier_b ($1))
431 ip.warning (_ ("Identifier should have alphabetic characters only"));
434 THIS->lexer_->set_identifier ($1, $4);
437 TODO: devise standard for protection in parser.
439 The parser stack lives on the C-stack, which means that
440 all objects can be unprotected as soon as they're here.
451 $$ = $1->self_scm ();
452 scm_gc_unprotect_object ($$);
455 $$ = $1->self_scm ();
456 scm_gc_unprotect_object ($$);
458 | translator_spec_block {
462 $$ = $1->self_scm ();
463 scm_gc_unprotect_object ($$);
466 $$ = $1->self_scm ();
467 scm_gc_unprotect_object ($$);
472 | number_expression {
483 translator_spec_block:
484 TRANSLATOR '{' translator_spec_body '}'
490 translator_spec_body:
491 TRANSLATOR_IDENTIFIER {
493 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
496 $$ = Translator_def::make_scm ();
497 Translator_def*td = unsmob_translator_def ($$);
498 td->translator_group_type_ = $2;
499 td->set_spot (THIS->here_input ());
501 | translator_spec_body STRING '=' embedded_scm {
502 unsmob_translator_def ($$)->add_property_assign ($2, $4);
504 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
505 unsmob_translator_def ($$)
506 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
508 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
509 unsmob_translator_def ($$)
510 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
512 | translator_spec_body STRING REVERT embedded_scm {
513 unsmob_translator_def ($$)->add_pop_property (
514 scm_string_to_symbol ($2), $4);
516 | translator_spec_body NAME STRING {
517 unsmob_translator_def ($$)->type_name_ = $3;
519 | translator_spec_body CONSISTS STRING {
520 unsmob_translator_def ($$)->add_element ($3);
522 | translator_spec_body ALIAS STRING {
523 Translator_def*td = unsmob_translator_def ($$);
524 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
526 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
527 Translator_def*td = unsmob_translator_def($$);
528 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
529 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
530 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
532 | translator_spec_body CONSISTSEND STRING {
533 unsmob_translator_def ($$)->add_last_element ( $3);
535 | translator_spec_body ACCEPTS STRING {
536 unsmob_translator_def ($$)->set_acceptor ($3,true);
538 | translator_spec_body DENIES STRING {
539 unsmob_translator_def ($$)->set_acceptor ($3,false);
541 | translator_spec_body REMOVE STRING {
542 unsmob_translator_def ($$)->remove_element ($3);
553 /*cont*/ '{' score_body '}' {
556 if (!$$->defs_.size ())
558 Music_output_def *id =
559 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
560 $$->add_output (id ? id->clone () : new Paper_def );
569 $$->set_spot (THIS->here_input ());
570 SCM m = $1->self_scm ();
571 scm_gc_unprotect_object (m);
576 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
577 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
578 m = gh_call1 (gh_car (check_funcs), m);
583 $$ = unsmob_score ($1);
584 $$->set_spot (THIS->here_input ());
586 | score_body lilypond_header {
589 | score_body output_def {
602 music_output_def_body '}' {
604 THIS-> lexer_-> remove_scope ();
608 music_output_def_body:
610 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
615 p = dynamic_cast<Midi_def*> (id->clone ());
620 THIS->lexer_->add_scope (p->scope_);
623 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
626 p = dynamic_cast<Paper_def*> (id->clone ());
630 THIS->lexer_->add_scope (p->scope_);
633 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
634 Music_output_def * o = unsmob_music_output_def ($3);
637 THIS->lexer_->add_scope (o->scope_);
639 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
640 Music_output_def * o = unsmob_music_output_def ($3);
643 THIS->lexer_->add_scope (o->scope_);
645 | music_output_def_body assignment {
648 | music_output_def_body translator_spec_block {
649 $$->assign_translator ($2);
651 | music_output_def_body tempo_event {
653 junk this ? there already is tempo stuff in
656 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
657 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
658 Midi_def * md = dynamic_cast<Midi_def*> ($$);
660 md->set_tempo (d->get_length (), m);
662 | music_output_def_body error {
668 TEMPO steno_duration '=' bare_unsigned {
669 $$ = MY_MAKE_MUSIC("TempoEvent");
670 $$->set_mus_property ("duration", $2);
671 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
676 The representation of a list is the
680 to have efficient append.
684 $$ = scm_cons (SCM_EOL, SCM_EOL);
688 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
689 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
690 if (gh_pair_p (ly_cdr (s)))
691 gh_set_cdr_x (ly_cdr (s), c); /* append */
693 gh_set_car_x (s, c); /* set first cons */
694 gh_set_cdr_x (s, c) ; /* remember last cell */
710 | ALTERNATIVE '{' Music_list '}' {
716 REPEAT string bare_unsigned Music Alternative_music
720 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
721 if (times < scm_ilength (alts)) {
722 unsmob_music (gh_car (alts))
723 ->origin ()->warning (
724 _("More alternatives than repeats. Junking excess alternatives."));
725 alts = ly_truncate_list (times, alts);
731 proc = scm_c_eval_string ("make-repeated-music");
733 SCM mus = scm_call_1 (proc, $2);
734 scm_gc_protect_object (mus); // UGH.
735 Music *r =unsmob_music (mus);
738 r-> set_mus_property ("element", beg->self_scm ());
739 scm_gc_unprotect_object (beg->self_scm ());
741 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
743 r-> set_mus_property ("elements",alts);
744 if (gh_equal_p ($2, scm_makfrom0str ("tremolo")))
747 we can not get durations and other stuff correct down the line, so we have to
748 add to the duration log here.
750 SCM func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
752 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3*2/3)),gh_int2scm(1));
754 gh_call3 (func, r->self_scm (), gh_int2scm(-intlog2 ($3)), gh_int2scm(0));
756 r->set_spot (*$4->origin ());
763 SEQUENTIAL '{' Music_list '}' {
764 $$ = MY_MAKE_MUSIC("SequentialMusic");
765 $$->set_mus_property ("elements", ly_car ($3));
766 $$->set_spot(THIS->here_input());
768 | '{' Music_list '}' {
769 $$ = MY_MAKE_MUSIC("SequentialMusic");
770 $$->set_mus_property ("elements", ly_car ($2));
771 $$->set_spot(THIS->here_input());
776 SIMULTANEOUS '{' Music_list '}'{
777 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
778 $$->set_mus_property ("elements", ly_car ($3));
779 $$->set_spot(THIS->here_input());
782 | '<' Music_list '>' {
783 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
784 $$->set_mus_property ("elements", ly_car ($2));
785 $$->set_spot(THIS->here_input());
790 event_chord { $$ = $1; }
791 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
793 if (!gh_symbol_p ($3))
795 THIS->parser_error (_ ("Second argument must be a symbol"));
797 /* Should check # args */
798 if (!gh_procedure_p (pred))
800 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
803 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
804 m->set_mus_property ("predicate", pred);
805 m->set_mus_property ("grob-property", $3);
806 m->set_mus_property ("grob-value", $5);
811 $$ = unsmob_music ($1);
819 CONTEXT STRING Music {
820 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
822 csm->set_mus_property ("element", $3->self_scm ());
823 scm_gc_unprotect_object ($3->self_scm ());
825 csm->set_mus_property ("context-type",$2);
826 csm->set_mus_property ("context-id", scm_makfrom0str (""));
830 | AUTOCHANGE STRING Music {
831 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
832 chm->set_mus_property ("element", $3->self_scm ());
833 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
835 scm_gc_unprotect_object ($3->self_scm ());
836 chm->set_mus_property ("what", $2);
839 chm->set_spot (*$3->origin ());
844 The other version is for easier debugging of
845 Sequential_music_iterator in combination with grace notes.
848 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
849 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
850 Music *startm = unsmob_music (start);
851 Music *stopm = unsmob_music (stop);
855 stopm = stopm->clone ();
856 ms = scm_cons (stopm->self_scm (), ms);
857 scm_gc_unprotect_object (stopm->self_scm ());
859 ms = scm_cons ($2->self_scm (), ms);
860 scm_gc_unprotect_object ($2->self_scm());
862 startm = startm->clone ();
863 ms = scm_cons (startm->self_scm () , ms);
864 scm_gc_unprotect_object (startm->self_scm ());
868 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
869 seq->set_mus_property ("elements", ms);
872 $$ = MY_MAKE_MUSIC("GraceMusic");
873 $$->set_mus_property ("element", seq->self_scm ());
874 scm_gc_unprotect_object (seq->self_scm ());
876 $$ = MY_MAKE_MUSIC("GraceMusic");
877 $$->set_mus_property ("element", $2->self_scm ());
878 scm_gc_unprotect_object ($2->self_scm ());
881 | CONTEXT string '=' string Music {
882 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
884 csm->set_mus_property ("element", $5->self_scm ());
885 scm_gc_unprotect_object ($5->self_scm ());
887 csm->set_mus_property ("context-type", $2);
888 csm->set_mus_property ("context-id", $4);
899 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
901 $$= MY_MAKE_MUSIC("TimeScaledMusic");
902 $$->set_spot (THIS->pop_spot ());
905 $$->set_mus_property ("element", mp->self_scm ());
906 scm_gc_unprotect_object (mp->self_scm ());
907 $$->set_mus_property ("numerator", gh_int2scm (n));
908 $$->set_mus_property ("denominator", gh_int2scm (d));
909 $$->compress (Moment (Rational (n,d)));
912 | Repeated_music { $$ = $1; }
913 | Simultaneous_music { $$ = $1; }
914 | Sequential_music { $$ = $1; }
915 | TRANSPOSE pitch Music {
916 $$ = MY_MAKE_MUSIC("TransposedMusic");
918 Pitch pit = *unsmob_pitch ($2);
921 $$->set_mus_property ("element", p->self_scm ());
922 scm_gc_unprotect_object (p->self_scm ());
924 | TRANSPOSE steno_tonic_pitch Music {
925 $$ = MY_MAKE_MUSIC("TransposedMusic");
927 Pitch pit = *unsmob_pitch ($2);
930 $$->set_mus_property ("element", p->self_scm ());
931 scm_gc_unprotect_object (p->self_scm ());
934 | APPLY embedded_scm Music {
935 SCM ret = gh_call1 ($2, $3->self_scm ());
936 Music *m = unsmob_music (ret);
938 THIS->parser_error ("\\apply must return a Music");
939 m = MY_MAKE_MUSIC("Music");
944 { THIS->lexer_->push_note_state (); }
947 THIS->lexer_->pop_state ();
950 { THIS->lexer_->push_figuredbass_state (); }
953 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
954 chm->set_mus_property ("element", $3->self_scm ());
956 scm_gc_unprotect_object ($3->self_scm());
958 THIS->lexer_->pop_state ();
961 { THIS->lexer_->push_chord_state (); }
964 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
965 chm->set_mus_property ("element", $3->self_scm ());
966 scm_gc_unprotect_object ($3->self_scm());
969 THIS->lexer_->pop_state ();
972 { THIS->lexer_->push_lyric_state (); }
976 THIS->lexer_->pop_state ();
978 | relative_music { $$ = $1; }
979 | re_rhythmed_music { $$ = $1; }
980 | part_combined_music { $$ = $1; }
984 RELATIVE absolute_pitch Music {
986 Pitch pit = *unsmob_pitch ($2);
987 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
989 $$->set_mus_property ("element", p->self_scm ());
990 scm_gc_unprotect_object (p->self_scm ());
992 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
998 ADDLYRICS Music Music {
999 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
1000 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1001 scm_gc_unprotect_object ($3->self_scm ());
1002 scm_gc_unprotect_object ($2->self_scm ());
1007 part_combined_music:
1008 PARTCOMBINE STRING Music Music {
1009 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1010 p->set_mus_property ("what", $2);
1011 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1013 scm_gc_unprotect_object ($3->self_scm ());
1014 scm_gc_unprotect_object ($4->self_scm ());
1021 TRANSLATOR STRING '=' STRING {
1022 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1023 t-> set_mus_property ("change-to-type", $2);
1024 t-> set_mus_property ("change-to-id", $4);
1027 $$->set_spot (THIS->here_input ());
1033 | ONCE simple_property_def {
1035 SCM e = $2->get_mus_property ("element");
1036 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1040 simple_property_def:
1041 PROPERTY STRING '.' STRING '=' scalar {
1042 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1043 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
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 UNSET {
1055 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1056 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1058 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1059 csm->set_mus_property ("element", t->self_scm ());
1060 scm_gc_unprotect_object (t->self_scm ());
1063 $$->set_spot (THIS->here_input ());
1065 csm-> set_mus_property ("context-type", $2);
1067 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1069 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1070 bool itc = internal_type_checking_global_b;
1071 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1072 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1073 t->set_mus_property ("pop-first", SCM_BOOL_T);
1075 internal_type_checking_global_b = false;
1076 t->set_mus_property ("grob-property", $6);
1078 internal_type_checking_global_b = itc;
1079 t->set_mus_property ("grob-value", $8);
1081 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1082 csm->set_mus_property ("element", t->self_scm ());
1083 scm_gc_unprotect_object (t->self_scm ());
1085 $$->set_spot (THIS->here_input ());
1087 csm-> set_mus_property ("context-type", $2);
1089 | PROPERTY STRING '.' STRING OVERRIDE
1090 embedded_scm '=' embedded_scm
1096 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1097 bool itc = internal_type_checking_global_b;
1099 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1100 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1102 internal_type_checking_global_b = false;
1103 t->set_mus_property ("grob-property", $6);
1104 t->set_mus_property ("grob-value", $8);
1106 internal_type_checking_global_b = itc;
1108 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1109 csm->set_mus_property ("element", t->self_scm ());
1110 scm_gc_unprotect_object (t->self_scm ());
1113 $$->set_spot (THIS->here_input ());
1115 csm-> set_mus_property ("context-type", $2);
1118 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1119 Music *t = MY_MAKE_MUSIC("RevertProperty");
1121 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1122 bool itc = internal_type_checking_global_b;
1124 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1126 internal_type_checking_global_b = false;
1127 t->set_mus_property ("grob-property", $6);
1129 internal_type_checking_global_b = itc;
1131 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1132 csm->set_mus_property ("element", t->self_scm ());
1133 scm_gc_unprotect_object (t->self_scm ());
1136 $$->set_spot (THIS->here_input ());
1138 csm-> set_mus_property ("context-type", $2);
1145 | bare_int { $$ = gh_int2scm ($1); }
1146 | embedded_scm { $$ = $1; }
1153 } /*cont */ simple_element post_events {
1154 SCM elts = $3-> get_mus_property ("elements");
1156 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1157 scm_reverse_x ($4, SCM_EOL));
1159 $3-> set_mus_property ("elements", elts);
1163 | note_chord_element
1168 chord_body optional_notemode_duration post_events
1170 SCM dur = unsmob_duration ($2)->smobbed_copy();
1171 SCM es = $1->get_mus_property ("elements");
1172 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1174 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1175 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1176 es = gh_append2 (es, postevs);
1178 $1-> set_mus_property ("elements", es);
1184 CHORD_OPEN chord_body_elements CHORD_CLOSE
1186 $$ = MY_MAKE_MUSIC("EventChord");
1187 $$->set_mus_property ("elements",
1188 scm_reverse_x ($2, SCM_EOL));
1192 chord_body_elements:
1193 /* empty */ { $$ = SCM_EOL; }
1194 | chord_body_elements chord_body_element {
1195 $$ = gh_cons ($2->self_scm(), $1);
1196 scm_gc_unprotect_object ($2->self_scm());
1201 pitch exclamations questions post_events
1203 Music * n = MY_MAKE_MUSIC("NoteEvent");
1204 n->set_mus_property ("pitch", $1);
1206 n->set_mus_property ("cautionary", SCM_BOOL_T);
1207 if ($2 % 2 || $3 % 2)
1208 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1210 SCM arts = scm_reverse_x ($4, SCM_EOL);
1211 n->set_mus_property ("articulations", arts);
1219 $$ = MY_MAKE_MUSIC("EventChord");
1220 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1221 scm_gc_unprotect_object ($1->self_scm());
1223 $$-> set_spot (THIS->here_input ());
1224 $1-> set_spot (THIS->here_input ());
1227 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1228 l->set_mus_property ("span-direction", gh_int2scm (START));
1229 l->set_spot (THIS->here_input ());
1231 $$ = MY_MAKE_MUSIC("EventChord");
1232 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1233 scm_gc_unprotect_object (l->self_scm());
1234 $$->set_spot (THIS->here_input ());
1237 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1238 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1239 l->set_spot (THIS->here_input ());
1241 $$ = MY_MAKE_MUSIC("EventChord");
1242 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1243 $$->set_spot (THIS->here_input ());
1244 scm_gc_unprotect_object (l->self_scm());
1248 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1249 $$->set_spot (THIS->here_input ());
1253 $$ = MY_MAKE_MUSIC("BarCheck");
1254 $$->set_spot (THIS->here_input ());
1257 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1259 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1260 csm->set_mus_property ("element", t->self_scm ());
1261 scm_gc_unprotect_object (t->self_scm ());
1264 $$->set_spot (THIS->here_input ());
1266 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1268 | PARTIAL duration_length {
1269 Moment m = - unsmob_duration ($2)->get_length ();
1270 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1272 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1273 sp->set_mus_property ("element", p->self_scm ());
1274 scm_gc_unprotect_object (p->self_scm ());
1277 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1282 proc = scm_c_eval_string ("make-clef-set");
1284 SCM result = scm_call_1 (proc, $2);
1285 scm_gc_protect_object (result);
1286 $$ = unsmob_music (result);
1289 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1291 int l = gh_scm2int (ly_car ($2));
1292 int o = gh_scm2int (ly_cdr ($2));
1294 Moment one_beat = Moment (1)/Moment (o);
1295 Moment len = Moment (l) * one_beat;
1298 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1299 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1301 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1302 Music *seq = MY_MAKE_MUSIC("SequentialMusic");
1303 seq->set_mus_property ("elements", list);
1306 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1307 sp->set_mus_property ("element", seq->self_scm ());
1309 scm_gc_unprotect_object (p3->self_scm ());
1310 scm_gc_unprotect_object (p2->self_scm ());
1311 scm_gc_unprotect_object (p1->self_scm ());
1312 scm_gc_unprotect_object (seq->self_scm ());
1316 sp-> set_mus_property ("context-type", scm_makfrom0str ( "Timing"));
1321 shorthand_command_req { $$ = $1; }
1322 | verbose_command_req { $$ = $1; }
1325 shorthand_command_req:
1333 $$ = MY_MAKE_MUSIC("TieEvent");
1336 Music *b= MY_MAKE_MUSIC("BeamEvent");
1337 b->set_mus_property ("span-direction", gh_int2scm (START))
1342 THIS->last_beam_start_ = b->self_scm ();
1345 Music *b= MY_MAKE_MUSIC("BeamEvent");
1346 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1350 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1353 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1357 verbose_command_req:
1359 Music * m = MY_MAKE_MUSIC("MarkEvent");
1363 Music *m = MY_MAKE_MUSIC("MarkEvent");
1364 m->set_mus_property ("label", $2);
1367 | SKIP duration_length {
1368 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1369 skip->set_mus_property ("duration", $2);
1377 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1380 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1381 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1383 key->set_mus_property ("pitch-alist", $3);
1384 ((Music*)key)->transpose (* unsmob_pitch ($2));
1393 | post_events post_event {
1394 $2->set_spot (THIS->here_input ());
1395 $$ = gh_cons ($2->self_scm(), $$);
1396 scm_gc_unprotect_object ($2->self_scm());
1409 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1410 s->set_mus_property ("string-number", gh_int2scm($1));
1411 s->set_spot (THIS->here_input ());
1417 event_that_take_dir:
1423 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1424 m->set_spot (THIS->here_input());
1425 m->set_mus_property ("span-direction" , gh_int2scm (START));
1429 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1430 m->set_spot (THIS->here_input());
1431 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1435 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1436 m->set_spot (THIS->here_input());
1439 | script_abbreviation {
1440 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1441 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1442 if (gh_string_p (s))
1443 a->set_mus_property ("articulation-type", s);
1444 else THIS->parser_error (_ ("Expecting string as script definition"));
1450 script_dir event_that_take_dir {
1451 $2->set_mus_property ("direction", gh_int2scm ($1));
1458 $$ = unsmob_music ($1);
1461 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1462 a->set_spot (THIS->here_input ());
1463 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1490 | NOTENAME_PITCH sup_quotes {
1491 Pitch p = *unsmob_pitch ($1);
1493 $$ = p.smobbed_copy ();
1495 | NOTENAME_PITCH sub_quotes {
1496 Pitch p =* unsmob_pitch ($1);
1499 $$ = p.smobbed_copy ();
1512 | TONICNAME_PITCH sup_quotes {
1513 Pitch p = *unsmob_pitch ($1);
1515 $$ = p.smobbed_copy ();
1517 | TONICNAME_PITCH sub_quotes {
1518 Pitch p =* unsmob_pitch ($1);
1521 $$ = p.smobbed_copy ();
1536 PITCH embedded_scm {
1538 if (!unsmob_pitch ($2)) {
1539 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1540 $$ = Pitch ().smobbed_copy ();
1546 DURATION embedded_scm {
1548 if (!unsmob_duration ($2))
1550 THIS->parser_error (_ ("Must have duration object"));
1551 $$ = Duration ().smobbed_copy ();
1558 if (!THIS->lexer_->lyric_state_b ())
1559 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1560 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1566 if (!THIS->lexer_->lyric_state_b ())
1567 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1568 $$ = MY_MAKE_MUSIC("HyphenEvent");
1573 close_event_parens {
1575 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1582 Music * s= MY_MAKE_MUSIC("SlurEvent");
1584 s->set_spot (THIS->here_input());
1587 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1589 s->set_spot (THIS->here_input());
1592 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1594 s->set_spot (THIS->here_input());
1597 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1599 s->set_spot (THIS->here_input());
1607 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1614 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1615 s->set_spot (THIS->here_input());
1620 Music * s= MY_MAKE_MUSIC("SlurEvent");
1622 s->set_spot (THIS->here_input());
1626 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1628 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1629 s->set_spot (THIS->here_input());
1635 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1636 t->set_mus_property ("text", $1);
1637 t->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("FingerEvent");
1648 SCM finger = ly_symbol2scm ("finger");
1649 t->set_mus_property ("digit", gh_int2scm ($1));
1650 t->set_spot (THIS->here_input ());
1655 script_abbreviation:
1657 $$ = scm_makfrom0str ("Hat");
1660 $$ = scm_makfrom0str ("Plus");
1663 $$ = scm_makfrom0str ("Dash");
1666 $$ = scm_makfrom0str ("Bar");
1669 $$ = scm_makfrom0str ("Larger");
1672 $$ = scm_makfrom0str ("Dot");
1675 $$ = scm_makfrom0str ("Underscore");
1682 | '-' { $$ = CENTER; }
1689 | pre_events open_event {
1690 $$ = gh_cons ($2->self_scm(), $$);
1691 scm_gc_unprotect_object ($2->self_scm());
1702 multiplied_duration {
1705 | verbose_duration {
1710 optional_notemode_duration:
1712 Duration dd = THIS->default_duration_;
1713 $$ = dd.smobbed_copy ();
1715 THIS->beam_check ($$);
1717 | multiplied_duration {
1719 THIS->default_duration_ = *unsmob_duration ($$);
1721 THIS->beam_check ($$);
1723 | verbose_duration {
1725 THIS->default_duration_ = *unsmob_duration ($$);
1730 bare_unsigned dots {
1732 if (!is_duration_b ($1))
1733 THIS->parser_error (_f ("not a duration: %d", $1));
1737 $$ = Duration (l, $2).smobbed_copy ();
1739 | DURATION_IDENTIFIER dots {
1740 Duration *d =unsmob_duration ($1);
1741 Duration k (d->duration_log (),d->dot_count () + $2);
1751 multiplied_duration:
1755 | multiplied_duration '*' bare_unsigned {
1756 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1758 | multiplied_duration '*' FRACTION {
1759 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1761 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1766 FRACTION { $$ = $1; }
1767 | UNSIGNED '/' UNSIGNED {
1768 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1786 | ':' bare_unsigned {
1787 if (!is_duration_b ($2))
1788 THIS->parser_error (_f ("not a duration: %d", $2));
1795 /*****************************************************************
1797 *****************************************************************/
1811 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1812 $$ = bfr->self_scm();
1813 scm_gc_unprotect_object ($$);
1816 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1817 $$ = bfr->self_scm();
1819 bfr->set_mus_property ("figure", gh_int2scm ($1));
1821 scm_gc_unprotect_object ($$);
1823 | bass_figure bass_mod {
1824 Music *m = unsmob_music ($1);
1826 SCM salter =m->get_mus_property ("alteration");
1827 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1828 m->set_mus_property ("alteration",
1829 gh_int2scm (alter + $2));
1831 m->set_mus_property ("alteration", gh_int2scm (0));
1839 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1844 | br_bass_figure ']' {
1846 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1854 | figure_list br_bass_figure {
1855 $$ = scm_cons ($2, $1);
1860 FIGURE_OPEN figure_list FIGURE_CLOSE {
1861 Music * m = MY_MAKE_MUSIC("EventChord");
1862 $2 = scm_reverse_x ($2, SCM_EOL);
1863 m->set_mus_property ("elements", $2);
1864 $$ = m->self_scm ();
1875 pitch exclamations questions optional_notemode_duration optional_rest {
1877 Input i = THIS->pop_spot ();
1878 if (!THIS->lexer_->note_state_b ())
1879 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1883 n = MY_MAKE_MUSIC("RestEvent");
1885 n = MY_MAKE_MUSIC("NoteEvent");
1887 n->set_mus_property ("pitch", $1);
1888 n->set_mus_property ("duration", $4);
1892 n->set_mus_property ("cautionary", SCM_BOOL_T);
1893 if ($2 % 2 || $3 % 2)
1894 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1896 Music *v = MY_MAKE_MUSIC("EventChord");
1897 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1898 scm_gc_unprotect_object (n->self_scm());
1904 | figure_spec optional_notemode_duration {
1905 Music * m = unsmob_music ($1);
1906 Input i = THIS->pop_spot ();
1908 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1910 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1914 | RESTNAME optional_notemode_duration {
1916 Input i = THIS->pop_spot ();
1918 if (ly_scm2string ($1) =="s") {
1920 ev = MY_MAKE_MUSIC("SkipEvent");
1923 ev = MY_MAKE_MUSIC("RestEvent");
1926 ev->set_mus_property ("duration" ,$2);
1928 Music * velt = MY_MAKE_MUSIC("EventChord");
1929 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1934 | MULTI_MEASURE_REST optional_notemode_duration {
1939 proc = scm_c_eval_string ("make-multi-measure-rest");
1941 SCM mus = scm_call_2 (proc, $2,
1942 make_input (THIS->here_input()));
1943 scm_gc_protect_object (mus);
1944 $$ = unsmob_music (mus);
1946 | STRING optional_notemode_duration {
1947 Input i = THIS->pop_spot ();
1949 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1950 lreq->set_mus_property ("text", $1);
1951 lreq->set_mus_property ("duration",$2);
1953 Music * velt = MY_MAKE_MUSIC("EventChord");
1954 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1961 if (!THIS->lexer_->chord_state_b ())
1962 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1969 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1970 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1971 $$->set_spot (THIS->here_input ());
1978 | CHORD_COLON chord_notes {
1987 | chord_notes '.' chord_step {
1988 $$ = gh_append2 ($$, $3);
1996 | CHORD_CARET chord_notes {
2006 | CHORD_SLASH steno_tonic_pitch {
2015 | CHORD_BASS steno_tonic_pitch {
2022 $$ = scm_cons ($1, SCM_EOL);
2024 | CHORDMODIFIER_PITCH {
2025 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2027 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2028 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2036 m.notename_ = ($1 - 1) % 7;
2037 m.octave_ = $1 > 7 ? 1 : 0;
2040 $$ = m.smobbed_copy ();
2042 | bare_unsigned '+' {
2044 m.notename_ = ($1 - 1) % 7;
2045 m.octave_ = $1 > 7 ? 1 : 0;
2049 $$ = m.smobbed_copy ();
2051 | bare_unsigned CHORD_MINUS {
2053 m.notename_ = ($1 - 1) % 7;
2054 m.octave_ = $1 > 7 ? 1 : 0;
2057 $$ = m.smobbed_copy ();
2065 number_expression '+' number_term {
2066 $$ = scm_sum ($1, $3);
2068 | number_expression '-' number_term {
2069 $$ = scm_difference ($1, $3);
2078 | number_factor '*' number_factor {
2079 $$ = scm_product ($1, $3);
2081 | number_factor '/' number_factor {
2082 $$ = scm_divide ($1, $3);
2087 '-' number_factor { /* %prec UNARY_MINUS */
2088 $$ = scm_difference ($2, SCM_UNDEFINED);
2096 $$ = gh_int2scm ($1);
2101 | NUMBER_IDENTIFIER {
2104 | REAL NUMBER_IDENTIFIER {
2105 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2107 | UNSIGNED NUMBER_IDENTIFIER {
2108 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2124 if (scm_integer_p ($1) == SCM_BOOL_T)
2126 int k = gh_scm2int ($1);
2130 THIS->parser_error (_ ("need integer number arg"));
2144 | STRING_IDENTIFIER {
2147 | string '+' string {
2148 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2155 | exclamations '!' { $$ ++; }
2160 | questions '?' { $$ ++; }
2167 My_lily_parser::set_yydebug (bool )
2174 extern My_lily_parser * current_parser;
2177 My_lily_parser::do_yyparse ()
2179 current_parser = this;;
2180 yyparse ((void*)this);
2185 Should make this optional? It will also complain when you do
2189 which is entirely legitimate.
2191 Or we can scrap it. Barchecks should detect wrong durations, and
2192 skipTypesetting speeds it up a lot.
2196 My_lily_parser::beam_check (SCM dur)
2198 Duration *d = unsmob_duration (dur);
2199 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2201 Music * m = unsmob_music (last_beam_start_);
2202 m->origin ()->warning (_("Suspect duration found following this beam"));
2204 last_beam_start_ = SCM_EOL;
2209 It is a little strange, to have this function in this file, but
2210 otherwise, we have to import music classes into the lexer.
2214 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2216 if (gh_string_p (sid)) {
2218 return STRING_IDENTIFIER;
2219 } else if (gh_number_p (sid)) {
2221 return NUMBER_IDENTIFIER;
2222 } else if (unsmob_translator_def (sid)) {
2223 *destination = unsmob_translator_def (sid)->clone_scm();
2224 return TRANSLATOR_IDENTIFIER;
2225 } else if (unsmob_score (sid)) {
2226 Score *sc = new Score (*unsmob_score (sid));
2227 *destination =sc->self_scm ();
2228 return SCORE_IDENTIFIER;
2229 } else if (Music * mus =unsmob_music (sid)) {
2230 *destination = unsmob_music (sid)->clone ()->self_scm();
2231 unsmob_music (*destination)->
2232 set_mus_property ("origin", make_input (last_input_));
2233 return dynamic_cast<Event*> (mus)
2234 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2235 } else if (unsmob_duration (sid)) {
2236 *destination = unsmob_duration (sid)->smobbed_copy();
2237 return DURATION_IDENTIFIER;
2238 } else if (unsmob_music_output_def (sid)) {
2239 Music_output_def *p = unsmob_music_output_def (sid);
2242 *destination = p->self_scm();
2243 return MUSIC_OUTPUT_DEF_IDENTIFIER;