lily/parser.yy

   1 %{ // -*-Fundamental-*-
   2
   3 /*
   4   parser.yy -- Bison/C++ parser for LilyPond
   5
   6   source file of the GNU LilyPond music typesetter
   7
   8   (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   9                  Jan Nieuwenhuizen <janneke@gnu.org>
  10 */
  11
  12 /*
  13
  14 TODO:
  15
  16 * The rules for who is protecting what are very shady. Uniformise
  17   this.
  18
  19 * There are too many lexical modes?
  20
  21 */
  22
  23 #include <ctype.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26
  27
  28 #include "book.hh"
  29 #include "book-paper-def.hh"
  30 #include "context-def.hh"
  31 #include "dimensions.hh"
  32 #include "event.hh"
  33 #include "file-path.hh"
  34 #include "input-smob.hh"
  35 #include "input.hh"
  36 #include "lily-guile.hh"
  37 #include "lilypond-input-version.hh"
  38 #include "ly-module.hh"
  39 #include "main.hh"
  40 #include "midi-def.hh"
  41 #include "misc.hh"
  42 #include "music-list.hh"
  43 #include "music-sequence.hh"
  44 #include "my-lily-lexer.hh"
  45 #include "my-lily-parser.hh"
  46 #include "paper-book.hh"
  47 #include "paper-def.hh"
  48 #include "scm-hash.hh"
  49 #include "scm-option.hh"
  50 #include "score.hh"
  51 #include "text-item.hh"
  52 #include "warn.hh"
  53
  54 #define MY_MAKE_MUSIC(x)  make_music_by_name (ly_symbol2scm (x))
  55
  56 Music *property_op_to_music (SCM op);
  57 Music *context_spec_music (SCM type, SCM id, Music *m, SCM ops_);
  58 SCM get_next_unique_context ();
  59
  60 #define YYERROR_VERBOSE 1
  61
  62 #define YYPARSE_PARAM my_lily_parser
  63 #define YYLEX_PARAM my_lily_parser
  64 #define THIS\
  65         ((My_lily_parser *) my_lily_parser)
  66
  67 #define yyerror THIS->parser_error
  68
  69 /* Add symbols to the TAGS field of a music object.  */
  70
  71 void
  72 tag_music (Music *m, SCM tag, Input ip)
  73 {
  74         SCM tags = m->get_property ("tags");
  75         if (ly_c_symbol_p (tag))
  76                 tags = scm_cons (tag, tags);
  77         else if (ly_c_list_p (tag))
  78                 tags = ly_append2 (tag, tags);
  79         else
  80                 ip.warning (_ ("Tag must be symbol or list of symbols."));
  81
  82         m->set_property ("tags", tags);
  83 }
  84
  85 bool
  86 is_regular_identifier (SCM id)
  87 {
  88   String str = ly_scm2string (id);
  89   char const *s = str.to_str0 ();
  90
  91   bool v = true;
  92 #if 0
  93   isalpha (*s);
  94   s++;
  95 #endif
  96   while (*s && v)
  97    {
  98         v = v && isalnum (*s);
  99         s++;
 100    }
 101   return v;
 102 }
 103
 104 SCM
 105 make_simple_markup (SCM encoding, SCM a)
 106 {
 107         SCM simple = ly_scheme_function ("simple-markup");
 108         if (ly_c_symbol_p (encoding))
 109                 return scm_list_3 (ly_scheme_function ("encoded-simple-markup"),
 110                            encoding, a);
 111         return scm_list_2 (simple, a);
 112 }
 113
 114 bool
 115 is_duration (int t)
 116 {
 117   return t && t == 1 << intlog2 (t);
 118 }
 119
 120 void
 121 set_music_properties (Music *p, SCM a)
 122 {
 123   for (SCM k = a; ly_c_pair_p (k); k = ly_cdr (k))
 124         p->internal_set_property (ly_caar (k), ly_cdar (k));
 125 }
 126
 127 SCM
 128 make_chord_step (int step, int alter)
 129 {
 130         if (step == 7)
 131                 alter += FLAT;
 132
 133         while (step < 0)
 134                 step += 7;
 135         Pitch m ((step -1) / 7, (step - 1) % 7, alter);
 136         return m.smobbed_copy ();
 137 }
 138
 139
 140 SCM
 141 make_chord (SCM pitch, SCM dur, SCM modification_list)
 142 {
 143         SCM chord_ctor = ly_scheme_function ("construct-chord");
 144         SCM ch = scm_call_3 (chord_ctor, pitch, dur, modification_list);
 145         scm_gc_protect_object (ch);
 146         return ch;
 147 }
 148
 149 /* Todo: actually also use apply iso. call too ...  */
 150 bool
 151 ly_input_procedure_p (SCM x)
 152 {
 153         return ly_c_procedure_p (x)
 154                 || (ly_c_pair_p (x) && ly_c_procedure_p (ly_car (x)));
 155 }
 156
 157 Music*
 158 set_property_music (SCM sym, SCM value)
 159 {
 160         Music *p = MY_MAKE_MUSIC ("PropertySet");
 161         p->set_property ("symbol", sym);
 162         p->set_property ("value", value);
 163         return p;
 164 }
 165
 166 Music*
 167 make_music_relative (Pitch start, Music *music)
 168 {
 169         Music *relative = MY_MAKE_MUSIC ("RelativeOctaveMusic");
 170         relative->set_property ("element", music->self_scm ());
 171
 172         Pitch last = music->to_relative_octave (start);
 173         if (lily_1_8_relative)
 174                 music->set_property ("last-pitch", last.smobbed_copy ());
 175         return relative;
 176 }
 177
 178 Music*
 179 make_lyric_combine_music (SCM name, Music *music)
 180 {
 181         Music *combine = MY_MAKE_MUSIC ("NewLyricCombineMusic");
 182         combine->set_property ("element", music->self_scm ());
 183         combine->set_property ("associated-context", name);
 184         return combine;
 185 }
 186
 187 %}
 188
 189 /* We use SCMs to do strings, because it saves us the trouble of
 190 deleting them.  Let's hope that a stack overflow doesnt trigger a move
 191 of the parse stack onto the heap. */
 192
 193 %left NEWLYRICS
 194
 195 %union {
 196         Book *book;
 197         Music_output_def *outputdef;
 198         SCM scm;
 199         String *string;
 200         Music *music;
 201         Score *score;
 202         int i;
 203 }
 204 %{
 205
 206 int
 207 yylex (YYSTYPE *s, void *v)
 208 {
 209         My_lily_parser *pars = (My_lily_parser*) v;
 210         My_lily_lexer *lex = pars->lexer_;
 211
 212         lex->lexval = (void*) s;
 213         lex->prepare_for_next_token ();
 214         return lex->yylex ();
 215 }
 216
 217
 218 %}
 219
 220 %expect 3
 221
 222 /*
 223   Three shift/reduce problems:
 224
 225 2. \markup identifier.
 226
 227 3. \markup { }
 228
 229 4.  \repeat
 230         \repeat .. \alternative
 231
 232
 233     \repeat { \repeat .. \alternative }
 234
 235 or
 236
 237     \repeat { \repeat } \alternative
 238
 239 )
 240  */
 241
 242
 243 %pure_parser
 244
 245 %token ACCEPTS
 246 %token ADDQUOTE
 247 %token LYRICSTO
 248 %token ALIAS
 249 %token ALTERNATIVE
 250 %token BAR
 251 %token BOOK
 252 %token CHANGE
 253 %token CHORDMODIFIERS
 254 %token CHORDS
 255 %token DOUBLE_ANGLE_OPEN
 256 %token DOUBLE_ANGLE_CLOSE
 257 %token CLEF
 258 %token COMMANDSPANREQUEST
 259 %token CONSISTS
 260 %token CONSISTSEND
 261 %token CONTEXT
 262 %token DEFAULT
 263 %token DENIES
 264 %token DESCRIPTION
 265 %token EXTENDER
 266 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
 267 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
 268 %token GROBDESCRIPTIONS
 269 %token HEADER
 270 %token HYPHEN
 271 %token INVALID
 272 %token KEY
 273 %token LYRICS
 274 %token LYRICS_STRING
 275 %token MARK
 276 %token MIDI
 277 %token MULTI_MEASURE_REST
 278 %token NAME
 279 %token NEWCONTEXT
 280 %token NOTES
 281 %token OCTAVE
 282 %token ONCE
 283 %token OVERRIDE SET REVERT
 284 %token PAPER
 285 %token PARTIAL
 286 %token QUOTE
 287 %token RELATIVE
 288 %token REMOVE
 289 %token REPEAT
 290 %token REST
 291 %token SCM_T
 292 %token SCORE
 293 %token SEQUENTIAL
 294 %token NEWLYRICS
 295 %token SIMULTANEOUS
 296 %token SKIP
 297 %token SPANREQUEST
 298 %token TAG
 299 %token TEMPO
 300 %token TIMES
 301 %token TIME_T
 302 %token TRANSPOSE
 303 %token TRANSPOSITION
 304 %token TYPE
 305 %token UNSET
 306 %token WITH
 307
 308 /* escaped */
 309 /* FIXME: this sucks.  The user will get to see these names:
 310     syntax error, unexpected E_CHAR:
 311                 \
 312                  %%
 313   */
 314 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
 315 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
 316 %token E_BACKSLASH
 317 %token <i> E_UNSIGNED
 318 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET  CHORD_SLASH
 319 %token FIGURE_SPACE
 320
 321 %token <i>      DIGIT
 322 %token <scm>    NOTENAME_PITCH
 323 %token <scm>    TONICNAME_PITCH
 324 %token <scm>    CHORDMODIFIER_PITCH
 325 %token <scm>    DURATION_IDENTIFIER
 326 %token <scm>    FRACTION
 327 %token <id>     IDENTIFIER
 328 %token DRUMS
 329 %token <scm>    DRUM_PITCH
 330 %token <scm>    CHORD_MODIFIER
 331 %token <scm>    SCORE_IDENTIFIER
 332 %token <scm>    MUSIC_OUTPUT_DEF_IDENTIFIER
 333 %token <scm>    NUMBER_IDENTIFIER
 334 %token <scm>    EVENT_IDENTIFIER
 335 %token <scm>    MUSIC_IDENTIFIER CONTEXT_DEF_IDENTIFIER
 336 %token <scm>    STRING_IDENTIFIER SCM_IDENTIFIER
 337 %token <scm>    RESTNAME
 338 %token <scm>    STRING
 339 %token <scm>    SCM_T
 340 %token <i>      UNSIGNED
 341 %token <scm>   REAL
 342
 343 %token MARKUP
 344 %token <scm> MARKUP_HEAD_MARKUP0
 345 %token <scm> MARKUP_HEAD_EMPTY
 346 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
 347 %token <scm> MARKUP_HEAD_SCM0
 348 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
 349 %token <scm> MARKUP_HEAD_SCM0_SCM1
 350 %token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
 351 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
 352
 353 %token <scm> MUSIC_FUNCTION
 354 %token <scm> MUSIC_FUNCTION_SCM
 355 %token <scm> MUSIC_FUNCTION_MUSIC
 356 %token <scm> MUSIC_FUNCTION_SCM_MUSIC
 357 %token <scm> MUSIC_FUNCTION_MUSIC_MUSIC
 358 %token <scm> MUSIC_FUNCTION_SCM_SCM_MUSIC
 359 %token <scm> MUSIC_FUNCTION_SCM_MUSIC_MUSIC
 360
 361 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
 362 %type <scm> markup markup_line markup_list  markup_list_body full_markup
 363
 364 %type <book>    book_block book_body
 365 %type <i>       exclamations questions dots optional_rest
 366 %type <i>       bass_mod
 367 %type <scm>     oct_check
 368 %type <scm>     context_mod_list
 369 %type <scm>     lyric_element
 370 %type <scm>     bass_number br_bass_figure bass_figure figure_list figure_spec
 371 %type <scm>     new_lyrics
 372 %type <outputdef> output_def
 373 %type <scm>     lilypond_header lilypond_header_body
 374 %type <music>   open_event close_event
 375 %type <i>       sub_quotes sup_quotes
 376 %type <music>   toplevel_music
 377 %type <music>   simple_element event_chord command_element
 378 %type <music>   Composite_music Simple_music Prefix_composite_music Generic_prefix_music
 379 %type <scm>     Generic_prefix_music_scm
 380 %type <music>   Grouped_music_list
 381 %type <music>   Repeated_music
 382 %type <scm>     Alternative_music
 383 %type <i>       tremolo_type
 384 %type <i>       bare_int  bare_unsigned
 385 %type <i>       script_dir
 386 %type <scm>     identifier_init
 387 %type <scm>     simple_string
 388
 389 %type <music>   note_chord_element chord_body chord_body_element
 390 %type <scm>     chord_body_elements
 391 %type <scm>     steno_duration optional_notemode_duration multiplied_duration
 392
 393 %type <scm>     post_events
 394 %type <music>   gen_text_def direction_less_event direction_reqd_event
 395 %type <scm>     steno_pitch pitch absolute_pitch pitch_also_in_chords
 396 %type <scm>     steno_tonic_pitch
 397 %type <scm>     duration_length fraction
 398
 399 %type <scm>     chord_item chord_items chord_separator new_chord
 400 %type <scm>     step_number step_numbers
 401
 402 %type <scm>     embedded_scm scalar
 403 %type <music>   Music Sequential_music Simultaneous_music
 404 %type <music>   relative_music re_rhythmed_music
 405 %type <music>   music_property_def context_change
 406 %type <scm>     context_prop_spec
 407 %type <scm>     Music_list
 408 %type <scm>     property_operation
 409 %type <scm>     context_mod context_def_mod optional_context_mod
 410 %type <outputdef>       music_output_def_body music_output_def_head
 411 %type <music>   post_event tagged_post_event
 412 %type <music>   command_req
 413 %type <music>   string_number_event
 414 %type <scm>     string bare_number number_expression number_term number_factor
 415 %type <score>   score_block score_body
 416
 417 %type <scm>     context_def_spec_block context_def_spec_body
 418 %type <music>   tempo_event
 419 %type <scm>     script_abbreviation
 420
 421
 422
 423 %left '-' '+'
 424
 425 /* We don't assign precedence to / and *, because we might need varied
 426 prec levels in different prods */
 427
 428 %left UNARY_MINUS
 429
 430 %%
 431
 432 lilypond:       /* empty */
 433         | lilypond toplevel_expression {
 434         }
 435         | lilypond assignment {
 436         }
 437         | lilypond error {
 438                 THIS->error_level_ = 1;
 439         }
 440         | lilypond INVALID      {
 441                 THIS->error_level_ = 1;
 442         }
 443         ;
 444
 445 toplevel_expression:
 446         lilypond_header {
 447                 THIS->header_ = $1;
 448         }
 449         | add_quote {
 450
 451         }
 452         | book_block {
 453                 Book *book = $1;
 454                 SCM proc = THIS->lexer_->lookup_identifier ("toplevel-book-handler");
 455                 scm_call_2 (proc, THIS->self_scm (), book->self_scm ());
 456                 scm_gc_unprotect_object (book->self_scm ());
 457         }
 458         | score_block {
 459                 Score *score = $1;
 460
 461                 SCM proc = THIS->lexer_->lookup_identifier ("toplevel-score-handler");
 462                 scm_call_2 (proc, THIS->self_scm (), score->self_scm ());
 463                 scm_gc_unprotect_object (score->self_scm ());
 464         }
 465         | toplevel_music {
 466                 Music *music = $1;
 467                 SCM proc = THIS->lexer_->lookup_identifier ("toplevel-music-handler");
 468                 scm_call_2 (proc, THIS->self_scm (), music->self_scm ());
 469                 scm_gc_unprotect_object (music->self_scm ());
 470         }
 471         | output_def {
 472                 SCM id = SCM_EOL;
 473                 if (dynamic_cast<Paper_def*> ($1))
 474                         id = scm_makfrom0str ("$defaultpaper");
 475                 else if (dynamic_cast<Midi_def*> ($1))
 476                         id = scm_makfrom0str ("$defaultmidi");
 477                 THIS->lexer_->set_identifier (id, $1->self_scm ());
 478                 scm_gc_unprotect_object ($1->self_scm ());
 479         }
 480         ;
 481
 482 toplevel_music:
 483         Composite_music {
 484         }
 485         ;
 486
 487 embedded_scm:
 488         SCM_T
 489         | SCM_IDENTIFIER
 490         ;
 491
 492
 493 lilypond_header_body:
 494         {
 495                 $$ = ly_make_anonymous_module (safe_global_b);
 496                 THIS->lexer_->add_scope ($$);
 497         }
 498         | lilypond_header_body assignment  {
 499
 500         }
 501         ;
 502
 503 lilypond_header:
 504         HEADER '{' lilypond_header_body '}'     {
 505                 $$ = THIS->lexer_->remove_scope ();
 506         }
 507         ;
 508
 509
 510 /*
 511         DECLARATIONS
 512 */
 513 assignment:
 514         STRING {
 515                 THIS->push_spot ();
 516         }
 517         /* cont */ '=' identifier_init  {
 518
 519         /*
 520                 Should find generic way of associating input with objects.
 521         */
 522                 Input ip = THIS->pop_spot ();
 523
 524                 if (! is_regular_identifier ($1))
 525                 {
 526                         ip.warning (_ ("Identifier should have alphabetic characters only"));
 527                 }
 528
 529                 THIS->lexer_->set_identifier ($1, $4);
 530
 531 /*
 532  TODO: devise standard for protection in parser.
 533
 534   The parser stack lives on the C-stack, which means that
 535 all objects can be unprotected as soon as they're here.
 536
 537 */
 538         }
 539         | embedded_scm { }
 540         ;
 541
 542
 543 identifier_init:
 544         score_block {
 545                 $$ = $1->self_scm ();
 546                 scm_gc_unprotect_object ($$);
 547         }
 548         | full_markup {
 549                 $$ = $1;
 550         }
 551         | output_def {
 552                 $$ = $1->self_scm ();
 553                 scm_gc_unprotect_object ($$);
 554         }
 555         | context_def_spec_block {
 556                 $$ = $1;
 557         }
 558         | Music  {
 559                 $$ = $1->self_scm ();
 560                 scm_gc_unprotect_object ($$);
 561         }
 562         | post_event {
 563                 $$ = $1->self_scm ();
 564                 scm_gc_unprotect_object ($$);
 565         }
 566         | number_expression {
 567                 $$ = $1;
 568         }
 569         | string {
 570                 $$ = $1;
 571         }
 572         | embedded_scm  {
 573                 $$ = $1;
 574         }
 575         ;
 576
 577 context_def_spec_block:
 578         CONTEXT '{' context_def_spec_body '}'
 579                 {
 580                 $$ = $3;
 581         }
 582         ;
 583
 584 context_def_spec_body:
 585         /**/ {
 586                 $$ = Context_def::make_scm ();
 587                 unsmob_context_def ($$)->set_spot (THIS->here_input ());
 588         }
 589         | CONTEXT_DEF_IDENTIFIER {
 590                 $$ = $1;
 591                 unsmob_context_def ($$)->set_spot (THIS->here_input ());
 592         }
 593         | context_def_spec_body GROBDESCRIPTIONS embedded_scm {
 594                 Context_def*td = unsmob_context_def ($$);
 595
 596                 for (SCM p = $3; ly_c_pair_p (p); p = ly_cdr (p)) {
 597                         SCM tag = ly_caar (p);
 598
 599                         /* TODO: should make new tag "grob-definition" ? */
 600                         td->add_context_mod (scm_list_3 (ly_symbol2scm ("assign"),
 601                                                         tag, scm_cons (ly_cdar (p), SCM_EOL)));
 602                 }
 603         }
 604         | context_def_spec_body context_mod {
 605                 unsmob_context_def ($$)->add_context_mod ($2);
 606         }
 607         ;
 608
 609 book_block:
 610         BOOK {
 611                 THIS->push_spot ();
 612         }
 613         /*cont*/ '{' book_body '}'      {
 614                 THIS->pop_spot ();
 615                 $$ = $4;
 616         }
 617         ;
 618
 619 /* FIXME:
 620    * Use 'handlers' like for toplevel-* stuff?
 621    * grok \paper and \midi?  */
 622 book_body:
 623         {
 624                 $$ = new Book;
 625                 $$->set_spot (THIS->here_input ());
 626                 $$->bookpaper_ = unsmob_book_paper_def (THIS->lexer_->lookup_identifier ("$defaultbookpaper"));
 627         }
 628         | book_body score_block {
 629                 Score *score = $2;
 630                 $$->scores_.push (score);
 631                 scm_gc_unprotect_object (score->self_scm ());
 632         }
 633         | book_body Composite_music {
 634                 Music *music = $2;
 635                 Score *score
 636                         = unsmob_score (ly_music_scorify (music->self_scm ()));
 637                 $$->scores_.push (score);
 638                 scm_gc_unprotect_object (music->self_scm ());
 639         }
 640         | lilypond_header {
 641                 THIS->header_ = $1;
 642         }
 643         | book_body error {
 644         }
 645         ;
 646
 647 score_block:
 648         SCORE {
 649                 THIS->push_spot ();
 650         }
 651         /*cont*/ '{' score_body '}'     {
 652                 THIS->pop_spot ();
 653                 $$ = $4;
 654         }
 655         ;
 656
 657 score_body:
 658         Music   {
 659                 $$ = new Score;
 660
 661                 $$->set_spot (THIS->here_input ());
 662                 SCM m = $1->self_scm ();
 663                 scm_gc_unprotect_object (m);
 664
 665                 /*
 666                         guh.
 667                 */
 668                 SCM check_funcs = ly_scheme_function ("toplevel-music-functions");
 669                 for (; ly_c_pair_p (check_funcs); check_funcs = ly_cdr (check_funcs))
 670                         m = scm_call_1 (ly_car (check_funcs), m);
 671                 $$->music_ = m;
 672
 673         }
 674         | SCORE_IDENTIFIER {
 675                 $$ = new Score ( *unsmob_score ($1));
 676                 $$->set_spot (THIS->here_input ());
 677         }
 678         | score_body lilypond_header    {
 679                 $$->header_ = $2;
 680         }
 681         | score_body output_def {
 682                 $$->defs_.push ($2);
 683                 scm_gc_unprotect_object ($2->self_scm ());
 684         }
 685         | score_body error {
 686
 687         }
 688         ;
 689
 690
 691 /*
 692         MIDI
 693 */
 694 output_def:
 695         music_output_def_body '}' {
 696                 $$ = $1;
 697                 THIS->lexer_->remove_scope ();
 698                 THIS->lexer_->pop_state ();
 699         }
 700         ;
 701
 702 music_output_def_head:
 703         MIDI    {
 704                 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
 705
 706
 707                 Midi_def *p = 0;
 708                 if (id)
 709                         p = dynamic_cast<Midi_def*> (id->clone ());
 710                 else
 711                         p = new Midi_def;
 712
 713                 $$ = p;
 714                 THIS->lexer_->add_scope (p->scope_);
 715         }
 716         | PAPER         {
 717                 Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
 718                   Paper_def *p = 0;
 719                 if (id)
 720                         p = dynamic_cast<Paper_def*> (id->clone ());
 721                 else
 722                         p = new Paper_def;
 723
 724                 THIS->lexer_->add_scope (p->scope_);
 725                 $$ = p;
 726         }
 727         ;
 728
 729
 730 music_output_def_body:
 731         music_output_def_head '{' {
 732                 $$ = $1;
 733                 $$->input_origin_. set_spot (THIS->here_input ());
 734                 THIS->lexer_->push_initial_state ();
 735         }
 736         | music_output_def_head '{' MUSIC_OUTPUT_DEF_IDENTIFIER         {
 737                 scm_gc_unprotect_object ($1->self_scm ());
 738                 Music_output_def *o = unsmob_music_output_def ($3);
 739                 o->input_origin_.set_spot (THIS->here_input ());
 740                 $$ = o;
 741                 THIS->lexer_->remove_scope ();
 742                 THIS->lexer_->add_scope (o->scope_);
 743                 THIS->lexer_->push_initial_state ();
 744         }
 745         | music_output_def_body assignment  {
 746
 747         }
 748         | music_output_def_body context_def_spec_block  {
 749                 $$->assign_context_def ($2);
 750         }
 751         | music_output_def_body tempo_event  {
 752                 /*
 753                         junk this ? there already is tempo stuff in
 754                         music.
 755                 */
 756                 int m = ly_scm2int ( $2->get_property ("metronome-count"));
 757                 Duration *d = unsmob_duration ($2->get_property ("tempo-unit"));
 758                 Midi_def *md = dynamic_cast<Midi_def*> ($$);
 759                 if (md)
 760                         md->set_tempo (d->get_length (), m);
 761                 scm_gc_unprotect_object ($2->self_scm ());
 762         }
 763         | music_output_def_body error {
 764
 765         }
 766         ;
 767
 768 tempo_event:
 769         TEMPO steno_duration '=' bare_unsigned  {
 770                 $$ = MY_MAKE_MUSIC ("MetronomeChangeEvent");
 771                 $$->set_property ("tempo-unit", $2);
 772                 $$->set_property ("metronome-count", scm_int2num ( $4));
 773         }
 774         ;
 775
 776 /*
 777 The representation of a  list is the
 778
 779   (LIST . LAST-CONS)
 780
 781  to have  efficient append.
 782 */
 783 Music_list:
 784         /* empty */ {
 785                 $$ = scm_cons (SCM_EOL, SCM_EOL);
 786         }
 787         | Music_list Music {
 788                 SCM s = $$;
 789                 SCM c = scm_cons ($2->self_scm (), SCM_EOL);
 790                 scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
 791                 if (ly_c_pair_p (ly_cdr (s)))
 792                         scm_set_cdr_x (ly_cdr (s), c); /* append */
 793                 else
 794                         scm_set_car_x (s, c); /* set first cons */
 795                 scm_set_cdr_x (s, c);  /* remember last cell */
 796         }
 797         | Music_list embedded_scm {
 798         }
 799         | Music_list error {
 800         }
 801         ;
 802
 803
 804 Music:
 805         Simple_music
 806         | Composite_music
 807         ;
 808
 809 Alternative_music:
 810         /* empty */ {
 811                 $$ = SCM_EOL;
 812         }
 813         | ALTERNATIVE '{' Music_list '}' {
 814                 $$ = $3;
 815         }
 816         ;
 817
 818
 819 Repeated_music:
 820         REPEAT simple_string bare_unsigned Music Alternative_music
 821         {
 822                 Music *beg = $4;
 823                 int times = $3;
 824                 SCM alts = ly_c_pair_p ($5) ? ly_car ($5) : SCM_EOL;
 825                 if (times < scm_ilength (alts)) {
 826                   unsmob_music (ly_car (alts))
 827                     ->origin ()->warning (
 828                     _ ("More alternatives than repeats.  Junking excess alternatives."));
 829                   alts = ly_truncate_list (times, alts);
 830                 }
 831
 832
 833                 SCM proc = ly_scheme_function ("make-repeated-music");
 834
 835                 SCM mus = scm_call_1 (proc, $2);
 836                 scm_gc_protect_object (mus); // UGH.
 837                 Music *r = unsmob_music (mus);
 838                 if (beg)
 839                         {
 840                         r-> set_property ("element", beg->self_scm ());
 841                         scm_gc_unprotect_object (beg->self_scm ());
 842                         }
 843                 r->set_property ("repeat-count", scm_int2num (times >? 1));
 844
 845                 r-> set_property ("elements",alts);
 846                 if (ly_c_equal_p ($2, scm_makfrom0str ("tremolo"))) {
 847                         /*
 848                         TODO: move this code to Scheme.
 849                         */
 850
 851                         /*
 852                         we can not get durations and other stuff correct down the line, so we have to
 853                         add to the duration log here.
 854                         */
 855                         SCM func = ly_scheme_function ("shift-duration-log");
 856
 857                         int dots = ($3 % 3) ? 0 : 1;
 858                         int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
 859
 860                         Sequential_music *seq = dynamic_cast<Sequential_music*> ($4);
 861
 862                         if (seq) {
 863                                 int list_len = scm_ilength (seq->music_list ());
 864                                 if (list_len != 2)
 865                                         seq->origin ()->warning ("Chord tremolo must have 2 elements.");
 866                                 shift -= 1;
 867                                 r->compress (Moment (Rational (1, list_len)));
 868                                 }
 869                         scm_call_3 (func, r->self_scm (), scm_int2num (shift),scm_int2num (dots));
 870
 871                 }
 872                 r->set_spot (*$4->origin ());
 873
 874                 $$ = r;
 875         }
 876         ;
 877
 878 Sequential_music:
 879         SEQUENTIAL '{' Music_list '}'           {
 880                 $$ = MY_MAKE_MUSIC ("SequentialMusic");
 881                 $$->set_property ("elements", ly_car ($3));
 882                 $$->set_spot (THIS->here_input ());
 883         }
 884         | '{' Music_list '}'            {
 885                 $$ = MY_MAKE_MUSIC ("SequentialMusic");
 886                 $$->set_property ("elements", ly_car ($2));
 887                 $$->set_spot (THIS->here_input ());
 888         }
 889         ;
 890
 891 Simultaneous_music:
 892         SIMULTANEOUS '{' Music_list '}'{
 893                 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
 894                 $$->set_property ("elements", ly_car ($3));
 895                 $$->set_spot (THIS->here_input ());
 896
 897         }
 898         | simul_open Music_list simul_close     {
 899                 $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
 900                 $$->set_property ("elements", ly_car ($2));
 901                 $$->set_spot (THIS->here_input ());
 902         }
 903         ;
 904
 905 Simple_music:
 906         event_chord             { $$ = $1; }
 907         | MUSIC_IDENTIFIER {
 908                 $$ = unsmob_music ($1);
 909         }
 910         | music_property_def
 911         | context_change
 912         ;
 913
 914
 915 optional_context_mod:
 916         /**/ { $$ = SCM_EOL; }
 917         | WITH { THIS->lexer_->push_initial_state (); }
 918         '{' context_mod_list '}'
 919         {
 920                 THIS->lexer_->pop_state ();
 921                 $$ = $4;
 922         }
 923         ;
 924
 925 context_mod_list:
 926         /* */  { $$ = SCM_EOL; }
 927         | context_mod_list context_mod  {
 928                  $$ = scm_cons ($2, $1);
 929         }
 930         ;
 931
 932
 933 Composite_music:
 934         Prefix_composite_music { $$ = $1; }
 935         | Grouped_music_list { $$ = $1; }
 936         ;
 937
 938 Grouped_music_list:
 939         Simultaneous_music              { $$ = $1; }
 940         | Sequential_music              { $$ = $1; }
 941         ;
 942
 943 Generic_prefix_music_scm:
 944         MUSIC_FUNCTION {
 945                 $$ = scm_list_2 ($1, make_input (THIS->here_input ()));
 946         }
 947         | MUSIC_FUNCTION_SCM {
 948                 THIS->push_spot ();
 949         } embedded_scm {
 950                 $$ = scm_list_3 ($1, make_input (THIS->pop_spot ()), $3);
 951         }
 952         | MUSIC_FUNCTION_MUSIC {
 953                 THIS->push_spot ();
 954         } Music {
 955                 $$ = scm_list_3 ($1, make_input (THIS->pop_spot ()), $3->self_scm ());
 956                 scm_gc_unprotect_object ($3->self_scm ());
 957         }
 958         | MUSIC_FUNCTION_SCM_MUSIC {
 959                 THIS->push_spot ();
 960         }  embedded_scm Music {
 961                 $$ = scm_list_4 ($1, make_input (THIS->pop_spot ()), $3, $4->self_scm ());
 962                 scm_gc_unprotect_object ($4->self_scm ());
 963         }
 964         | MUSIC_FUNCTION_MUSIC_MUSIC {
 965                 THIS->push_spot ();
 966         }  Music  Music {
 967                 $$ = scm_list_4 ($1, make_input (THIS->pop_spot ()), $3->self_scm (), $4->self_scm ());
 968                 scm_gc_unprotect_object ($3->self_scm ());
 969                 scm_gc_unprotect_object ($4->self_scm ());
 970         }
 971         | MUSIC_FUNCTION_SCM_MUSIC_MUSIC {
 972                 THIS->push_spot ();
 973         } embedded_scm Music Music {
 974                 $$ = scm_list_5 ($1, make_input (THIS->pop_spot ()),
 975                         $3, $4->self_scm (), $5->self_scm ());
 976                 scm_gc_unprotect_object ($5->self_scm ());
 977                 scm_gc_unprotect_object ($4->self_scm ());
 978         }
 979         ;
 980
 981 Generic_prefix_music:
 982         Generic_prefix_music_scm {
 983                 SCM func = ly_car ($1);
 984                 Input *loc = unsmob_input (ly_cadr ($1));
 985                 SCM args = ly_cddr ($1);
 986                 SCM sig = scm_object_property (func, ly_symbol2scm ("music-function-signature"));
 987                 int k = 0;
 988                 bool ok  = true;
 989                 for (SCM s = sig, t = args;
 990                         ok && ly_c_pair_p (s) && ly_c_pair_p (t);
 991                         s = ly_cdr (s), t = ly_cdr (t)) {
 992                         k++;
 993                         if (scm_call_1 (ly_car (s), ly_car (t)) != SCM_BOOL_T)
 994                         {
 995                                 loc->error (_f ("Argument %d failed typecheck", k));
 996                                 THIS->error_level_ = 1;
 997                                 ok = false;
 998                         }
 999                 }
1000                 SCM m = SCM_EOL;
1001                 if (ok)
1002                         m = scm_apply_0 (func, ly_cdr ($1));
1003                 if (unsmob_music (m))
1004                         {
1005                         $$ = unsmob_music (m);
1006                         scm_gc_protect_object (m);
1007                         }
1008                 else
1009                         {
1010                         if (ok)
1011                                 loc->error (_ ("Music head function should return Music object."));
1012                         $$ = MY_MAKE_MUSIC ("Music");
1013                         }
1014                 $$->set_spot (*loc);
1015         }
1016         ;
1017
1018
1019 Prefix_composite_music:
1020         Generic_prefix_music {
1021                 $$ = $1;
1022         }
1023         | CONTEXT simple_string '=' simple_string optional_context_mod Music {
1024                 $$ = context_spec_music ($2, $4, $6, $5);
1025
1026         }
1027         | CONTEXT simple_string optional_context_mod Music {
1028                 $$ = context_spec_music ($2, SCM_UNDEFINED, $4, $3);
1029         }
1030         | NEWCONTEXT simple_string optional_context_mod Music {
1031                 $$ = context_spec_music ($2, get_next_unique_context (), $4,
1032                         $3);
1033         }
1034
1035         | TIMES {
1036                 THIS->push_spot ();
1037         }
1038         /* CONTINUED */
1039                 fraction Music
1040
1041         {
1042                 int n = ly_scm2int (ly_car ($3)); int d = ly_scm2int (ly_cdr ($3));
1043                 Music *mp = $4;
1044
1045                 $$= MY_MAKE_MUSIC ("TimeScaledMusic");
1046                 $$->set_spot (THIS->pop_spot ());
1047
1048                 $$->set_property ("element", mp->self_scm ());
1049                 scm_gc_unprotect_object (mp->self_scm ());
1050                 $$->set_property ("numerator", scm_int2num (n));
1051                 $$->set_property ("denominator", scm_int2num (d));
1052                 $$->compress (Moment (Rational (n,d)));
1053
1054         }
1055         | Repeated_music                { $$ = $1; }
1056         | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
1057                 $$ = MY_MAKE_MUSIC ("TransposedMusic");
1058                 Music *p = $4;
1059                 Pitch from = *unsmob_pitch ($2);
1060                 Pitch to = *unsmob_pitch ($3);
1061
1062                 p->transpose (interval (from, to));
1063                 $$->set_property ("element", p->self_scm ());
1064                 scm_gc_unprotect_object (p->self_scm ());
1065         }
1066         | NOTES
1067                 {
1068                 SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
1069                 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1070         }
1071         Music
1072                 { $$ = $3;
1073                   THIS->lexer_->pop_state ();
1074                 }
1075         | DRUMS
1076                 {
1077                 SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
1078                 THIS->lexer_->push_note_state (alist_to_hashq (nn));
1079         }
1080         /* FIXME: This used to be: */
1081         Music
1082 /*      Grouped_music_list */
1083                 { $$ = $3;
1084                   THIS->lexer_->pop_state ();
1085                 }
1086         | FIGURES
1087                 { THIS->lexer_->push_figuredbass_state (); }
1088         /* FIXME: This used to be:
1089         Music
1090         but that breaks web build
1091         */
1092         Grouped_music_list
1093                 {
1094                   Music *chm = MY_MAKE_MUSIC ("UntransposableMusic");
1095                   chm->set_property ("element", $3->self_scm ());
1096                   $$ = chm;
1097                   scm_gc_unprotect_object ($3->self_scm ());
1098
1099                   THIS->lexer_->pop_state ();
1100         }
1101         | CHORDS {
1102                 SCM nn = THIS->lexer_->lookup_identifier ("chordmodifiers");
1103                 THIS->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
1104                 nn = THIS->lexer_->lookup_identifier ("pitchnames");
1105                 THIS->lexer_->push_chord_state (alist_to_hashq (nn));
1106
1107         }
1108         /* FIXME:
1109         Music
1110 */
1111         Grouped_music_list
1112         {
1113                   Music *chm = MY_MAKE_MUSIC ("UnrelativableMusic");
1114                   chm->set_property ("element", $3->self_scm ());
1115                   scm_gc_unprotect_object ($3->self_scm ());
1116                   $$ = chm;
1117
1118                   THIS->lexer_->pop_state ();
1119         }
1120         | LYRICS
1121                 { THIS->lexer_->push_lyric_state (); }
1122         /* FIXME:
1123         Music
1124 */
1125         Grouped_music_list
1126                 {
1127                   $$ = $3;
1128                   THIS->lexer_->pop_state ();
1129         }
1130         | relative_music        { $$ = $1; }
1131         | re_rhythmed_music     { $$ = $1; }
1132         | TAG embedded_scm Music {
1133                 tag_music ($3, $2, THIS->here_input ());
1134                 $$ = $3;
1135         }
1136         ;
1137
1138 relative_music:
1139         RELATIVE absolute_pitch Music {
1140                 Music *m = $3;
1141                 Pitch start = *unsmob_pitch ($2);
1142                 $$ = make_music_relative (start, m);
1143                 scm_gc_unprotect_object (m->self_scm ());
1144         }
1145         | RELATIVE Composite_music {
1146                 Music *m = $2;
1147                 /* FIXME: why is octave==0 and default not middleC? */
1148                 Pitch middle_c (-1, 0, 0);
1149                 $$ = make_music_relative (middle_c, m);
1150                 scm_gc_unprotect_object (m->self_scm ());
1151         }
1152         ;
1153
1154 new_lyrics:
1155         NEWLYRICS { THIS->lexer_->push_lyric_state (); }
1156         /*cont */
1157         Grouped_music_list {
1158         /* Can also use Music at the expensive of two S/Rs similar to
1159            \repeat \alternative */
1160                 THIS->lexer_->pop_state ();
1161 #if 0
1162                 Music *music = MY_MAKE_MUSIC ("SimultaneousMusic");
1163                 music->set_property ("elements", scm_list_1 ($3->self_scm ()));
1164                 $$ = music;
1165 #else
1166                 $$ = scm_cons ($3->self_scm (), SCM_EOL);
1167 #endif
1168         }
1169         | new_lyrics NEWLYRICS { THIS->lexer_->push_lyric_state (); }
1170         Grouped_music_list {
1171                 THIS->lexer_->pop_state ();
1172                 $$ = scm_cons ($4->self_scm (), $1);
1173         }
1174         ;
1175
1176 re_rhythmed_music:
1177         Grouped_music_list new_lyrics {
1178
1179                 /* FIXME: should find out uniqueXXX name from music */
1180                 SCM name = $1->get_property ("context-id");
1181                 //if (name == SCM_EOL)
1182                 if (!ly_c_string_p (name))
1183                         name = scm_makfrom0str ("");
1184
1185                 SCM context = scm_makfrom0str ("Lyrics");
1186                 Music *all = MY_MAKE_MUSIC ("SimultaneousMusic");
1187
1188                 SCM lst = SCM_EOL;
1189                 for (SCM s = $2; ly_c_pair_p (s); s = ly_cdr (s))
1190                 {
1191                         Music *music = unsmob_music (ly_car (s));
1192                         Music *com = make_lyric_combine_music (name, music);
1193                         Music *csm = context_spec_music (context,
1194                                 get_next_unique_context (), com, SCM_EOL);
1195                         lst = scm_cons (csm->self_scm (), lst);
1196                 }
1197                 /* FIXME: only first lyric music is accepted,
1198                           the rest is junked */
1199                 all->set_property ("elements", scm_cons ($1->self_scm (),
1200                         lst));
1201                 $$ = all;
1202                 scm_gc_unprotect_object ($1->self_scm ());
1203         }
1204         | LYRICSTO string Music {
1205                 Music *music = $3;
1206                 SCM name = $2;
1207                 $$ = make_lyric_combine_music (name, music);
1208                 scm_gc_unprotect_object (music->self_scm ());
1209         }
1210         ;
1211
1212 context_change:
1213         CHANGE STRING '=' STRING  {
1214                 Music*t= MY_MAKE_MUSIC ("ContextChange");
1215                 t-> set_property ("change-to-type", scm_string_to_symbol ($2));
1216                 t-> set_property ("change-to-id", $4);
1217
1218                 $$ = t;
1219                 $$->set_spot (THIS->here_input ());
1220         }
1221         ;
1222
1223 property_operation:
1224         STRING '=' scalar {
1225                 $$ = scm_list_3 (ly_symbol2scm ("assign"),
1226                         scm_string_to_symbol ($1), $3);
1227         }
1228         | UNSET simple_string {
1229                 $$ = scm_list_2 (ly_symbol2scm ("unset"),
1230                         scm_string_to_symbol ($2));
1231         }
1232         | OVERRIDE simple_string embedded_scm '=' embedded_scm {
1233                 $$ = scm_list_4 (ly_symbol2scm ("push"),
1234                         scm_string_to_symbol ($2), $3, $5);
1235         }
1236         | REVERT simple_string embedded_scm {
1237                 $$ = scm_list_3 (ly_symbol2scm ("pop"),
1238                         scm_string_to_symbol ($2), $3);
1239         }
1240         ;
1241
1242 context_def_mod:
1243         CONSISTSEND { $$ = ly_symbol2scm ("consists-end"); }
1244         | CONSISTS { $$ = ly_symbol2scm ("consists"); }
1245         | REMOVE { $$ = ly_symbol2scm ("remove"); }
1246
1247         | ACCEPTS { $$ = ly_symbol2scm ("accepts"); }
1248         | DENIES { $$ = ly_symbol2scm ("denies"); }
1249
1250         | ALIAS { $$ = ly_symbol2scm ("alias"); }
1251         | TYPE { $$ = ly_symbol2scm ("translator-type"); }
1252         | DESCRIPTION { $$ = ly_symbol2scm ("description"); }
1253         | NAME { $$ = ly_symbol2scm ("context-name"); }
1254         ;
1255
1256 context_mod:
1257         property_operation { $$ = $1; }
1258         | context_def_mod STRING {
1259                 $$ = scm_list_2 ($1, $2);
1260         }
1261         ;
1262
1263 context_prop_spec:
1264         simple_string {
1265                 $$ = scm_list_2 (ly_symbol2scm ("Bottom"),
1266                         scm_string_to_symbol ($1));
1267         }
1268         | simple_string '.' simple_string {
1269                 $$ = scm_list_2 (scm_string_to_symbol ($1),
1270                         scm_string_to_symbol ($3));
1271         }
1272         ;
1273
1274 music_property_def:
1275         OVERRIDE context_prop_spec embedded_scm '=' scalar {
1276                 $$ = property_op_to_music (scm_list_4 (
1277                         ly_symbol2scm ("poppush"),
1278                         ly_cadr ($2),
1279                         $3, $5));
1280                 $$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1281         }
1282         | REVERT context_prop_spec embedded_scm {
1283                 $$ = property_op_to_music (scm_list_3 (
1284                         ly_symbol2scm ("pop"),
1285                         ly_cadr ($2),
1286                         $3));
1287
1288                 $$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1289         }
1290         | SET context_prop_spec '=' scalar {
1291                 $$ = property_op_to_music (scm_list_3 (
1292                         ly_symbol2scm ("assign"),
1293                         ly_cadr ($2),
1294                         $4));
1295                 $$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1296         }
1297         | UNSET context_prop_spec {
1298                 $$ = property_op_to_music (scm_list_2 (
1299                         ly_symbol2scm ("unset"),
1300                         ly_cadr ($2)));
1301                 $$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
1302         }
1303         | ONCE music_property_def {
1304                 SCM e = $2->get_property ("element");
1305                 unsmob_music (e)->set_property ("once", SCM_BOOL_T);
1306                 $$ = $2;
1307
1308         }
1309         ;
1310
1311
1312 string:
1313         STRING {
1314                 $$ = $1;
1315         }
1316         | STRING_IDENTIFIER {
1317                 $$ = $1;
1318         }
1319         | string '+' string {
1320                 $$ = scm_string_append (scm_list_2 ($1, $3));
1321         }
1322         ;
1323
1324 simple_string: STRING {
1325         }
1326         | LYRICS_STRING {
1327         }
1328         ;
1329
1330 scalar: string {
1331         }
1332         | LYRICS_STRING {
1333         }
1334         | bare_int {
1335                 $$ = scm_int2num ($1);
1336         }
1337         | embedded_scm {
1338         }
1339         | full_markup {
1340         }
1341         | DIGIT {
1342                 $$ = scm_int2num ($1);
1343         }
1344         ;
1345
1346 /*
1347 FIXME: remove or fix this comment.  What is `This'?
1348
1349 This is a trick:
1350
1351 Adding pre_events to the simple_element
1352 makes the choice between
1353
1354   string:  STRING
1355
1356 and
1357
1358   simple_element: STRING
1359
1360 a single shift/reduction conflict.
1361
1362 nevertheless, this is not very clean, and we should find a different
1363 solution.
1364
1365 */
1366 pre_events: {
1367                 THIS->push_spot ();
1368         }
1369         ;
1370
1371 event_chord:
1372         pre_events simple_element post_events   {
1373                 SCM elts = $2-> get_property ("elements");
1374
1375                 elts = ly_append2 (elts, scm_reverse_x ($3, SCM_EOL));
1376
1377                 $2->set_property ("elements", elts);
1378                 $$ = $2;
1379         }
1380         | command_element
1381         | note_chord_element
1382         ;
1383
1384
1385 note_chord_element:
1386         chord_body optional_notemode_duration post_events
1387         {
1388                 SCM dur = unsmob_duration ($2)->smobbed_copy ();
1389                 SCM es = $1->get_property ("elements");
1390                 SCM postevs = scm_reverse_x ($3, SCM_EOL);
1391
1392                 for (SCM s = es; ly_c_pair_p (s); s = ly_cdr (s))
1393                   unsmob_music (ly_car (s))->set_property ("duration", dur);
1394                 es = ly_append2 (es, postevs);
1395
1396                 $1-> set_property ("elements", es);
1397                 $$ = $1;
1398         }
1399         ;
1400
1401 chord_open: '<'
1402         ;
1403
1404 chord_close: '>'
1405         ;
1406
1407 simul_open: DOUBLE_ANGLE_OPEN
1408         ;
1409
1410 simul_close: DOUBLE_ANGLE_CLOSE
1411         ;
1412
1413 chord_body:
1414         chord_open chord_body_elements chord_close
1415         {
1416                 $$ = MY_MAKE_MUSIC ("EventChord");
1417                 $$->set_property ("elements",
1418                         scm_reverse_x ($2, SCM_EOL));
1419         }
1420         ;
1421
1422 chord_body_elements:
1423         /* empty */             { $$ = SCM_EOL; }
1424         | chord_body_elements chord_body_element {
1425                 $$ = scm_cons ($2->self_scm (), $1);
1426                 scm_gc_unprotect_object ($2->self_scm ());
1427         }
1428         ;
1429
1430 chord_body_element:
1431         pitch exclamations questions post_events
1432         {
1433                 Music *n = MY_MAKE_MUSIC ("NoteEvent");
1434                 n->set_property ("pitch", $1);
1435                 if ($3 % 2)
1436                         n->set_property ("cautionary", SCM_BOOL_T);
1437                 if ($2 % 2 || $3 % 2)
1438                         n->set_property ("force-accidental", SCM_BOOL_T);
1439
1440                 if (ly_c_pair_p ($4)) {
1441                         SCM arts = scm_reverse_x ($4, SCM_EOL);
1442                         n->set_property ("articulations", arts);
1443                 }
1444                 $$ = n;
1445         }
1446         | DRUM_PITCH post_events {
1447                 Music *n = MY_MAKE_MUSIC ("NoteEvent");
1448                 n->set_property ("duration", $2);
1449                 n->set_property ("drum-type", $1);
1450                 n->set_spot (THIS->here_input ());
1451
1452                 if (ly_c_pair_p ($2)) {
1453                         SCM arts = scm_reverse_x ($2, SCM_EOL);
1454                         n->set_property ("articulations", arts);
1455                 }
1456                 $$ = n;
1457         }
1458         ;
1459
1460 add_quote:
1461         ADDQUOTE string Music {
1462                 SCM adder = ly_scheme_function ("add-quotable");
1463
1464                 scm_call_2 (adder, $2, $3->self_scm ());
1465                 scm_gc_unprotect_object ($3->self_scm ());
1466         }
1467         ;
1468
1469 command_element:
1470         command_req {
1471                 $$ = MY_MAKE_MUSIC ("EventChord");
1472                 $$->set_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
1473                 scm_gc_unprotect_object ($1->self_scm ());
1474
1475                 $$-> set_spot (THIS->here_input ());
1476                 $1-> set_spot (THIS->here_input ());
1477         }
1478         | SKIP duration_length {
1479                 Music *skip = MY_MAKE_MUSIC ("SkipMusic");
1480                 skip->set_property ("duration", $2);
1481
1482                 $$ = skip;
1483         }
1484         | QUOTE STRING duration_length {
1485                 SCM tab = THIS->lexer_->lookup_identifier ("musicQuotes");
1486                 SCM evs = SCM_EOL;
1487                 if (scm_hash_table_p (tab) == SCM_BOOL_T)
1488                 {
1489                         SCM key = $2; // use symbol?
1490                         evs = scm_hash_ref (tab, key, SCM_BOOL_F);
1491                 }
1492                 Music *quote = 0;
1493                 if (ly_c_vector_p (evs))
1494                 {
1495                         quote = MY_MAKE_MUSIC ("QuoteMusic");
1496                         quote->set_property ("duration", $3);
1497                         quote->set_property ("quoted-events", evs);
1498                 } else {
1499                         THIS->here_input ().warning (_f ("Can\'t find music"));
1500                         quote = MY_MAKE_MUSIC ("Event");
1501                 }
1502                 quote->set_spot (THIS->here_input ());
1503                 $$ = quote;
1504         }
1505         | OCTAVE { THIS->push_spot (); }
1506           pitch {
1507                 Music *m = MY_MAKE_MUSIC ("RelativeOctaveCheck");
1508                 $$ = m;
1509                 $$->set_spot (THIS->pop_spot ());
1510                 $$->set_property ("pitch", $3);
1511         }
1512         | E_LEFTSQUARE {
1513                 Music *m = MY_MAKE_MUSIC ("LigatureEvent");
1514                 m->set_property ("span-direction", scm_int2num (START));
1515                 m->set_spot (THIS->here_input ());
1516
1517                 $$ = MY_MAKE_MUSIC ("EventChord");
1518                 $$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
1519                 scm_gc_unprotect_object (m->self_scm ());
1520                 $$->set_spot (THIS->here_input ());
1521         }
1522         | E_RIGHTSQUARE {
1523                 Music *m = MY_MAKE_MUSIC ("LigatureEvent");
1524                 m->set_property ("span-direction", scm_int2num (STOP));
1525                 m->set_spot (THIS->here_input ());
1526
1527                 $$ = MY_MAKE_MUSIC ("EventChord");
1528                 $$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
1529                 $$->set_spot (THIS->here_input ());
1530                 scm_gc_unprotect_object (m->self_scm ());
1531         }
1532         | E_BACKSLASH {
1533                 $$ = MY_MAKE_MUSIC ("VoiceSeparator");
1534                 $$->set_spot (THIS->here_input ());
1535         }
1536         | '|'      {
1537                 SCM pipe =THIS->lexer_->lookup_identifier ("pipeSymbol");
1538
1539                 if (Music * m = unsmob_music (pipe))
1540                         $$ = m->clone ();
1541                 else
1542                         $$ = MY_MAKE_MUSIC ("BarCheck");
1543
1544                 $$->set_spot (THIS->here_input ());
1545         }
1546         | TRANSPOSITION pitch {
1547                 $$ = set_property_music (ly_symbol2scm ("instrumentTransposition"),
1548                                         $2);
1549                 $$->set_spot (THIS-> here_input ());
1550                 $$ = context_spec_music (ly_symbol2scm ("Staff"), SCM_UNDEFINED,
1551                         $$, SCM_EOL);
1552         }
1553         | BAR STRING                    {
1554                 Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
1555
1556                 Music *csm = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1557                                         t, SCM_EOL);
1558                 $$ = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED, csm, SCM_EOL);
1559                 $$->set_spot (THIS->here_input ());
1560                 t->set_spot (THIS->here_input ());
1561         }
1562         | PARTIAL duration_length       {
1563                 Moment m = - unsmob_duration ($2)->get_length ();
1564                 Music *p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
1565                 p->set_spot (THIS->here_input ());
1566                 p = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
1567                                         p, SCM_EOL);
1568                 p = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED,
1569                                         p, SCM_EOL);
1570                 $$ = p;
1571         }
1572         | CLEF STRING  {
1573                 SCM proc = ly_scheme_function ("make-clef-set");
1574
1575                 SCM result = scm_call_1 (proc, $2);
1576                 scm_gc_protect_object (result);
1577                 $$ = unsmob_music (result);
1578         }
1579         | TIME_T fraction  {
1580                 SCM proc= ly_scheme_function ("make-time-signature-set");
1581
1582                 SCM result = scm_apply_2   (proc, ly_car ($2), ly_cdr ($2), SCM_EOL);
1583                 scm_gc_protect_object (result);
1584                 $$ = unsmob_music (result);
1585         }
1586         | MARK scalar {
1587                 SCM proc = ly_scheme_function ("make-mark-set");
1588
1589                 SCM result = scm_call_1 (proc, $2);
1590                 scm_gc_protect_object (result);
1591                 $$ = unsmob_music (result);
1592         }
1593         ;
1594
1595 command_req:
1596         E_TILDE {
1597                 $$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
1598         }
1599         | MARK DEFAULT  {
1600                 Music *m = MY_MAKE_MUSIC ("MarkEvent");
1601                 $$ = m;
1602         }
1603         | tempo_event {
1604                 $$ = $1;
1605         }
1606         | KEY DEFAULT {
1607                 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1608                 $$ = key;
1609         }
1610         | KEY NOTENAME_PITCH SCM_IDENTIFIER     {
1611
1612                 Music *key= MY_MAKE_MUSIC ("KeyChangeEvent");
1613                 if (scm_ilength ($3) > 0)
1614                 {
1615                         key->set_property ("pitch-alist", $3);
1616                         key->set_property ("tonic", Pitch (0,0,0).smobbed_copy ());
1617                         ((Music*)key)->transpose (* unsmob_pitch ($2));
1618                 } else {
1619                         THIS->parser_error (_ ("Second argument must be pitch list."));
1620                 }
1621
1622                 $$ = key;
1623         }
1624         ;
1625
1626 post_events:
1627         /* empty */ {
1628                 $$ = SCM_EOL;
1629         }
1630         | post_events post_event {
1631                 $2->set_spot (THIS->here_input ());
1632                 $$ = scm_cons ($2->self_scm (), $$);
1633                 scm_gc_unprotect_object ($2->self_scm ());
1634         }
1635         | post_events tagged_post_event {
1636                 $2 -> set_spot (THIS->here_input ());
1637                 $$ = scm_cons ($2->self_scm (), $$);
1638                 scm_gc_unprotect_object ($2->self_scm ());
1639         }
1640         ;
1641
1642
1643 tagged_post_event:
1644         '-' TAG embedded_scm post_event {
1645                 tag_music ($4, $3, THIS->here_input ());
1646                 $$ = $4;
1647         }
1648         ;
1649
1650 post_event:
1651         direction_less_event {
1652                 $$ = $1;
1653         }
1654         | HYPHEN {
1655                 if (!THIS->lexer_->is_lyric_state ())
1656                         THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1657                 $$ = MY_MAKE_MUSIC ("HyphenEvent");
1658         }
1659         | EXTENDER {
1660                 if (!THIS->lexer_->is_lyric_state ())
1661                         THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
1662                 $$ = MY_MAKE_MUSIC ("ExtenderEvent");
1663         }
1664         | script_dir direction_reqd_event {
1665                 if ($1)
1666                         $2->set_property ("direction", scm_int2num ($1));
1667                 $$ = $2;
1668         }
1669         | script_dir direction_less_event {
1670                 if ($1)
1671                         $2->set_property ("direction", scm_int2num ($1));
1672                 $$ = $2;
1673         }
1674         | string_number_event
1675         ;
1676
1677 string_number_event:
1678         E_UNSIGNED {
1679                 Music *s = MY_MAKE_MUSIC ("StringNumberEvent");
1680                 s->set_property ("string-number", scm_int2num ($1));
1681                 s->set_spot (THIS->here_input ());
1682                 $$ = s;
1683         }
1684         ;
1685
1686
1687 direction_less_event:
1688         '['  {
1689
1690
1691 /*
1692
1693 TODO: should take all these defs out of the parser, adn make use
1694 configurable, i.e.
1695
1696
1697 (set-articulation '~ "trill")
1698
1699 */
1700                 Music *m = MY_MAKE_MUSIC ("BeamEvent");
1701                 m->set_spot (THIS->here_input ());
1702                 m->set_property ("span-direction", scm_int2num (START));
1703                 $$ = m;
1704         }
1705         | ']'  {
1706                 Music *m = MY_MAKE_MUSIC ("BeamEvent");
1707                 m->set_spot (THIS->here_input ());
1708                 m->set_property ("span-direction", scm_int2num (STOP));
1709                 $$ = m;
1710         }
1711         | '~' {
1712                 Music *m = MY_MAKE_MUSIC ("TieEvent");
1713                 m->set_spot (THIS->here_input ());
1714                 $$ = m;
1715         }
1716         | close_event {
1717                 $$ = $1;
1718                 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1719                         scm_int2num (START));
1720         }
1721         | open_event {
1722                 $$ = $1;
1723                 dynamic_cast<Music *> ($$)->set_property ("span-direction",
1724                         scm_int2num (STOP));
1725         }
1726         | EVENT_IDENTIFIER      {
1727                 $$ = unsmob_music ($1);
1728         }
1729         | tremolo_type  {
1730                Music *a = MY_MAKE_MUSIC ("TremoloEvent");
1731                a->set_spot (THIS->here_input ());
1732                a->set_property ("tremolo-type", scm_int2num ($1));
1733                $$ = a;
1734         }
1735         ;
1736
1737 direction_reqd_event:
1738         gen_text_def {
1739                 $$ = $1;
1740         }
1741         | script_abbreviation {
1742                 SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
1743                 Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
1744                 if (ly_c_string_p (s))
1745                         a->set_property ("articulation-type", s);
1746                 else THIS->parser_error (_ ("Expecting string as script definition"));
1747                 $$ = a;
1748         }
1749         ;
1750
1751 oct_check:
1752         /**/ { $$ = SCM_EOL; }
1753         | '='  { $$ = scm_int2num (0); }
1754         | '=' sub_quotes { $$ = scm_int2num ($2); }
1755         | '=' sup_quotes { $$ = scm_int2num ($2); }
1756         ;
1757
1758 sup_quotes:
1759         '\'' {
1760                 $$ = 1;
1761         }
1762         | sup_quotes '\'' {
1763                 $$ ++;
1764         }
1765         ;
1766
1767 sub_quotes:
1768         ',' {
1769                 $$ = 1;
1770         }
1771         | sub_quotes ',' {
1772                 $$++;
1773         }
1774         ;
1775
1776 steno_pitch:
1777         NOTENAME_PITCH  {
1778                 $$ = $1;
1779         }
1780         | NOTENAME_PITCH sup_quotes     {
1781                 Pitch p = *unsmob_pitch ($1);
1782                 p = p.transposed (Pitch ($2,0,0));
1783                 $$ = p.smobbed_copy ();
1784         }
1785         | NOTENAME_PITCH sub_quotes      {
1786                 Pitch p =* unsmob_pitch ($1);
1787                 p = p.transposed (Pitch (-$2,0,0));
1788                 $$ = p.smobbed_copy ();
1789         }
1790         ;
1791
1792 /*
1793 ugh. duplication
1794 */
1795
1796 steno_tonic_pitch:
1797         TONICNAME_PITCH {
1798                 $$ = $1;
1799         }
1800         | TONICNAME_PITCH sup_quotes    {
1801                 Pitch p = *unsmob_pitch ($1);
1802                 p = p.transposed (Pitch ($2,0,0));
1803                 $$ = p.smobbed_copy ();
1804         }
1805         | TONICNAME_PITCH sub_quotes     {
1806                 Pitch p =* unsmob_pitch ($1);
1807
1808                 p = p.transposed (Pitch (-$2,0,0));
1809                 $$ = p.smobbed_copy ();
1810         }
1811         ;
1812
1813 pitch:
1814         steno_pitch {
1815                 $$ = $1;
1816         }
1817         ;
1818
1819 pitch_also_in_chords:
1820         pitch
1821         | steno_tonic_pitch
1822         ;
1823
1824 close_event:
1825         '('     {
1826                 Music *s = MY_MAKE_MUSIC ("SlurEvent");
1827                 $$ = s;
1828                 s->set_spot (THIS->here_input ());
1829         }
1830         | E_OPEN        {
1831                 Music *s = MY_MAKE_MUSIC ("PhrasingSlurEvent");
1832                 $$ = s;
1833                 s->set_spot (THIS->here_input ());
1834         }
1835         | E_SMALLER {
1836                 Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
1837                 $$ = s;
1838                 s->set_spot (THIS->here_input ());
1839         }
1840         | E_BIGGER {
1841                 Music *s = MY_MAKE_MUSIC ("DecrescendoEvent");
1842                 $$ = s;
1843                 s->set_spot (THIS->here_input ());
1844         }
1845         ;
1846
1847
1848 open_event:
1849         E_EXCLAMATION   {
1850                 Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
1851                 s->set_spot (THIS->here_input ());
1852
1853                 $$ = s;
1854         }
1855         | ')'   {
1856                 Music *s= MY_MAKE_MUSIC ("SlurEvent");
1857                 $$ = s;
1858                 s->set_spot (THIS->here_input ());
1859
1860         }
1861         | E_CLOSE       {
1862                 Music *s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
1863                 $$ = s;
1864                 s->set_property ("span-type",
1865                         scm_makfrom0str ("phrasing-slur"));
1866                 s->set_spot (THIS->here_input ());
1867         }
1868         ;
1869
1870 gen_text_def:
1871         full_markup {
1872                 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1873                 t->set_property ("text", $1);
1874                 t->set_spot (THIS->here_input ());
1875                 $$ = t;
1876         }
1877         | string {
1878                 Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
1879                 t->set_property ("text",
1880                         make_simple_markup (THIS->lexer_->encoding (), $1));
1881                 t->set_spot (THIS->here_input ());
1882                 $$ = t;
1883
1884         }
1885         | DIGIT {
1886                 Music *t = MY_MAKE_MUSIC ("FingerEvent");
1887                 t->set_property ("digit", scm_int2num ($1));
1888                 t->set_spot (THIS->here_input ());
1889                 $$ = t;
1890         }
1891         ;
1892
1893 script_abbreviation:
1894         '^'             {
1895                 $$ = scm_makfrom0str ("Hat");
1896         }
1897         | '+'           {
1898                 $$ = scm_makfrom0str ("Plus");
1899         }
1900         | '-'           {
1901                 $$ = scm_makfrom0str ("Dash");
1902         }
1903         | '|'           {
1904                 $$ = scm_makfrom0str ("Bar");
1905         }
1906         | '>'           {
1907                 $$ = scm_makfrom0str ("Larger");
1908         }
1909         | '.'           {
1910                 $$ = scm_makfrom0str ("Dot");
1911         }
1912         | '_' {
1913                 $$ = scm_makfrom0str ("Underscore");
1914         }
1915         ;
1916
1917 script_dir:
1918         '_'     { $$ = DOWN; }
1919         | '^'   { $$ = UP; }
1920         | '-'   { $$ = CENTER; }
1921         ;
1922
1923
1924 absolute_pitch:
1925         steno_pitch     {
1926                 $$ = $1;
1927         }
1928         ;
1929
1930 duration_length:
1931         multiplied_duration {
1932                 $$ = $1;
1933         }
1934         ;
1935
1936 optional_notemode_duration:
1937         {
1938                 Duration dd = THIS->default_duration_;
1939                 $$ = dd.smobbed_copy ();
1940
1941                 THIS->beam_check ($$);
1942         }
1943         | multiplied_duration   {
1944                 $$ = $1;
1945                 THIS->default_duration_ = *unsmob_duration ($$);
1946
1947                 THIS->beam_check ($$);
1948         }
1949         ;
1950
1951 steno_duration:
1952         bare_unsigned dots              {
1953                 int len = 0;
1954                 if (!is_duration ($1))
1955                         THIS->parser_error (_f ("not a duration: %d", $1));
1956                 else
1957                         len = intlog2 ($1);
1958
1959                 $$ = Duration (len, $2).smobbed_copy ();
1960         }
1961         | DURATION_IDENTIFIER dots      {
1962                 Duration *d = unsmob_duration ($1);
1963                 Duration k (d->duration_log (), d->dot_count () + $2);
1964                 *d = k;
1965                 $$ = $1;
1966         }
1967         ;
1968
1969 multiplied_duration:
1970         steno_duration {
1971                 $$ = $1;
1972         }
1973         | multiplied_duration '*' bare_unsigned {
1974                 $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
1975         }
1976         | multiplied_duration '*' FRACTION {
1977                 Rational  m (ly_scm2int (ly_car ($3)), ly_scm2int (ly_cdr ($3)));
1978
1979                 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
1980         }
1981         ;
1982
1983 fraction:
1984         FRACTION { $$ = $1; }
1985         | UNSIGNED '/' UNSIGNED {
1986                 $$ = scm_cons (scm_int2num ($1), scm_int2num ($3));
1987         }
1988         ;
1989
1990 dots:
1991         /* empty */     {
1992                 $$ = 0;
1993         }
1994         | dots '.' {
1995                 $$ ++;
1996         }
1997         ;
1998
1999 tremolo_type:
2000         ':'     {
2001                 $$ = 0;
2002         }
2003         | ':' bare_unsigned {
2004                 if (!is_duration ($2))
2005                         THIS->parser_error (_f ("not a duration: %d", $2));
2006                 $$ = $2;
2007         }
2008         ;
2009
2010 bass_number:
2011         DIGIT   {
2012                 $$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
2013                 $$ = scm_list_2 (ly_scheme_function ("number-markup"),
2014                                 $$);
2015         }
2016         | UNSIGNED {
2017                 $$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
2018                 $$ = scm_list_2 (ly_scheme_function ("number-markup"),
2019                                 $$);
2020         }
2021         | STRING { $$ = $1; }
2022         ;
2023
2024 bass_mod:
2025         '-'     { $$ = -2; }
2026         | '+'   { $$ = 2; }
2027         | '!'   { $$ = 0; }
2028         ;
2029
2030 bass_figure:
2031         FIGURE_SPACE {
2032                 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
2033                 $$ = bfr->self_scm ();
2034                 scm_gc_unprotect_object ($$);
2035         }
2036         | bass_number  {
2037                 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
2038                 $$ = bfr->self_scm ();
2039
2040                 bfr->set_property ("figure", $1);
2041
2042                 scm_gc_unprotect_object ($$);
2043         }
2044         | bass_figure bass_mod {
2045                 Music *m = unsmob_music ($1);
2046                 if ($2) {
2047                         SCM salter = m->get_property ("alteration");
2048                         int alter = ly_c_number_p (salter) ? ly_scm2int (salter) : 0;
2049                         m->set_property ("alteration",
2050                                 scm_int2num (alter + $2));
2051                 } else {
2052                         m->set_property ("alteration", scm_int2num (0));
2053                 }
2054         }
2055         ;
2056
2057 br_bass_figure:
2058         '[' bass_figure {
2059                 $$ = $2;
2060                 unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
2061         }
2062         | bass_figure   {
2063                 $$ = $1;
2064         }
2065         | br_bass_figure ']' {
2066                 $$ = $1;
2067                 unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
2068         }
2069         ;
2070
2071 figure_list:
2072         /**/            {
2073                 $$ = SCM_EOL;
2074         }
2075         | figure_list br_bass_figure {
2076                 $$ = scm_cons ($2, $1);
2077         }
2078         ;
2079
2080 figure_spec:
2081         FIGURE_OPEN figure_list FIGURE_CLOSE {
2082                 Music *m = MY_MAKE_MUSIC ("EventChord");
2083                 $2 = scm_reverse_x ($2, SCM_EOL);
2084                 m->set_property ("elements", $2);
2085                 $$ = m->self_scm ();
2086         }
2087         ;
2088
2089
2090 optional_rest:
2091         /**/   { $$ = 0; }
2092         | REST { $$ = 1; }
2093         ;
2094
2095 simple_element:
2096         pitch exclamations questions oct_check optional_notemode_duration optional_rest {
2097
2098                 Input i = THIS->pop_spot ();
2099                 if (!THIS->lexer_->is_note_state ())
2100                         THIS->parser_error (_ ("Have to be in Note mode for notes"));
2101
2102                 Music *n = 0;
2103                 if ($6)
2104                         n = MY_MAKE_MUSIC ("RestEvent");
2105                 else
2106                         n = MY_MAKE_MUSIC ("NoteEvent");
2107
2108                 n->set_property ("pitch", $1);
2109                 n->set_property ("duration", $5);
2110
2111                 if (ly_c_number_p ($4))
2112                 {
2113                         int q = ly_scm2int ($4);
2114                         n->set_property ("absolute-octave", scm_int2num (q-1));
2115                 }
2116
2117                 if ($3 % 2)
2118                         n->set_property ("cautionary", SCM_BOOL_T);
2119                 if ($2 % 2 || $3 % 2)
2120                         n->set_property ("force-accidental", SCM_BOOL_T);
2121
2122                 Music *v = MY_MAKE_MUSIC ("EventChord");
2123                 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2124                 scm_gc_unprotect_object (n->self_scm ());
2125
2126                 v->set_spot (i);
2127                 n->set_spot (i);
2128                 $$ = v;
2129         }
2130         | DRUM_PITCH optional_notemode_duration {
2131                 Input i = THIS->pop_spot ();
2132
2133                 Music *n = MY_MAKE_MUSIC ("NoteEvent");
2134                 n->set_property ("duration", $2);
2135                 n->set_property ("drum-type", $1);
2136
2137                 Music *v = MY_MAKE_MUSIC ("EventChord");
2138                 v->set_property ("elements", scm_list_1 (n->self_scm ()));
2139                 scm_gc_unprotect_object (n->self_scm ());
2140                 v->set_spot (i);
2141                 n->set_spot (i);
2142                 $$ = v;
2143
2144         }
2145         | figure_spec optional_notemode_duration {
2146                 Music *m = unsmob_music ($1);
2147                 Input i = THIS->pop_spot ();
2148                 m->set_spot (i);
2149                 for (SCM s = m->get_property ("elements"); ly_c_pair_p (s); s = ly_cdr (s))
2150                 {
2151                         unsmob_music (ly_car (s))->set_property ("duration", $2);
2152                 }
2153                 $$ = m;
2154         }
2155         | RESTNAME optional_notemode_duration           {
2156
2157                 Input i = THIS->pop_spot ();
2158                 Music *ev = 0;
2159                 if (ly_scm2string ($1) == "s") {
2160                         /* Space */
2161                         ev = MY_MAKE_MUSIC ("SkipEvent");
2162                   }
2163                 else {
2164                         ev = MY_MAKE_MUSIC ("RestEvent");
2165
2166                     }
2167                 ev->set_property ("duration", $2);
2168                 ev->set_spot (i);
2169                 Music *velt = MY_MAKE_MUSIC ("EventChord");
2170                 velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
2171                 velt->set_spot (i);
2172
2173                 scm_gc_unprotect_object (ev->self_scm ());
2174
2175                 $$ = velt;
2176         }
2177         | MULTI_MEASURE_REST optional_notemode_duration         {
2178                 THIS->pop_spot ();
2179
2180                 SCM proc = ly_scheme_function ("make-multi-measure-rest");
2181                 SCM mus = scm_call_2 (proc, $2,
2182                         make_input (THIS->here_input ()));
2183                 scm_gc_protect_object (mus);
2184                 $$ = unsmob_music (mus);
2185         }
2186
2187         | lyric_element optional_notemode_duration      {
2188                 Input i = THIS->pop_spot ();
2189                 if (!THIS->lexer_->is_lyric_state ())
2190                         THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
2191
2192                 Music *lreq = MY_MAKE_MUSIC ("LyricEvent");
2193                 lreq->set_property ("text", $1);
2194                 lreq->set_property ("duration",$2);
2195                 lreq->set_spot (i);
2196                 Music *velt = MY_MAKE_MUSIC ("EventChord");
2197                 velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
2198
2199                 $$= velt;
2200         }
2201         | new_chord {
2202                 THIS->pop_spot ();
2203
2204                 if (!THIS->lexer_->is_chord_state ())
2205                         THIS->parser_error (_ ("Have to be in Chord mode for chords"));
2206                 $$ = unsmob_music ($1);
2207         }
2208         ;
2209
2210 lyric_element:
2211         /* FIXME: lyric flavoured markup would be better */
2212         full_markup {
2213         }
2214         | LYRICS_STRING {
2215         }
2216         ;
2217
2218 new_chord:
2219         steno_tonic_pitch optional_notemode_duration   {
2220                 $$ = make_chord ($1, $2, SCM_EOL);
2221         }
2222         | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
2223                 SCM its = scm_reverse_x ($4, SCM_EOL);
2224                 $$ = make_chord ($1, $2, scm_cons ($3, its));
2225         }
2226         ;
2227
2228 chord_items:
2229         /**/ {
2230                 $$ = SCM_EOL;
2231         }
2232         | chord_items chord_item {
2233                 $$ = scm_cons ($2, $$);
2234         }
2235         ;
2236
2237 chord_separator:
2238         CHORD_COLON {
2239                 $$ = ly_symbol2scm ("chord-colon");
2240         }
2241         | CHORD_CARET {
2242                 $$ = ly_symbol2scm ("chord-caret");
2243         }
2244         | CHORD_SLASH steno_tonic_pitch {
2245                 $$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2);
2246         }
2247         | CHORD_BASS steno_tonic_pitch {
2248                 $$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2);
2249         }
2250         ;
2251
2252 chord_item:
2253         chord_separator {
2254                 $$ = $1;
2255         }
2256         | step_numbers {
2257                 $$ = scm_reverse_x ($1, SCM_EOL);
2258         }
2259         | CHORD_MODIFIER  {
2260                 $$ = $1;
2261         }
2262         ;
2263
2264 step_numbers:
2265         step_number { $$ = scm_cons ($1, SCM_EOL); }
2266         | step_numbers '.' step_number {
2267                 $$ = scm_cons ($3, $$);
2268         }
2269         ;
2270
2271 step_number:
2272         bare_unsigned {
2273                 $$ = make_chord_step ($1, 0);
2274         }
2275         | bare_unsigned '+' {
2276                 $$ = make_chord_step ($1, SHARP);
2277         }
2278         | bare_unsigned CHORD_MINUS {
2279                 $$ = make_chord_step ($1, FLAT);
2280         }
2281         ;
2282
2283 /*
2284         UTILITIES
2285
2286 TODO: should deprecate in favor of Scheme?
2287
2288  */
2289 number_expression:
2290         number_expression '+' number_term {
2291                 $$ = scm_sum ($1, $3);
2292         }
2293         | number_expression '-' number_term {
2294                 $$ = scm_difference ($1, $3);
2295         }
2296         | number_term
2297         ;
2298
2299 number_term:
2300         number_factor {
2301                 $$ = $1;
2302         }
2303         | number_factor '*' number_factor {
2304                 $$ = scm_product ($1, $3);
2305         }
2306         | number_factor '/' number_factor {
2307                 $$ = scm_divide ($1, $3);
2308         }
2309         ;
2310
2311 number_factor:
2312         '-'  number_factor { /* %prec UNARY_MINUS */
2313                 $$ = scm_difference ($2, SCM_UNDEFINED);
2314         }
2315         | bare_number
2316         ;
2317
2318
2319 bare_number:
2320         UNSIGNED        {
2321                 $$ = scm_int2num ($1);
2322         }
2323         | REAL          {
2324                 $$ = $1;
2325         }
2326         | NUMBER_IDENTIFIER             {
2327                 $$ = $1;
2328         }
2329         | REAL NUMBER_IDENTIFIER        {
2330                 $$ = scm_make_real (ly_scm2double ($1) *ly_scm2double ($2));
2331         }
2332         | UNSIGNED NUMBER_IDENTIFIER    {
2333                 $$ = scm_make_real ($1 *ly_scm2double ($2));
2334         }
2335         ;
2336
2337
2338 bare_unsigned:
2339         UNSIGNED {
2340                         $$ = $1;
2341         }
2342         | DIGIT {
2343                 $$ = $1;
2344         }
2345         ;
2346
2347 bare_int:
2348         bare_number {
2349                 if (scm_integer_p ($1) == SCM_BOOL_T)
2350                 {
2351                         int k = ly_scm2int ($1);
2352                         $$ = k;
2353                 } else
2354                 {
2355                         THIS->parser_error (_ ("need integer number arg"));
2356                         $$ = 0;
2357                 }
2358         }
2359         | '-' bare_int {
2360                 $$ = -$2;
2361         }
2362         ;
2363
2364 exclamations:
2365                 { $$ = 0; }
2366         | exclamations '!'      { $$ ++; }
2367         ;
2368
2369 questions:
2370                 { $$ = 0; }
2371         | questions '?' { $$ ++; }
2372         ;
2373
2374
2375
2376 full_markup:
2377         MARKUP_IDENTIFIER {
2378                 $$ = $1;
2379         }
2380         | MARKUP
2381                 { THIS->lexer_->push_markup_state (); }
2382         markup
2383                 { $$ = $3;
2384                   THIS->lexer_->pop_state ();
2385                 }
2386         ;
2387
2388
2389 /*
2390 This should be done more dynamically if possible.
2391 */
2392 markup:
2393         STRING {
2394                 $$ = make_simple_markup (THIS->lexer_->encoding (), $1);
2395         }
2396         | MARKUP_HEAD_EMPTY {
2397                 $$ = scm_list_1 ($1);
2398         }
2399         | MARKUP_HEAD_MARKUP0 markup {
2400                 $$ = scm_list_2 ($1, $2);
2401         }
2402         | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
2403                 $$ = scm_list_3 ($1, $2, $3);
2404         }
2405         | MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
2406                 $$ = scm_list_3 ($1, $2, $3);
2407         }
2408         | markup_line {
2409                 $$ = $1;
2410         }
2411         | MARKUP_HEAD_LIST0 markup_list {
2412                 $$ = scm_list_2 ($1,$2);
2413         }
2414         | MARKUP_HEAD_SCM0 embedded_scm {
2415                 $$ = scm_list_2 ($1, $2);
2416         }
2417         | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm markup {
2418                 $$ = scm_list_4 ($1, $2, $3, $4);
2419         }
2420         | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
2421                 $$ = scm_list_4 ($1, $2, $3, $4);
2422         }
2423         | MARKUP_HEAD_SCM0_SCM1 embedded_scm embedded_scm {
2424                 $$ = scm_list_3 ($1, $2, $3);
2425         }
2426         | MARKUP_IDENTIFIER {
2427                 $$ = $1;
2428         }
2429         | STRING_IDENTIFIER {
2430                 $$ = $1;
2431         }
2432         | {
2433                 SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
2434                 THIS->lexer_->push_note_state (alist_to_hashq (nn));
2435         }
2436         /* cont */ score_block {
2437                 /* WIP this is a bit arbitrary,
2438                    we should also allow \book or Composite_music.
2439                    However, you'd typically want to change paper
2440                    settings, and need a \score block anyway.  */
2441
2442                 THIS->lexer_->pop_state ();
2443                 Score *score = $2;
2444                 Book *book = new Book;
2445                 book->scores_.push (score);
2446
2447                 Music_output_def *paper = get_paper (THIS);
2448                 SCM s = book->to_stencil (paper, THIS->header_);
2449                 scm_gc_unprotect_object (score->self_scm ());
2450                 scm_gc_unprotect_object (book->self_scm ());
2451                 $$ = scm_list_2 (ly_scheme_function ("stencil-markup"), s);
2452         }
2453         ;
2454
2455 markup_list:
2456         chord_open markup_list_body chord_close { $$ = scm_reverse_x ($2, SCM_EOL); }
2457         ;
2458
2459 markup_line:
2460         '{' markup_list_body '}' {
2461                 SCM line = ly_scheme_function ("line-markup");
2462
2463                 $$ = scm_list_2 (line, scm_reverse_x ($2, SCM_EOL));
2464         }
2465         ;
2466
2467 markup_list_body:
2468         /**/ {  $$ = SCM_EOL; }
2469         | markup_list_body markup {
2470                 $$ = scm_cons ($2, $1);
2471         }
2472         ;
2473
2474
2475 %%
2476
2477 void
2478 My_lily_parser::set_yydebug (bool )
2479 {
2480 #if 0
2481         yydebug = 1;
2482 #endif
2483 }
2484
2485 void
2486 My_lily_parser::do_yyparse ()
2487 {
2488         yyparse ((void*)this);
2489 }
2490
2491
2492 /*
2493 Should make this optional?    It will also complain when you do
2494
2495         [s4]
2496
2497 which is entirely legitimate.
2498
2499 Or we can scrap it. Barchecks should detect wrong durations, and
2500 skipTypesetting speeds it up a lot.
2501 */
2502
2503 void
2504 My_lily_parser::beam_check (SCM dur)
2505 {
2506   Duration *d = unsmob_duration (dur);
2507   if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
2508     {
2509       Music *m = unsmob_music (last_beam_start_);
2510       m->origin ()->warning (_ ("Suspect duration found following this beam"));
2511     }
2512   last_beam_start_ = SCM_EOL;
2513 }
2514
2515
2516
2517
2518 /*
2519
2520 It is a little strange to have this function in this file, but
2521 otherwise, we have to import music classes into the lexer.
2522
2523 */
2524 int
2525 My_lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
2526 {
2527         if (ly_c_string_p (sid)) {
2528                 *destination = sid;
2529                 return STRING_IDENTIFIER;
2530         } else if (ly_c_number_p (sid)) {
2531                 *destination = sid;
2532                 return NUMBER_IDENTIFIER;
2533         } else if (unsmob_context_def (sid)) {
2534                 *destination = unsmob_context_def (sid)->clone_scm ();
2535                 return CONTEXT_DEF_IDENTIFIER;
2536         } else if (unsmob_score (sid)) {
2537                 Score *score = new Score (*unsmob_score (sid));
2538                 *destination = score->self_scm ();
2539                 return SCORE_IDENTIFIER;
2540         } else if (Music *mus = unsmob_music (sid)) {
2541                 mus = mus->clone ();
2542                 *destination = mus->self_scm ();
2543                 unsmob_music (*destination)->
2544                         set_property ("origin", make_input (last_input_));
2545                 return dynamic_cast<Event*> (mus)
2546                         ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
2547         } else if (unsmob_duration (sid)) {
2548                 *destination = unsmob_duration (sid)->smobbed_copy ();
2549                 return DURATION_IDENTIFIER;
2550         } else if (unsmob_music_output_def (sid)) {
2551                 Music_output_def *p = unsmob_music_output_def (sid);
2552                 p = p->clone ();
2553
2554                 *destination = p->self_scm ();
2555                 return MUSIC_OUTPUT_DEF_IDENTIFIER;
2556         } else if (Text_item::markup_p (sid)) {
2557                 *destination = sid;
2558                 return MARKUP_IDENTIFIER;
2559         }
2560
2561         return -1;
2562 }
2563
2564 Music *
2565 property_op_to_music (SCM op)
2566 {
2567         Music *m = 0;
2568         SCM tag = ly_car (op);
2569         SCM symbol = ly_cadr (op);
2570         SCM args = ly_cddr (op);
2571         SCM grob_val = SCM_UNDEFINED;
2572         SCM grob_sym = SCM_UNDEFINED;
2573         SCM val = SCM_UNDEFINED;
2574
2575         if (tag == ly_symbol2scm ("assign"))
2576                 {
2577                 m = MY_MAKE_MUSIC ("PropertySet");
2578                 val = ly_car (args);
2579                 }
2580         else if (tag == ly_symbol2scm ("unset"))
2581                 m = MY_MAKE_MUSIC ("PropertyUnset");
2582         else if (tag == ly_symbol2scm ("poppush")
2583                  || tag == ly_symbol2scm ("push"))
2584                 {
2585                 m = MY_MAKE_MUSIC ("OverrideProperty");
2586                 grob_sym = ly_car (args);
2587                 grob_val = ly_cadr (args);
2588                 }
2589         else if (tag == ly_symbol2scm ("pop")) {
2590                 m = MY_MAKE_MUSIC ("RevertProperty");
2591                 grob_sym = ly_car (args);
2592                 }
2593
2594         m->set_property ("symbol", symbol);
2595
2596         if (val != SCM_UNDEFINED)
2597                 m->set_property ("value", val);
2598         if (grob_val != SCM_UNDEFINED)
2599                 m->set_property ("grob-value", grob_val);
2600
2601         if (grob_sym != SCM_UNDEFINED)
2602                 {
2603                 bool itc = internal_type_checking_global_b;
2604                 /* UGH.
2605                 */
2606                 bool autobeam = ly_c_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
2607                 if (autobeam)
2608                         internal_type_checking_global_b = false;
2609                 m->set_property ("grob-property", grob_sym);
2610                 if (autobeam)
2611                         internal_type_checking_global_b = itc;
2612                 }
2613
2614         if (tag == ly_symbol2scm ("poppush"))
2615                 m->set_property ("pop-first", SCM_BOOL_T);
2616
2617
2618         return m;
2619 }
2620
2621 Music*
2622 context_spec_music (SCM type, SCM id, Music *m, SCM ops)
2623 {
2624         Music *csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
2625
2626         csm->set_property ("element", m->self_scm ());
2627         scm_gc_unprotect_object (m->self_scm ());
2628
2629         csm->set_property ("context-type",
2630                 ly_c_symbol_p (type) ? type : scm_string_to_symbol (type));
2631         csm->set_property ("property-operations", ops);
2632
2633         if (ly_c_string_p (id))
2634                 csm->set_property ("context-id", id);
2635         return csm;
2636 }
2637
2638 SCM
2639 get_next_unique_context ()
2640 {
2641         static int new_context_count;
2642         char s[1024];
2643         snprintf (s, 1024, "uniqueContext%d", new_context_count++);
2644         return scm_makfrom0str (s);
2645 }
2646