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 */
188 %token CHORDMODIFIERS
194 %token GROBDESCRIPTIONS
199 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
200 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
208 %token MULTI_MEASURE_REST
219 %token OVERRIDE SET REVERT
229 %token COMMANDSPANREQUEST
231 %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
267 %token <scm> NUMBER_IDENTIFIER
268 %token <scm> EVENT_IDENTIFIER
269 %token <scm> MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
270 %token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
271 %token <scm> RESTNAME
277 %type <outputdef> output_def
278 %type <scm> lilypond_header lilypond_header_body
279 %type <music> open_event_parens close_event_parens open_event close_event
280 %type <music> event_with_dir event_that_take_dir verbose_event
281 %type <i> sub_quotes sup_quotes
282 %type <music> simple_element event_chord command_element Simple_music Composite_music
283 %type <music> Repeated_music
284 %type <scm> Alternative_music
285 %type <i> tremolo_type
286 %type <i> bare_int bare_unsigned
288 %type <scm> identifier_init
290 %type <music> note_chord_element chord_body chord_body_element
291 %type <scm> chord_body_elements
292 %type <scm> steno_duration optional_notemode_duration multiplied_duration
293 %type <scm> verbose_duration
295 %type <scm> pre_events post_events
296 %type <music> gen_text_def
297 %type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
298 %type <scm> explicit_pitch steno_tonic_pitch
300 %type <scm> chord_additions chord_subtractions chord_notes chord_step
302 %type <scm> chord_note chord_inversion chord_bass
303 %type <scm> duration_length fraction
305 %type <scm> embedded_scm scalar
306 %type <music> Music Sequential_music Simultaneous_music
307 %type <music> relative_music re_rhythmed_music part_combined_music
308 %type <music> property_def translator_change simple_property_def
309 %type <scm> Music_list
310 %type <outputdef> music_output_def_body
311 %type <music> shorthand_command_req
312 %type <music> post_event
313 %type <music> command_req verbose_command_req
314 %type <music> extender_req
315 %type <music> hyphen_req
316 %type <music> string_event
317 %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_event
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 ());
374 chordmodifiers_block:
375 CHORDMODIFIERS notenames_body { $$ = $2; }
379 PITCHNAMES notenames_body { $$ = $2; }
384 int i = scm_ilength ($1);
386 SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
387 for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
388 SCM pt = ly_cdar (s);
389 if (!unsmob_pitch (pt))
390 THIS->parser_error ("Need pitch object.");
392 scm_hashq_set_x (tab, ly_caar (s), pt);
399 lilypond_header_body:
401 $$ = ly_make_anonymous_module ();
402 THIS->lexer_->add_scope ($$);
404 | lilypond_header_body assignment {
410 HEADER '{' lilypond_header_body '}' {
411 $$ = THIS->lexer_-> remove_scope();
423 /* cont */ '=' identifier_init {
426 Should find generic way of associating input with objects.
428 Input ip = THIS->pop_spot ();
430 if (! regular_identifier_b ($1))
432 ip.warning (_ ("Identifier should have alphabetic characters only"));
435 THIS->lexer_->set_identifier ($1, $4);
438 TODO: devise standard for protection in parser.
440 The parser stack lives on the C-stack, which means that
441 all objects can be unprotected as soon as they're here.
452 $$ = $1->self_scm ();
453 scm_gc_unprotect_object ($$);
456 $$ = $1->self_scm ();
457 scm_gc_unprotect_object ($$);
459 | translator_spec_block {
463 $$ = $1->self_scm ();
464 scm_gc_unprotect_object ($$);
467 $$ = $1->self_scm ();
468 scm_gc_unprotect_object ($$);
473 | number_expression {
484 translator_spec_block:
485 TRANSLATOR '{' translator_spec_body '}'
491 translator_spec_body:
492 TRANSLATOR_IDENTIFIER {
494 unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
497 $$ = Translator_def::make_scm ();
498 Translator_def*td = unsmob_translator_def ($$);
499 td->translator_group_type_ = $2;
500 td->set_spot (THIS->here_input ());
502 | translator_spec_body STRING '=' embedded_scm {
503 unsmob_translator_def ($$)->add_property_assign ($2, $4);
505 | translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
506 unsmob_translator_def ($$)
507 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
509 | translator_spec_body STRING SET embedded_scm '=' embedded_scm {
510 unsmob_translator_def ($$)
511 ->add_push_property (scm_string_to_symbol ($2), $4, $6);
513 | translator_spec_body STRING REVERT embedded_scm {
514 unsmob_translator_def ($$)->add_pop_property (
515 scm_string_to_symbol ($2), $4);
517 | translator_spec_body NAME STRING {
518 unsmob_translator_def ($$)->type_name_ = $3;
520 | translator_spec_body CONSISTS STRING {
521 unsmob_translator_def ($$)->add_element ($3);
523 | translator_spec_body ALIAS STRING {
524 Translator_def*td = unsmob_translator_def ($$);
525 td->type_aliases_ = scm_cons ($3, td->type_aliases_);
527 | translator_spec_body GROBDESCRIPTIONS embedded_scm {
528 Translator_def*td = unsmob_translator_def($$);
529 // td->add_property_assign (ly_symbol2scm ("allGrobDescriptions"), $3);
530 for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
531 td->add_property_assign (scm_symbol_to_string (ly_caar (p)), ly_cdar (p));
533 | translator_spec_body CONSISTSEND STRING {
534 unsmob_translator_def ($$)->add_last_element ( $3);
536 | translator_spec_body ACCEPTS STRING {
537 unsmob_translator_def ($$)->set_acceptor ($3,true);
539 | translator_spec_body DENIES STRING {
540 unsmob_translator_def ($$)->set_acceptor ($3,false);
542 | translator_spec_body REMOVE STRING {
543 unsmob_translator_def ($$)->remove_element ($3);
554 /*cont*/ '{' score_body '}' {
557 if (!$$->defs_.size ())
559 Music_output_def *id =
560 unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
561 $$->add_output (id ? id->clone () : new Paper_def );
570 $$->set_spot (THIS->here_input ());
571 SCM m = $1->self_scm ();
572 scm_gc_unprotect_object (m);
577 SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
578 for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
579 m = gh_call1 (gh_car (check_funcs), m);
584 $$ = unsmob_score ($1);
585 $$->set_spot (THIS->here_input ());
587 | score_body lilypond_header {
590 | score_body output_def {
603 music_output_def_body '}' {
605 THIS-> lexer_-> remove_scope ();
609 music_output_def_body:
611 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
616 p = dynamic_cast<Midi_def*> (id->clone ());
621 THIS->lexer_->add_scope (p->scope_);
624 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
627 p = dynamic_cast<Paper_def*> (id->clone ());
631 THIS->lexer_->add_scope (p->scope_);
634 | PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
635 Music_output_def * o = unsmob_music_output_def ($3);
638 THIS->lexer_->add_scope (o->scope_);
640 | MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER {
641 Music_output_def * o = unsmob_music_output_def ($3);
644 THIS->lexer_->add_scope (o->scope_);
646 | music_output_def_body assignment {
649 | music_output_def_body translator_spec_block {
650 $$->assign_translator ($2);
652 | music_output_def_body tempo_event {
654 junk this ? there already is tempo stuff in
657 int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
658 Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
659 Midi_def * md = dynamic_cast<Midi_def*> ($$);
661 md->set_tempo (d->get_length (), m);
663 | music_output_def_body error {
669 TEMPO steno_duration '=' bare_unsigned {
670 $$ = MY_MAKE_MUSIC("TempoEvent");
671 $$->set_mus_property ("duration", $2);
672 $$->set_mus_property ("metronome-count", gh_int2scm ( $4));
677 The representation of a list is the
681 to have efficient append.
685 $$ = scm_cons (SCM_EOL, SCM_EOL);
689 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
690 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
691 if (gh_pair_p (ly_cdr (s)))
692 gh_set_cdr_x (ly_cdr (s), c); /* append */
694 gh_set_car_x (s, c); /* set first cons */
695 gh_set_cdr_x (s, c) ; /* remember last cell */
711 | ALTERNATIVE '{' Music_list '}' {
717 REPEAT string bare_unsigned Music Alternative_music
721 SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
722 if (times < scm_ilength (alts)) {
723 unsmob_music (gh_car (alts))
724 ->origin ()->warning (
725 _("More alternatives than repeats. Junking excess alternatives."));
726 alts = ly_truncate_list (times, alts);
732 proc = scm_c_eval_string ("make-repeated-music");
734 SCM mus = scm_call_1 (proc, $2);
735 scm_gc_protect_object (mus); // UGH.
736 Music *r =unsmob_music (mus);
739 r-> set_mus_property ("element", beg->self_scm ());
740 scm_gc_unprotect_object (beg->self_scm ());
742 r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
744 r-> set_mus_property ("elements",alts);
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));
757 r->set_spot (*$4->origin ());
764 SEQUENTIAL '{' Music_list '}' {
765 $$ = MY_MAKE_MUSIC("SequentialMusic");
766 $$->set_mus_property ("elements", ly_car ($3));
767 $$->set_spot(THIS->here_input());
769 | '{' Music_list '}' {
770 $$ = MY_MAKE_MUSIC("SequentialMusic");
771 $$->set_mus_property ("elements", ly_car ($2));
772 $$->set_spot(THIS->here_input());
777 SIMULTANEOUS '{' Music_list '}'{
778 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
779 $$->set_mus_property ("elements", ly_car ($3));
780 $$->set_spot(THIS->here_input());
783 | '<' Music_list '>' {
784 $$ = MY_MAKE_MUSIC("SimultaneousMusic");
785 $$->set_mus_property ("elements", ly_car ($2));
786 $$->set_spot(THIS->here_input());
791 event_chord { $$ = $1; }
792 | APPLYCONTEXT embedded_scm {
793 if (!gh_procedure_p ($2))
794 THIS->parser_error (_ ("\applycontext takes function argument"));
795 $$ = MY_MAKE_MUSIC ("ApplyContext");
796 $$->set_mus_property ("procedure", $2);
797 $$->set_spot (THIS->here_input());
799 | OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm {
801 if (!gh_symbol_p ($3))
803 THIS->parser_error (_ ("Second argument must be a symbol"));
805 /* Should check # args */
806 if (!gh_procedure_p (pred))
808 THIS->parser_error (_ ("First argument must be a procedure taking one argument"));
811 Music*m = MY_MAKE_MUSIC("OutputPropertySetMusic");
812 m->set_mus_property ("predicate", pred);
813 m->set_mus_property ("grob-property", $3);
814 m->set_mus_property ("grob-value", $5);
819 $$ = unsmob_music ($1);
827 CONTEXT STRING Music {
828 Music*csm =MY_MAKE_MUSIC("ContextSpeccedMusic");
830 csm->set_mus_property ("element", $3->self_scm ());
831 scm_gc_unprotect_object ($3->self_scm ());
833 csm->set_mus_property ("context-type",$2);
834 csm->set_mus_property ("context-id", scm_makfrom0str (""));
838 | AUTOCHANGE STRING Music {
839 Music*chm = MY_MAKE_MUSIC("AutoChangeMusic");
840 chm->set_mus_property ("element", $3->self_scm ());
841 chm->set_mus_property ("iterator-ctor", Auto_change_iterator::constructor_proc);
843 scm_gc_unprotect_object ($3->self_scm ());
844 chm->set_mus_property ("what", $2);
847 chm->set_spot (*$3->origin ());
852 The other version is for easier debugging of
853 Sequential_music_iterator in combination with grace notes.
856 SCM start = THIS->lexer_->lookup_identifier ("startGraceMusic");
857 SCM stop = THIS->lexer_->lookup_identifier ("stopGraceMusic");
858 Music *startm = unsmob_music (start);
859 Music *stopm = unsmob_music (stop);
863 stopm = stopm->clone ();
864 ms = scm_cons (stopm->self_scm (), ms);
865 scm_gc_unprotect_object (stopm->self_scm ());
867 ms = scm_cons ($2->self_scm (), ms);
868 scm_gc_unprotect_object ($2->self_scm());
870 startm = startm->clone ();
871 ms = scm_cons (startm->self_scm () , ms);
872 scm_gc_unprotect_object (startm->self_scm ());
876 Music* seq = MY_MAKE_MUSIC("SequentialMusic");
877 seq->set_mus_property ("elements", ms);
880 $$ = MY_MAKE_MUSIC("GraceMusic");
881 $$->set_mus_property ("element", seq->self_scm ());
882 scm_gc_unprotect_object (seq->self_scm ());
884 $$ = MY_MAKE_MUSIC("GraceMusic");
885 $$->set_mus_property ("element", $2->self_scm ());
886 scm_gc_unprotect_object ($2->self_scm ());
889 | CONTEXT string '=' string Music {
890 Music * csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
892 csm->set_mus_property ("element", $5->self_scm ());
893 scm_gc_unprotect_object ($5->self_scm ());
895 csm->set_mus_property ("context-type", $2);
896 csm->set_mus_property ("context-id", $4);
907 int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
909 $$= MY_MAKE_MUSIC("TimeScaledMusic");
910 $$->set_spot (THIS->pop_spot ());
913 $$->set_mus_property ("element", mp->self_scm ());
914 scm_gc_unprotect_object (mp->self_scm ());
915 $$->set_mus_property ("numerator", gh_int2scm (n));
916 $$->set_mus_property ("denominator", gh_int2scm (d));
917 $$->compress (Moment (Rational (n,d)));
920 | Repeated_music { $$ = $1; }
921 | Simultaneous_music { $$ = $1; }
922 | Sequential_music { $$ = $1; }
923 | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
924 $$ = MY_MAKE_MUSIC("TransposedMusic");
926 Pitch from = *unsmob_pitch ($2);
927 Pitch to = *unsmob_pitch ($3);
929 p->transpose (interval (from, to));
930 $$->set_mus_property ("element", p->self_scm ());
931 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());
1246 $$ = MY_MAKE_MUSIC("VoiceSeparator");
1247 $$->set_spot (THIS->here_input ());
1251 $$ = MY_MAKE_MUSIC("BarCheck");
1252 $$->set_spot (THIS->here_input ());
1255 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1257 Music *csm = MY_MAKE_MUSIC("ContextSpeccedMusic");
1258 csm->set_mus_property ("element", t->self_scm ());
1259 scm_gc_unprotect_object (t->self_scm ());
1262 $$->set_spot (THIS->here_input ());
1264 csm->set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1266 | PARTIAL duration_length {
1267 Moment m = - unsmob_duration ($2)->get_length ();
1268 Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1270 Music * sp = MY_MAKE_MUSIC("ContextSpeccedMusic");
1271 sp->set_mus_property ("element", p->self_scm ());
1272 scm_gc_unprotect_object (p->self_scm ());
1275 sp-> set_mus_property ("context-type", scm_makfrom0str ("Timing"));
1280 proc = scm_c_eval_string ("make-clef-set");
1282 SCM result = scm_call_1 (proc, $2);
1283 scm_gc_protect_object (result);
1284 $$ = unsmob_music (result);
1289 proc = scm_c_eval_string ("make-time-signature-set");
1291 SCM result = scm_apply_2 (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
1292 scm_gc_protect_object (result);
1293 $$ = unsmob_music (result);
1298 shorthand_command_req { $$ = $1; }
1299 | verbose_command_req { $$ = $1; }
1302 shorthand_command_req:
1310 $$ = MY_MAKE_MUSIC("TieEvent");
1313 Music *b= MY_MAKE_MUSIC("BeamEvent");
1314 b->set_mus_property ("span-direction", gh_int2scm (START));
1317 THIS->last_beam_start_ = b->self_scm ();
1320 Music *b= MY_MAKE_MUSIC("BeamEvent");
1321 b->set_mus_property ("span-direction", gh_int2scm (STOP));
1325 $$ = MY_MAKE_MUSIC("BreathingSignEvent");
1328 $$ = MY_MAKE_MUSIC("PorrectusEvent");
1332 verbose_command_req:
1334 Music * m = MY_MAKE_MUSIC("MarkEvent");
1338 Music *m = MY_MAKE_MUSIC("MarkEvent");
1339 m->set_mus_property ("label", $2);
1342 | SKIP duration_length {
1343 Music * skip = MY_MAKE_MUSIC("SkipEvent");
1344 skip->set_mus_property ("duration", $2);
1352 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1355 | KEY NOTENAME_PITCH SCM_IDENTIFIER {
1356 Music *key= MY_MAKE_MUSIC("KeyChangeEvent");
1358 key->set_mus_property ("pitch-alist", $3);
1359 ((Music*)key)->transpose (* unsmob_pitch ($2));
1368 | post_events post_event {
1369 $2->set_spot (THIS->here_input ());
1370 $$ = gh_cons ($2->self_scm(), $$);
1371 scm_gc_unprotect_object ($2->self_scm());
1384 Music * s = MY_MAKE_MUSIC("StringNumberEvent");
1385 s->set_mus_property ("string-number", gh_int2scm($1));
1386 s->set_spot (THIS->here_input ());
1392 event_that_take_dir:
1398 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1399 m->set_spot (THIS->here_input());
1400 m->set_mus_property ("span-direction" , gh_int2scm (START));
1404 Music * m = MY_MAKE_MUSIC ("NewBeamEvent");
1405 m->set_spot (THIS->here_input());
1406 m->set_mus_property ("span-direction" , gh_int2scm (STOP));
1410 Music * m = MY_MAKE_MUSIC ("NewTieEvent");
1411 m->set_spot (THIS->here_input());
1414 | script_abbreviation {
1415 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1416 Music *a = MY_MAKE_MUSIC("ArticulationEvent");
1417 if (gh_string_p (s))
1418 a->set_mus_property ("articulation-type", s);
1419 else THIS->parser_error (_ ("Expecting string as script definition"));
1425 script_dir event_that_take_dir {
1426 $2->set_mus_property ("direction", gh_int2scm ($1));
1433 $$ = unsmob_music ($1);
1436 Music * a = MY_MAKE_MUSIC("TremoloEvent");
1437 a->set_spot (THIS->here_input ());
1438 a->set_mus_property ("tremolo-type", gh_int2scm ($1));
1465 | NOTENAME_PITCH sup_quotes {
1466 Pitch p = *unsmob_pitch ($1);
1468 $$ = p.smobbed_copy ();
1470 | NOTENAME_PITCH sub_quotes {
1471 Pitch p =* unsmob_pitch ($1);
1474 $$ = p.smobbed_copy ();
1487 | TONICNAME_PITCH sup_quotes {
1488 Pitch p = *unsmob_pitch ($1);
1490 $$ = p.smobbed_copy ();
1492 | TONICNAME_PITCH sub_quotes {
1493 Pitch p =* unsmob_pitch ($1);
1496 $$ = p.smobbed_copy ();
1510 pitch_also_in_chords:
1516 PITCH embedded_scm {
1518 if (!unsmob_pitch ($2)) {
1519 THIS->parser_error (_f ("Expecting musical-pitch value", 3));
1520 $$ = Pitch ().smobbed_copy ();
1526 DURATION embedded_scm {
1528 if (!unsmob_duration ($2))
1530 THIS->parser_error (_ ("Must have duration object"));
1531 $$ = Duration ().smobbed_copy ();
1538 if (!THIS->lexer_->lyric_state_b ())
1539 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1540 $$ = MY_MAKE_MUSIC("ExtenderEvent");
1546 if (!THIS->lexer_->lyric_state_b ())
1547 THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1548 $$ = MY_MAKE_MUSIC("HyphenEvent");
1553 close_event_parens {
1555 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (START))
1562 Music * s= MY_MAKE_MUSIC("SlurEvent");
1564 s->set_spot (THIS->here_input());
1567 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1569 s->set_spot (THIS->here_input());
1572 Music *s =MY_MAKE_MUSIC("CrescendoEvent");
1574 s->set_spot (THIS->here_input());
1577 Music *s =MY_MAKE_MUSIC("DecrescendoEvent");
1579 s->set_spot (THIS->here_input());
1587 dynamic_cast<Music *> ($$)->set_mus_property ("span-direction", gh_int2scm (STOP))
1594 Music *s = MY_MAKE_MUSIC("CrescendoEvent");
1595 s->set_spot (THIS->here_input());
1600 Music * s= MY_MAKE_MUSIC("SlurEvent");
1602 s->set_spot (THIS->here_input());
1606 Music * s= MY_MAKE_MUSIC("PhrasingSlurEvent");
1608 s->set_mus_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
1609 s->set_spot (THIS->here_input());
1615 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1616 t->set_mus_property ("text", $1);
1617 t->set_spot (THIS->here_input ());
1621 Music *t = MY_MAKE_MUSIC("TextScriptEvent");
1622 t->set_mus_property ("text", $1);
1623 t->set_spot (THIS->here_input ());
1627 Music * t = MY_MAKE_MUSIC("FingerEvent");
1628 t->set_mus_property ("digit", gh_int2scm ($1));
1629 t->set_spot (THIS->here_input ());
1634 script_abbreviation:
1636 $$ = scm_makfrom0str ("Hat");
1639 $$ = scm_makfrom0str ("Plus");
1642 $$ = scm_makfrom0str ("Dash");
1645 $$ = scm_makfrom0str ("Bar");
1648 $$ = scm_makfrom0str ("Larger");
1651 $$ = scm_makfrom0str ("Dot");
1654 $$ = scm_makfrom0str ("Underscore");
1661 | '-' { $$ = CENTER; }
1668 | pre_events open_event {
1669 $$ = gh_cons ($2->self_scm(), $$);
1670 scm_gc_unprotect_object ($2->self_scm());
1681 multiplied_duration {
1684 | verbose_duration {
1689 optional_notemode_duration:
1691 Duration dd = THIS->default_duration_;
1692 $$ = dd.smobbed_copy ();
1694 THIS->beam_check ($$);
1696 | multiplied_duration {
1698 THIS->default_duration_ = *unsmob_duration ($$);
1700 THIS->beam_check ($$);
1702 | verbose_duration {
1704 THIS->default_duration_ = *unsmob_duration ($$);
1709 bare_unsigned dots {
1711 if (!is_duration_b ($1))
1712 THIS->parser_error (_f ("not a duration: %d", $1));
1716 $$ = Duration (l, $2).smobbed_copy ();
1718 | DURATION_IDENTIFIER dots {
1719 Duration *d =unsmob_duration ($1);
1720 Duration k (d->duration_log (),d->dot_count () + $2);
1730 multiplied_duration:
1734 | multiplied_duration '*' bare_unsigned {
1735 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1737 | multiplied_duration '*' FRACTION {
1738 Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
1740 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1745 FRACTION { $$ = $1; }
1746 | UNSIGNED '/' UNSIGNED {
1747 $$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
1765 | ':' bare_unsigned {
1766 if (!is_duration_b ($2))
1767 THIS->parser_error (_f ("not a duration: %d", $2));
1774 /*****************************************************************
1776 *****************************************************************/
1790 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1791 $$ = bfr->self_scm();
1792 scm_gc_unprotect_object ($$);
1795 Music *bfr = MY_MAKE_MUSIC("BassFigureEvent");
1796 $$ = bfr->self_scm();
1798 bfr->set_mus_property ("figure", gh_int2scm ($1));
1800 scm_gc_unprotect_object ($$);
1802 | bass_figure bass_mod {
1803 Music *m = unsmob_music ($1);
1805 SCM salter =m->get_mus_property ("alteration");
1806 int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
1807 m->set_mus_property ("alteration",
1808 gh_int2scm (alter + $2));
1810 m->set_mus_property ("alteration", gh_int2scm (0));
1818 unsmob_music ($$)->set_mus_property ("bracket-start", SCM_BOOL_T);
1823 | br_bass_figure ']' {
1825 unsmob_music ($1)->set_mus_property ("bracket-stop", SCM_BOOL_T);
1833 | figure_list br_bass_figure {
1834 $$ = scm_cons ($2, $1);
1839 FIGURE_OPEN figure_list FIGURE_CLOSE {
1840 Music * m = MY_MAKE_MUSIC("EventChord");
1841 $2 = scm_reverse_x ($2, SCM_EOL);
1842 m->set_mus_property ("elements", $2);
1843 $$ = m->self_scm ();
1854 pitch exclamations questions optional_notemode_duration optional_rest {
1856 Input i = THIS->pop_spot ();
1857 if (!THIS->lexer_->note_state_b ())
1858 THIS->parser_error (_ ("Have to be in Note mode for notes"));
1862 n = MY_MAKE_MUSIC("RestEvent");
1864 n = MY_MAKE_MUSIC("NoteEvent");
1866 n->set_mus_property ("pitch", $1);
1867 n->set_mus_property ("duration", $4);
1871 n->set_mus_property ("cautionary", SCM_BOOL_T);
1872 if ($2 % 2 || $3 % 2)
1873 n->set_mus_property ("force-accidental", SCM_BOOL_T);
1875 Music *v = MY_MAKE_MUSIC("EventChord");
1876 v->set_mus_property ("elements", scm_list_n (n->self_scm (), SCM_UNDEFINED));
1877 scm_gc_unprotect_object (n->self_scm());
1883 | figure_spec optional_notemode_duration {
1884 Music * m = unsmob_music ($1);
1885 Input i = THIS->pop_spot ();
1887 for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
1889 unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
1893 | RESTNAME optional_notemode_duration {
1895 Input i = THIS->pop_spot ();
1897 if (ly_scm2string ($1) =="s") {
1899 ev = MY_MAKE_MUSIC("SkipEvent");
1902 ev = MY_MAKE_MUSIC("RestEvent");
1905 ev->set_mus_property ("duration" ,$2);
1907 Music * velt = MY_MAKE_MUSIC("EventChord");
1908 velt->set_mus_property ("elements", scm_list_n (ev->self_scm (),SCM_UNDEFINED));
1913 | MULTI_MEASURE_REST optional_notemode_duration {
1918 proc = scm_c_eval_string ("make-multi-measure-rest");
1920 SCM mus = scm_call_2 (proc, $2,
1921 make_input (THIS->here_input()));
1922 scm_gc_protect_object (mus);
1923 $$ = unsmob_music (mus);
1925 | STRING optional_notemode_duration {
1926 Input i = THIS->pop_spot ();
1928 Music * lreq = MY_MAKE_MUSIC("LyricEvent");
1929 lreq->set_mus_property ("text", $1);
1930 lreq->set_mus_property ("duration",$2);
1932 Music * velt = MY_MAKE_MUSIC("EventChord");
1933 velt->set_mus_property ("elements", scm_list_n (lreq->self_scm (), SCM_UNDEFINED));
1940 if (!THIS->lexer_->chord_state_b ())
1941 THIS->parser_error (_ ("Have to be in Chord mode for chords"));
1948 steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
1949 $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
1950 $$->set_spot (THIS->here_input ());
1957 | CHORD_COLON chord_notes {
1966 | chord_notes '.' chord_step {
1967 $$ = gh_append2 ($$, $3);
1975 | CHORD_CARET chord_notes {
1985 | CHORD_SLASH steno_tonic_pitch {
1994 | CHORD_BASS steno_tonic_pitch {
2001 $$ = scm_cons ($1, SCM_EOL);
2003 | CHORDMODIFIER_PITCH {
2004 $$ = scm_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
2006 | CHORDMODIFIER_PITCH chord_note { /* Ugh. */
2007 $$ = scm_list_n (unsmob_pitch ($1)->smobbed_copy (),
2015 m.notename_ = ($1 - 1) % 7;
2016 m.octave_ = $1 > 7 ? 1 : 0;
2019 $$ = m.smobbed_copy ();
2021 | bare_unsigned '+' {
2023 m.notename_ = ($1 - 1) % 7;
2024 m.octave_ = $1 > 7 ? 1 : 0;
2028 $$ = m.smobbed_copy ();
2030 | bare_unsigned CHORD_MINUS {
2032 m.notename_ = ($1 - 1) % 7;
2033 m.octave_ = $1 > 7 ? 1 : 0;
2036 $$ = m.smobbed_copy ();
2044 number_expression '+' number_term {
2045 $$ = scm_sum ($1, $3);
2047 | number_expression '-' number_term {
2048 $$ = scm_difference ($1, $3);
2057 | number_factor '*' number_factor {
2058 $$ = scm_product ($1, $3);
2060 | number_factor '/' number_factor {
2061 $$ = scm_divide ($1, $3);
2066 '-' number_factor { /* %prec UNARY_MINUS */
2067 $$ = scm_difference ($2, SCM_UNDEFINED);
2075 $$ = gh_int2scm ($1);
2080 | NUMBER_IDENTIFIER {
2083 | REAL NUMBER_IDENTIFIER {
2084 $$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
2086 | UNSIGNED NUMBER_IDENTIFIER {
2087 $$ = gh_double2scm ($1 * gh_scm2double ($2));
2103 if (scm_integer_p ($1) == SCM_BOOL_T)
2105 int k = gh_scm2int ($1);
2109 THIS->parser_error (_ ("need integer number arg"));
2123 | STRING_IDENTIFIER {
2126 | string '+' string {
2127 $$ = scm_string_append (scm_list_n ($1, $3, SCM_UNDEFINED));
2134 | exclamations '!' { $$ ++; }
2139 | questions '?' { $$ ++; }
2146 My_lily_parser::set_yydebug (bool )
2153 extern My_lily_parser * current_parser;
2156 My_lily_parser::do_yyparse ()
2158 current_parser = this;;
2159 yyparse ((void*)this);
2164 Should make this optional? It will also complain when you do
2168 which is entirely legitimate.
2170 Or we can scrap it. Barchecks should detect wrong durations, and
2171 skipTypesetting speeds it up a lot.
2175 My_lily_parser::beam_check (SCM dur)
2177 Duration *d = unsmob_duration (dur);
2178 if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2180 Music * m = unsmob_music (last_beam_start_);
2181 m->origin ()->warning (_("Suspect duration found following this beam"));
2183 last_beam_start_ = SCM_EOL;
2188 It is a little strange, to have this function in this file, but
2189 otherwise, we have to import music classes into the lexer.
2193 My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
2195 if (gh_string_p (sid)) {
2197 return STRING_IDENTIFIER;
2198 } else if (gh_number_p (sid)) {
2200 return NUMBER_IDENTIFIER;
2201 } else if (unsmob_translator_def (sid)) {
2202 *destination = unsmob_translator_def (sid)->clone_scm();
2203 return TRANSLATOR_IDENTIFIER;
2204 } else if (unsmob_score (sid)) {
2205 Score *sc = new Score (*unsmob_score (sid));
2206 *destination =sc->self_scm ();
2207 return SCORE_IDENTIFIER;
2208 } else if (Music * mus =unsmob_music (sid)) {
2209 *destination = unsmob_music (sid)->clone ()->self_scm();
2210 unsmob_music (*destination)->
2211 set_mus_property ("origin", make_input (last_input_));
2212 return dynamic_cast<Event*> (mus)
2213 ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2214 } else if (unsmob_duration (sid)) {
2215 *destination = unsmob_duration (sid)->smobbed_copy();
2216 return DURATION_IDENTIFIER;
2217 } else if (unsmob_music_output_def (sid)) {
2218 Music_output_def *p = unsmob_music_output_def (sid);
2221 *destination = p->self_scm();
2222 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2230 $$ = scm_list_n (scm_c_eval_string ("simple-markup"), $1, SCM_UNDEFINED);
2232 | MARKUP_HEAD0 markup
2233 | MARKUP_HEAD1 SCM_T markup
2234 | MARKUP_HEAD2 markup
2242 '<' markup_list_body '>' { $$ = scm_reverse_x ($1, SCM_EOL); }
2246 '{' markup_list_body '}' { $$ = .. scm_reverse_x ($1, SCM_EOL); }
2250 /**/ { $$ = SCM_EOL; }
2251 markup_list_body markup {
2252 $$ = gh_cons ($2, $1) ;