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.
682 Music_list: /* empty */ {
683 $$ = scm_cons (SCM_EOL, SCM_EOL);
687 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
688 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
689 if (gh_pair_p (ly_cdr (s)))
690 gh_set_cdr_x (ly_cdr (s), c); /* append */
692 gh_set_car_x (s, c); /* set first cons */
693 gh_set_cdr_x (s, c) ; /* remember last cell */
709 | ALTERNATIVE '{' Music_list '}' {
715 REPEAT string bare_unsigned Music Alternative_music
719 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
720 if (times < scm_ilength (alts)) {
721 unsmob_music (gh_car (alts))
722 ->origin ()->warning (
723 _("More alternatives than repeats. Junking excess alternatives."));
724 alts = ly_truncate_list (times, alts);
730 proc = scm_c_eval_string ("make-repeated-music");
732 SCM mus = scm_call_1 (proc, $2);
733 scm_gc_protect_object (mus); // UGH.
734 Music *r =unsmob_music (mus);
737 r-> set_mus_property ("element", beg->self_scm ());
738 scm_gc_unprotect_object (beg->self_scm ());
740 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
742 r-> set_mus_property ("elements",alts);
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));
755 r->set_spot (*$4->origin ());
762 SEQUENTIAL '{' Music_list '}' {
763 $$ = MY_MAKE_MUSIC("SequentialMusic");
764 $$->set_mus_property ("elements", ly_car ($3));
765 $$->set_spot(THIS->here_input());
767 | '{' Music_list '}' {
768 $$ = MY_MAKE_MUSIC("SequentialMusic");
769 $$->set_mus_property ("elements", ly_car ($2));
770 $$->set_spot(THIS->here_input());
775 SIMULTANEOUS '{' Music_list '}'{
776 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
777 $$->set_mus_property ("elements", ly_car ($3));
778 $$->set_spot(THIS->here_input());
781 | '<' Music_list '>' {
782 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
783 $$->set_mus_property ("elements", ly_car ($2));
784 $$->set_spot(THIS->here_input());
789 event_chord { $$ = $1; }
790 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
792 if (!gh_symbol_p ($3))
794 THIS->parser_error (_ ("Second argument must be a symbol"));
796 /* Should check # args */
797 if (!gh_procedure_p (pred))
799 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
802 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
803 m->set_mus_property ("predicate", pred);
804 m->set_mus_property ("grob-property", $3);
805 m->set_mus_property ("grob-value", $5);
810 $$ = unsmob_music ($1);
818 CONTEXT STRING Music {
819 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
821 csm->set_mus_property ("element", $3->self_scm ());
822 scm_gc_unprotect_object ($3->self_scm ());
824 csm->set_mus_property ("context-type",$2);
825 csm->set_mus_property ("context-id", scm_makfrom0str (""));
829 | AUTOCHANGE STRING Music {
830 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
831 chm->set_mus_property ("element", $3->self_scm ());
832 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
834 scm_gc_unprotect_object ($3->self_scm ());
835 chm->set_mus_property ("what", $2);
838 chm->set_spot (*$3->origin ());
843 The other version is for easier debugging of
844 Sequential_music_iterator in combination with grace notes.
847 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
848 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
849 Music *startm = unsmob_music (start);
850 Music *stopm = unsmob_music (stop);
854 stopm = stopm->clone ();
855 ms = scm_cons (stopm->self_scm (), ms);
856 scm_gc_unprotect_object (stopm->self_scm ());
858 ms = scm_cons ($2->self_scm (), ms);
859 scm_gc_unprotect_object ($2->self_scm());
861 startm = startm->clone ();
862 ms = scm_cons (startm->self_scm () , ms);
863 scm_gc_unprotect_object (startm->self_scm ());
867 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
868 seq->set_mus_property ("elements", ms);
871 $$ = MY_MAKE_MUSIC("GraceMusic");
872 $$->set_mus_property ("element", seq->self_scm ());
873 scm_gc_unprotect_object (seq->self_scm ());
875 $$ = MY_MAKE_MUSIC("GraceMusic");
876 $$->set_mus_property ("element", $2->self_scm ());
877 scm_gc_unprotect_object ($2->self_scm ());
880 | CONTEXT string '=' string Music {
881 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
883 csm->set_mus_property ("element", $5->self_scm ());
884 scm_gc_unprotect_object ($5->self_scm ());
886 csm->set_mus_property ("context-type", $2);
887 csm->set_mus_property ("context-id", $4);
898 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
900 $$= MY_MAKE_MUSIC("TimeScaledMusic");
901 $$->set_spot (THIS->pop_spot ());
904 $$->set_mus_property ("element", mp->self_scm ());
905 scm_gc_unprotect_object (mp->self_scm ());
906 $$->set_mus_property ("numerator", gh_int2scm (n));
907 $$->set_mus_property ("denominator", gh_int2scm (d));
908 $$->compress (Moment (Rational (n,d)));
911 | Repeated_music { $$ = $1; }
912 | Simultaneous_music { $$ = $1; }
913 | Sequential_music { $$ = $1; }
914 | TRANSPOSE pitch Music {
915 $$ = MY_MAKE_MUSIC("TransposedMusic");
917 Pitch pit = *unsmob_pitch ($2);
920 $$->set_mus_property ("element", p->self_scm ());
921 scm_gc_unprotect_object (p->self_scm ());
923 | TRANSPOSE steno_tonic_pitch Music {
924 $$ = MY_MAKE_MUSIC("TransposedMusic");
926 Pitch pit = *unsmob_pitch ($2);
929 $$->set_mus_property ("element", p->self_scm ());
930 scm_gc_unprotect_object (p->self_scm ());
933 | APPLY embedded_scm Music {
934 SCM ret = gh_call1 ($2, $3->self_scm ());
935 Music *m = unsmob_music (ret);
937 THIS->parser_error ("\\apply must return a Music");
938 m = MY_MAKE_MUSIC("Music");
943 { THIS->lexer_->push_note_state (); }
946 THIS->lexer_->pop_state ();
949 { THIS->lexer_->push_figuredbass_state (); }
952 Music * chm = MY_MAKE_MUSIC("UntransposableMusic");
953 chm->set_mus_property ("element", $3->self_scm ());
955 scm_gc_unprotect_object ($3->self_scm());
957 THIS->lexer_->pop_state ();
960 { THIS->lexer_->push_chord_state (); }
963 Music * chm = MY_MAKE_MUSIC("UnrelativableMusic");
964 chm->set_mus_property ("element", $3->self_scm ());
965 scm_gc_unprotect_object ($3->self_scm());
968 THIS->lexer_->pop_state ();
971 { THIS->lexer_->push_lyric_state (); }
975 THIS->lexer_->pop_state ();
977 | relative_music { $$ = $1; }
978 | re_rhythmed_music { $$ = $1; }
979 | part_combined_music { $$ = $1; }
983 RELATIVE absolute_pitch Music {
985 Pitch pit = *unsmob_pitch ($2);
986 $$ = MY_MAKE_MUSIC("RelativeOctaveMusic");
988 $$->set_mus_property ("element", p->self_scm ());
989 scm_gc_unprotect_object (p->self_scm ());
991 $$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
997 ADDLYRICS Music Music {
998 Music*l =MY_MAKE_MUSIC("LyricCombineMusic");
999 l->set_mus_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
1000 scm_gc_unprotect_object ($3->self_scm ());
1001 scm_gc_unprotect_object ($2->self_scm ());
1006 part_combined_music:
1007 PARTCOMBINE STRING Music Music {
1008 Music * p= MY_MAKE_MUSIC("PartCombineMusic");
1009 p->set_mus_property ("what", $2);
1010 p->set_mus_property ("elements", gh_list ($3->self_scm (),$4->self_scm (), SCM_UNDEFINED));
1012 scm_gc_unprotect_object ($3->self_scm ());
1013 scm_gc_unprotect_object ($4->self_scm ());
1020 TRANSLATOR STRING '=' STRING {
1021 Music*t= MY_MAKE_MUSIC("TranslatorChange");
1022 t-> set_mus_property ("change-to-type", $2);
1023 t-> set_mus_property ("change-to-id", $4);
1026 $$->set_spot (THIS->here_input ());
1032 | ONCE simple_property_def {
1034 SCM e = $2->get_mus_property ("element");
1035 unsmob_music (e)->set_mus_property ("once", SCM_BOOL_T);
1039 simple_property_def:
1040 PROPERTY STRING '.' STRING '=' scalar {
1041 Music *t = set_property_music (scm_string_to_symbol ($4), $6);
1042 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1044 csm->set_mus_property ("element", t->self_scm ());
1045 scm_gc_unprotect_object (t->self_scm ());
1048 $$->set_spot (THIS->here_input ());
1050 csm-> set_mus_property ("context-type", $2);
1052 | PROPERTY STRING '.' STRING UNSET {
1054 Music *t = MY_MAKE_MUSIC("PropertyUnset");
1055 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1057 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1058 csm->set_mus_property ("element", t->self_scm ());
1059 scm_gc_unprotect_object (t->self_scm ());
1062 $$->set_spot (THIS->here_input ());
1064 csm-> set_mus_property ("context-type", $2);
1066 | PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
1068 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1069 bool itc = internal_type_checking_global_b;
1070 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1071 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1072 t->set_mus_property ("pop-first", SCM_BOOL_T);
1074 internal_type_checking_global_b = false;
1075 t->set_mus_property ("grob-property", $6);
1077 internal_type_checking_global_b = itc;
1078 t->set_mus_property ("grob-value", $8);
1080 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1081 csm->set_mus_property ("element", t->self_scm ());
1082 scm_gc_unprotect_object (t->self_scm ());
1084 $$->set_spot (THIS->here_input ());
1086 csm-> set_mus_property ("context-type", $2);
1088 | PROPERTY STRING '.' STRING OVERRIDE
1089 embedded_scm '=' embedded_scm
1095 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1096 bool itc = internal_type_checking_global_b;
1098 Music *t = MY_MAKE_MUSIC("OverrideProperty");
1099 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1101 internal_type_checking_global_b = false;
1102 t->set_mus_property ("grob-property", $6);
1103 t->set_mus_property ("grob-value", $8);
1105 internal_type_checking_global_b = itc;
1107 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1108 csm->set_mus_property ("element", t->self_scm ());
1109 scm_gc_unprotect_object (t->self_scm ());
1112 $$->set_spot (THIS->here_input ());
1114 csm-> set_mus_property ("context-type", $2);
1117 | PROPERTY STRING '.' STRING REVERT embedded_scm {
1118 Music *t = MY_MAKE_MUSIC("RevertProperty");
1120 = gh_equal_p ($4, scm_makfrom0str ("autoBeamSettings"));
1121 bool itc = internal_type_checking_global_b;
1123 t->set_mus_property ("symbol", scm_string_to_symbol ($4));
1125 internal_type_checking_global_b = false;
1126 t->set_mus_property ("grob-property", $6);
1128 internal_type_checking_global_b = itc;
1130 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1131 csm->set_mus_property ("element", t->self_scm ());
1132 scm_gc_unprotect_object (t->self_scm ());
1135 $$->set_spot (THIS->here_input ());
1137 csm-> set_mus_property ("context-type", $2);
1144 | bare_int { $$ = gh_int2scm ($1); }
1145 | embedded_scm { $$ = $1; }
1152 } /*cont */ simple_element post_events {
1153 SCM elts = $3-> get_mus_property ("elements");
1155 elts = gh_append3 (elts, scm_reverse_x ($1, SCM_EOL),
1156 scm_reverse_x ($4, SCM_EOL));
1158 $3-> set_mus_property ("elements", elts);
1162 | note_chord_element
1167 chord_body optional_notemode_duration post_events
1169 SCM dur = unsmob_duration ($2)->smobbed_copy();
1170 SCM es = $1->get_mus_property ("elements");
1171 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1173 for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
1174 unsmob_music (gh_car(s))->set_mus_property ("duration", dur);
1175 es = gh_append2 (es, postevs);
1177 $1-> set_mus_property ("elements", es);
1183 CHORD_OPEN chord_body_elements CHORD_CLOSE
1185 $$ = MY_MAKE_MUSIC("EventChord");
1186 $$->set_mus_property ("elements",
1187 scm_reverse_x ($2, SCM_EOL));
1191 chord_body_elements:
1192 /* empty */ { $$ = SCM_EOL; }
1193 | chord_body_elements chord_body_element {
1194 $$ = gh_cons ($2->self_scm(), $1);
1195 scm_gc_unprotect_object ($2->self_scm());
1200 pitch exclamations questions post_events
1202 Music * n = MY_MAKE_MUSIC("NoteEvent");
1203 n->set_mus_property ("pitch", $1);
1205 n->set_mus_property ("cautionary", SCM_BOOL_T);
1206 if ($2 % 2 || $3 % 2)
1207 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1209 SCM arts = scm_reverse_x ($4, SCM_EOL);
1210 n->set_mus_property ("articulations", arts);
1218 $$ = MY_MAKE_MUSIC("EventChord");
1219 $$->set_mus_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1220 scm_gc_unprotect_object ($1->self_scm());
1222 $$-> set_spot (THIS->here_input ());
1223 $1-> set_spot (THIS->here_input ());
1226 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1227 l->set_mus_property ("span-direction", gh_int2scm (START));
1228 l->set_spot (THIS->here_input ());
1230 $$ = MY_MAKE_MUSIC("EventChord");
1231 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1232 scm_gc_unprotect_object (l->self_scm());
1233 $$->set_spot (THIS->here_input ());
1236 Music *l = MY_MAKE_MUSIC("LigatureEvent");
1237 l->set_mus_property ("span-direction", gh_int2scm (STOP));
1238 l->set_spot (THIS->here_input ());
1240 $$ = MY_MAKE_MUSIC("EventChord");
1241 $$->set_mus_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
1242 $$->set_spot (THIS->here_input ());
1243 scm_gc_unprotect_object (l->self_scm());
1247 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1248 $$->set_spot (THIS->here_input ());
1252 $$ = MY_MAKE_MUSIC("BarCheck");
1253 $$->set_spot (THIS->here_input ());
1256 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1258 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1259 csm->set_mus_property ("element", t->self_scm ());
1260 scm_gc_unprotect_object (t->self_scm ());
1263 $$->set_spot (THIS->here_input ());
1265 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1267 | PARTIAL duration_length {
1268 Moment m = - unsmob_duration ($2)->get_length ();
1269 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1271 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1272 sp->set_mus_property ("element", p->self_scm ());
1273 scm_gc_unprotect_object (p->self_scm ());
1276 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1281 proc = scm_c_eval_string ("make-clef-set");
1283 SCM result = scm_call_1 (proc, $2);
1284 scm_gc_protect_object (result);
1285 $$ = unsmob_music (result);
1288 Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
1290 int l = gh_scm2int (ly_car ($2));
1291 int o = gh_scm2int (ly_cdr ($2));
1293 Moment one_beat = Moment (1)/Moment (o);
1294 Moment len = Moment (l) * one_beat;
1297 Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
1298 Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
1300 SCM list = scm_list_n (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
1301 Music *seq = MY_MAKE_MUSIC("SequentialMusic");
1302 seq->set_mus_property ("elements", list);
1305 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1306 sp->set_mus_property ("element", seq->self_scm ());
1308 scm_gc_unprotect_object (p3->self_scm ());
1309 scm_gc_unprotect_object (p2->self_scm ());
1310 scm_gc_unprotect_object (p1->self_scm ());
1311 scm_gc_unprotect_object (seq->self_scm ());
1315 sp-> set_mus_property ("context-type", scm_makfrom0str ( "Timing"));
1320 shorthand_command_req { $$ = $1; }
1321 | verbose_command_req { $$ = $1; }
1324 shorthand_command_req:
1332 $$ = MY_MAKE_MUSIC("TieEvent");
1335 Music *b= MY_MAKE_MUSIC("BeamEvent");
1336 b->set_mus_property ("span-direction", gh_int2scm (START))
1341 THIS->last_beam_start_ = b->self_scm ();
1344 Music *b= MY_MAKE_MUSIC("BeamEvent");
1345 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1349 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1352 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1356 verbose_command_req:
1358 Music * m = MY_MAKE_MUSIC("MarkEvent");
1362 Music *m = MY_MAKE_MUSIC("MarkEvent");
1363 m->set_mus_property ("label", $2);
1366 | SKIP duration_length {
1367 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1368 skip->set_mus_property ("duration", $2);
1376 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1379 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1380 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1382 key->set_mus_property ("pitch-alist", $3);
1383 ((Music*)key)->transpose (* unsmob_pitch ($2));
1392 | post_events post_event {
1393 $2->set_spot (THIS->here_input ());
1394 $$ = gh_cons ($2->self_scm(), $$);
1395 scm_gc_unprotect_object ($2->self_scm());
1408 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1409 s->set_mus_property ("string-number", gh_int2scm($1));
1410 s->set_spot (THIS->here_input ());
1416 event_that_take_dir:
1421 | script_abbreviation {
1422 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1423 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1424 if (gh_string_p (s))
1425 a->set_mus_property ("articulation-type", s);
1426 else THIS->parser_error (_ ("Expecting string as script definition"));
1432 script_dir event_that_take_dir {
1433 $2->set_mus_property ("direction", gh_int2scm ($1));
1440 $$ = unsmob_music ($1);
1443 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1444 a->set_spot (THIS->here_input ());
1445 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1472 | NOTENAME_PITCH sup_quotes {
1473 Pitch p = *unsmob_pitch ($1);
1475 $$ = p.smobbed_copy ();
1477 | NOTENAME_PITCH sub_quotes {
1478 Pitch p =* unsmob_pitch ($1);
1481 $$ = p.smobbed_copy ();
1494 | TONICNAME_PITCH sup_quotes {
1495 Pitch p = *unsmob_pitch ($1);
1497 $$ = p.smobbed_copy ();
1499 | TONICNAME_PITCH sub_quotes {
1500 Pitch p =* unsmob_pitch ($1);
1503 $$ = p.smobbed_copy ();
1518 PITCH embedded_scm {
1520 if (!unsmob_pitch ($2)) {
1521 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1522 $$ = Pitch ().smobbed_copy ();
1528 DURATION embedded_scm {
1530 if (!unsmob_duration ($2))
1532 THIS->parser_error (_ ("Must have duration object"));
1533 $$ = Duration ().smobbed_copy ();
1540 if (!THIS->lexer_->lyric_state_b ())
1541 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1542 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1548 if (!THIS->lexer_->lyric_state_b ())
1549 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1550 $$ = MY_MAKE_MUSIC("HyphenEvent");
1555 close_event_parens {
1557 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1564 Music * s= MY_MAKE_MUSIC("SlurEvent");
1566 s->set_spot (THIS->here_input());
1569 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1571 s->set_spot (THIS->here_input());
1574 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1576 s->set_spot (THIS->here_input());
1579 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1581 s->set_spot (THIS->here_input());
1589 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1596 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1597 s->set_spot (THIS->here_input());
1602 Music * s= MY_MAKE_MUSIC("SlurEvent");
1604 s->set_spot (THIS->here_input());
1608 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1610 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1611 s->set_spot (THIS->here_input());
1617 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1618 t->set_mus_property ("text", $1);
1619 t->set_spot (THIS->here_input ());
1623 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1624 t->set_mus_property ("text", $1);
1625 t->set_spot (THIS->here_input ());
1629 Music * t = MY_MAKE_MUSIC("FingerEvent");
1630 SCM finger = ly_symbol2scm ("finger");
1631 t->set_mus_property ("digit", gh_int2scm ($1));
1632 t->set_spot (THIS->here_input ());
1637 script_abbreviation:
1639 $$ = scm_makfrom0str ("Hat");
1642 $$ = scm_makfrom0str ("Plus");
1645 $$ = scm_makfrom0str ("Dash");
1648 $$ = scm_makfrom0str ("Bar");
1651 $$ = scm_makfrom0str ("Larger");
1654 $$ = scm_makfrom0str ("Dot");
1657 $$ = scm_makfrom0str ("Underscore");
1664 | '-' { $$ = CENTER; }
1671 | pre_events open_event {
1672 $$ = gh_cons ($2->self_scm(), $$);
1673 scm_gc_unprotect_object ($2->self_scm());
1684 multiplied_duration {
1687 | verbose_duration {
1692 optional_notemode_duration:
1694 Duration dd = THIS->default_duration_;
1695 $$ = dd.smobbed_copy ();
1697 THIS->beam_check ($$);
1699 | multiplied_duration {
1701 THIS->default_duration_ = *unsmob_duration ($$);
1703 THIS->beam_check ($$);
1705 | verbose_duration {
1707 THIS->default_duration_ = *unsmob_duration ($$);
1712 bare_unsigned dots {
1714 if (!is_duration_b ($1))
1715 THIS->parser_error (_f ("not a duration: %d", $1));
1719 $$ = Duration (l, $2).smobbed_copy ();
1721 | DURATION_IDENTIFIER dots {
1722 Duration *d =unsmob_duration ($1);
1723 Duration k (d->duration_log (),d->dot_count () + $2);
1733 multiplied_duration:
1737 | multiplied_duration '*' bare_unsigned {
1738 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1740 | multiplied_duration '*' FRACTION {
1741 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1743 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1748 FRACTION { $$ = $1; }
1749 | UNSIGNED '/' UNSIGNED {
1750 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1768 | ':' bare_unsigned {
1769 if (!is_duration_b ($2))
1770 THIS->parser_error (_f ("not a duration: %d", $2));
1777 /*****************************************************************
1779 *****************************************************************/
1793 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1794 $$ = bfr->self_scm();
1795 scm_gc_unprotect_object ($$);
1798 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1799 $$ = bfr->self_scm();
1801 bfr->set_mus_property ("figure", gh_int2scm ($1));
1803 scm_gc_unprotect_object ($$);
1805 | bass_figure bass_mod {
1806 Music *m = unsmob_music ($1);
1808 SCM salter =m->get_mus_property ("alteration");
1809 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1810 m->set_mus_property ("alteration",
1811 gh_int2scm (alter + $2));
1813 m->set_mus_property ("alteration", gh_int2scm (0));
1821 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1826 | br_bass_figure ']' {
1828 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1836 | figure_list br_bass_figure {
1837 $$ = scm_cons ($2, $1);
1842 FIGURE_OPEN figure_list FIGURE_CLOSE {
1843 Music * m = MY_MAKE_MUSIC("EventChord");
1844 $2 = scm_reverse_x ($2, SCM_EOL);
1845 m->set_mus_property ("elements", $2);
1846 $$ = m->self_scm ();
1857 pitch exclamations questions optional_notemode_duration optional_rest {
1859 Input i = THIS->pop_spot ();
1860 if (!THIS->lexer_->note_state_b ())
1861 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1865 n = MY_MAKE_MUSIC("RestEvent");
1867 n = MY_MAKE_MUSIC("NoteEvent");
1869 n->set_mus_property ("pitch", $1);
1870 n->set_mus_property ("duration", $4);
1874 n->set_mus_property ("cautionary", SCM_BOOL_T);
1875 if ($2 % 2 || $3 % 2)
1876 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1878 Music *v = MY_MAKE_MUSIC("EventChord");
1879 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1880 scm_gc_unprotect_object (n->self_scm());
1886 | figure_spec optional_notemode_duration {
1887 Music * m = unsmob_music ($1);
1888 Input i = THIS->pop_spot ();
1890 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1892 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1896 | RESTNAME optional_notemode_duration {
1898 Input i = THIS->pop_spot ();
1900 if (ly_scm2string ($1) =="s") {
1902 ev = MY_MAKE_MUSIC("SkipEvent");
1905 ev = MY_MAKE_MUSIC("RestEvent");
1908 ev->set_mus_property ("duration" ,$2);
1910 Music * velt = MY_MAKE_MUSIC("EventChord");
1911 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1916 | MULTI_MEASURE_REST optional_notemode_duration {
1921 proc = scm_c_eval_string ("make-multi-measure-rest");
1923 SCM mus = scm_call_2 (proc, $2,
1924 make_input (THIS->here_input()));
1925 scm_gc_protect_object (mus);
1926 $$ = unsmob_music (mus);
1928 | STRING optional_notemode_duration {
1929 Input i = THIS->pop_spot ();
1931 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1932 lreq->set_mus_property ("text", $1);
1933 lreq->set_mus_property ("duration",$2);
1935 Music * velt = MY_MAKE_MUSIC("EventChord");
1936 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1943 if (!THIS->lexer_->chord_state_b ())
1944 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1951 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1952 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1953 $$->set_spot (THIS->here_input ());
1960 | CHORD_COLON chord_notes {
1969 | chord_notes '.' chord_step {
1970 $$ = gh_append2 ($$, $3);
1978 | CHORD_CARET chord_notes {
1988 | CHORD_SLASH steno_tonic_pitch {
1997 | CHORD_BASS steno_tonic_pitch {
2004 $$ = scm_cons ($1, SCM_EOL);
2006 | CHORDMODIFIER_PITCH {
2007 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2009 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2010 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2018 m.notename_ = ($1 - 1) % 7;
2019 m.octave_ = $1 > 7 ? 1 : 0;
2022 $$ = m.smobbed_copy ();
2024 | bare_unsigned '+' {
2026 m.notename_ = ($1 - 1) % 7;
2027 m.octave_ = $1 > 7 ? 1 : 0;
2031 $$ = m.smobbed_copy ();
2033 | bare_unsigned CHORD_MINUS {
2035 m.notename_ = ($1 - 1) % 7;
2036 m.octave_ = $1 > 7 ? 1 : 0;
2039 $$ = m.smobbed_copy ();
2047 number_expression '+' number_term {
2048 $$ = scm_sum ($1, $3);
2050 | number_expression '-' number_term {
2051 $$ = scm_difference ($1, $3);
2060 | number_factor '*' number_factor {
2061 $$ = scm_product ($1, $3);
2063 | number_factor '/' number_factor {
2064 $$ = scm_divide ($1, $3);
2069 '-' number_factor { /* %prec UNARY_MINUS */
2070 $$ = scm_difference ($2, SCM_UNDEFINED);
2078 $$ = gh_int2scm ($1);
2083 | NUMBER_IDENTIFIER {
2086 | REAL NUMBER_IDENTIFIER {
2087 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2089 | UNSIGNED NUMBER_IDENTIFIER {
2090 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2106 if (scm_integer_p ($1) == SCM_BOOL_T)
2108 int k = gh_scm2int ($1);
2112 THIS->parser_error (_ ("need integer number arg"));
2126 | STRING_IDENTIFIER {
2129 | string '+' string {
2130 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2137 | exclamations '!' { $$ ++; }
2142 | questions '?' { $$ ++; }
2149 My_lily_parser::set_yydebug (bool )
2156 extern My_lily_parser * current_parser;
2159 My_lily_parser::do_yyparse ()
2161 current_parser = this;;
2162 yyparse ((void*)this);
2167 Should make this optional? It will also complain when you do
2171 which is entirely legitimate.
2173 Or we can scrap it. Barchecks should detect wrong durations, and
2174 skipTypesetting speeds it up a lot.
2178 My_lily_parser::beam_check (SCM dur)
2180 Duration *d = unsmob_duration (dur);
2181 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2183 Music * m = unsmob_music (last_beam_start_);
2184 m->origin ()->warning (_("Suspect duration found following this beam"));
2186 last_beam_start_ = SCM_EOL;
2191 It is a little strange, to have this function in this file, but
2192 otherwise, we have to import music classes into the lexer.
2196 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2198 if (gh_string_p (sid)) {
2200 return STRING_IDENTIFIER;
2201 } else if (gh_number_p (sid)) {
2203 return NUMBER_IDENTIFIER;
2204 } else if (unsmob_translator_def (sid)) {
2205 *destination = unsmob_translator_def (sid)->clone_scm();
2206 return TRANSLATOR_IDENTIFIER;
2207 } else if (unsmob_score (sid)) {
2208 Score *sc = new Score (*unsmob_score (sid));
2209 *destination =sc->self_scm ();
2210 return SCORE_IDENTIFIER;
2211 } else if (Music * mus =unsmob_music (sid)) {
2212 *destination = unsmob_music (sid)->clone ()->self_scm();
2213 unsmob_music (*destination)->
2214 set_mus_property ("origin", make_input (last_input_));
2215 return dynamic_cast<Event*> (mus)
2216 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2217 } else if (unsmob_duration (sid)) {
2218 *destination = unsmob_duration (sid)->smobbed_copy();
2219 return DURATION_IDENTIFIER;
2220 } else if (unsmob_music_output_def (sid)) {
2221 Music_output_def *p = unsmob_music_output_def (sid);
2224 *destination = p->self_scm();
2225 return MUSIC_OUTPUT_DEF_IDENTIFIER;