lily/parser.yy

   1 /* -*- mode: c++; c-file-style: "linux"; indent-tabs-mode: t -*- */
   2 /*
   3   This file is part of LilyPond, the GNU music typesetter.
   4
   5   Copyright (C) 1997--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
   6                  Jan Nieuwenhuizen <janneke@gnu.org>
   7
   8   LilyPond is free software: you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation, either version 3 of the License, or
  11   (at your option) any later version.
  12
  13   LilyPond is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /* Mode and indentation are at best a rough approximation based on TAB
  23  * formatting (reasonable for compatibility with unspecific editor
  24  * modes as Bison modes are hard to find) and need manual correction
  25  * frequently.  Without a reasonably dependable way of formatting a
  26  * Bison file sensibly, there is little point in trying to fix the
  27  * inconsistent state of indentation.
  28  */
  29
  30 %{
  31
  32 #define yyerror Lily_parser::parser_error
  33
  34 /* We use custom location type: Input objects */
  35 #define YYLTYPE Input
  36 #define YYSTYPE SCM
  37 #define YYLLOC_DEFAULT(Current,Rhs,N) \
  38         ((Current).set_location ((Rhs)[1], (Rhs)[N]))
  39
  40 #define YYPRINT(file, type, value)                                      \
  41         do {                                                            \
  42                 if (scm_is_eq (value, SCM_UNSPECIFIED))                 \
  43                         break;                                          \
  44                 char *p = scm_to_locale_string                          \
  45                         (scm_simple_format (SCM_BOOL_F,                 \
  46                                             scm_from_locale_string ("~S"), \
  47                                             scm_list_1 (value)));       \
  48                 fputs (p, file);                                        \
  49                 free (p);                                               \
  50         } while (0)
  51
  52 %}
  53
  54 %parse-param {Lily_parser *parser}
  55 %parse-param {SCM *retval}
  56 %lex-param {Lily_parser *parser}
  57 %error-verbose
  58 %debug
  59
  60 /* We use SCMs to do strings, because it saves us the trouble of
  61 deleting them.  Let's hope that a stack overflow doesn't trigger a move
  62 of the parse stack onto the heap. */
  63
  64 %left PREC_BOT
  65 %nonassoc REPEAT REPEAT_IDENTIFIER
  66 %nonassoc ALTERNATIVE
  67
  68 /* The above precedences tackle the shift/reduce problem
  69
  70 1.  \repeat
  71         \repeat .. \alternative
  72
  73     \repeat { \repeat .. \alternative }
  74
  75 or
  76
  77     \repeat { \repeat } \alternative
  78 */
  79
  80 %nonassoc COMPOSITE
  81 %left ADDLYRICS
  82
  83 %right ':' UNSIGNED REAL E_UNSIGNED EVENT_IDENTIFIER EVENT_FUNCTION '^' '_'
  84        HYPHEN EXTENDER DURATION_IDENTIFIER
  85
  86  /* The above are needed for collecting tremoli and other items (that
  87     could otherwise be interpreted as belonging to the next function
  88     argument) greedily, and together with the next rule will serve to
  89     join numbers and units greedily instead of allowing them into
  90     separate function arguments
  91  */
  92
  93 %nonassoc NUMBER_IDENTIFIER
  94
  95 %left PREC_TOP
  96
  97
  98
  99
 100 %pure-parser
 101 %locations
 102
 103
 104
 105 %{ // -*-Fundamental-*-
 106
 107 /*
 108 FIXME:
 109
 110    * The rules for who is protecting what are very shady.  Uniformise
 111      this.
 112
 113    * There are too many lexical modes?
 114 */
 115
 116 #include "config.hh"
 117
 118 #include <cctype>
 119 #include <cstdlib>
 120 #include <cstdio>
 121 using namespace std;
 122
 123 #include "book.hh"
 124 #include "context-def.hh"
 125 #include "context-mod.hh"
 126 #include "dimensions.hh"
 127 #include "file-path.hh"
 128 #include "input.hh"
 129 #include "international.hh"
 130 #include "lily-guile.hh"
 131 #include "lily-lexer.hh"
 132 #include "lily-parser.hh"
 133 #include "main.hh"
 134 #include "misc.hh"
 135 #include "music.hh"
 136 #include "output-def.hh"
 137 #include "paper-book.hh"
 138 #include "scm-hash.hh"
 139 #include "score.hh"
 140 #include "text-interface.hh"
 141 #include "warn.hh"
 142
 143 void
 144 Lily_parser::parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s)
 145 {
 146         parser->parser_error (*i, s);
 147 }
 148
 149 #define MYBACKUP(Token, Value, Location)                                \
 150 do                                                                      \
 151         if (yychar == YYEMPTY)                                          \
 152         {                                                               \
 153                 if (Token)                                              \
 154                         parser->lexer_->push_extra_token (Token, Value); \
 155                 parser->lexer_->push_extra_token (BACKUP);              \
 156         } else {                                                        \
 157                 parser->parser_error                                    \
 158                         (Location, _("Too much lookahead"));            \
 159         }                                                               \
 160 while (0)
 161
 162
 163 #define MYREPARSE(Location, Pred, Token, Value)                         \
 164 do                                                                      \
 165         if (yychar == YYEMPTY)                                          \
 166         {                                                               \
 167                 parser->lexer_->push_extra_token (Token, Value);        \
 168                 parser->lexer_->push_extra_token (REPARSE,              \
 169                                                   Pred);                \
 170         } else {                                                        \
 171                 parser->parser_error                                    \
 172                         (Location, _("Too much lookahead"));            \
 173         }                                                               \
 174 while (0)
 175
 176 %}
 177
 178
 179 %{
 180
 181 #define MY_MAKE_MUSIC(x, spot) \
 182         make_music_with_input (ly_symbol2scm (x), \
 183                                parser->lexer_->override_input (spot))
 184
 185 /* ES TODO:
 186 - Don't use lily module, create a new module instead.
 187 - delay application of the function
 188 */
 189 #define LOWLEVEL_MAKE_SYNTAX(proc, args)        \
 190   scm_apply_0 (proc, args)
 191 /* Syntactic Sugar. */
 192 #define MAKE_SYNTAX(name, location, ...)                                \
 193         LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_input (parser->lexer_->override_input (location)), ##__VA_ARGS__, SCM_UNDEFINED))
 194 #define START_MAKE_SYNTAX(name, ...)                                    \
 195         scm_list_n (ly_lily_module_constant (name) , ##__VA_ARGS__, SCM_UNDEFINED)
 196 #define FINISH_MAKE_SYNTAX(start, location, ...)                        \
 197         LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons2 (parser->self_scm (), make_input (parser->lexer_->override_input (location)), scm_append_x (scm_list_2 (scm_cdr (start), scm_list_n (__VA_ARGS__, SCM_UNDEFINED)))))
 198
 199 SCM get_next_unique_context_id ();
 200 SCM get_next_unique_lyrics_context_id ();
 201
 202 #undef _
 203 #if !HAVE_GETTEXT
 204 #define _(x) x
 205 #else
 206 #include <libintl.h>
 207 #define _(x) gettext (x)
 208 #endif
 209
 210
 211 static Music *make_music_with_input (SCM name, Input where);
 212 SCM check_scheme_arg (Lily_parser *parser, Input loc,
 213                       SCM arg, SCM args, SCM pred, SCM disp = SCM_UNDEFINED);
 214 SCM make_music_from_simple (Lily_parser *parser, Input loc, SCM pitch);
 215 SCM loc_on_music (Input loc, SCM arg);
 216 SCM make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list);
 217 SCM make_chord_step (SCM step, Rational alter);
 218 SCM make_simple_markup (SCM a);
 219 SCM make_duration (SCM t, int dots = 0);
 220 bool is_regular_identifier (SCM id, bool multiple=false);
 221 SCM try_string_variants (SCM pred, SCM str);
 222 int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
 223
 224 %}
 225
 226 /* The third option is an alias that will be used to display the
 227    syntax error.  Bison CVS now correctly handles backslash escapes.
 228
 229    FIXME: Bison needs to translate some of these, eg, STRING.
 230
 231 */
 232
 233 /* Keyword tokens with plain escaped name.  */
 234 %token END_OF_FILE 0 "end of input"
 235 %token ACCEPTS "\\accepts"
 236 %token ADDLYRICS "\\addlyrics"
 237 %token ALIAS "\\alias"
 238 %token ALTERNATIVE "\\alternative"
 239 %token BOOK "\\book"
 240 %token BOOKPART "\\bookpart"
 241 %token CHANGE "\\change"
 242 %token CHORDMODE "\\chordmode"
 243 %token CHORDS "\\chords"
 244 %token CONSISTS "\\consists"
 245 %token CONTEXT "\\context"
 246 %token DEFAULT "\\default"
 247 %token DEFAULTCHILD "\\defaultchild"
 248 %token DENIES "\\denies"
 249 %token DESCRIPTION "\\description"
 250 %token DRUMMODE "\\drummode"
 251 %token DRUMS "\\drums"
 252 %token FIGUREMODE "\\figuremode"
 253 %token FIGURES "\\figures"
 254 %token HEADER "\\header"
 255 %token INVALID "\\version-error"
 256 %token LAYOUT "\\layout"
 257 %token LYRICMODE "\\lyricmode"
 258 %token LYRICS "\\lyrics"
 259 %token LYRICSTO "\\lyricsto"
 260 %token MARKUP "\\markup"
 261 %token MARKUPLIST "\\markuplist"
 262 %token MIDI "\\midi"
 263 %token NAME "\\name"
 264 %token NOTEMODE "\\notemode"
 265 %token OVERRIDE "\\override"
 266 %token PAPER "\\paper"
 267 %token REMOVE "\\remove"
 268 %token REPEAT "\\repeat"
 269 %token REST "\\rest"
 270 %token REVERT "\\revert"
 271 %token SCORE "\\score"
 272 %token SCORELINES "\\score-lines"
 273 %token SEQUENTIAL "\\sequential"
 274 %token SET "\\set"
 275 %token SIMULTANEOUS "\\simultaneous"
 276 %token TEMPO "\\tempo"
 277 %token TYPE "\\type"
 278 %token UNSET "\\unset"
 279 %token WITH "\\with"
 280
 281 /* Keyword token exceptions.  */
 282 %token NEWCONTEXT "\\new"
 283
 284
 285 /* Other string tokens.  */
 286
 287 %token CHORD_BASS "/+"
 288 %token CHORD_CARET "^"
 289 %token CHORD_COLON ":"
 290 %token CHORD_MINUS "-"
 291 %token CHORD_SLASH "/"
 292 %token ANGLE_OPEN "<"
 293 %token ANGLE_CLOSE ">"
 294 %token DOUBLE_ANGLE_OPEN "<<"
 295 %token DOUBLE_ANGLE_CLOSE ">>"
 296 %token E_BACKSLASH "\\"
 297 %token E_EXCLAMATION "\\!"
 298 %token E_PLUS "\\+"
 299 %token EXTENDER "__"
 300
 301 /*
 302 If we give names, Bison complains.
 303 */
 304 %token FIGURE_CLOSE /* "\\>" */
 305 %token FIGURE_OPEN /* "\\<" */
 306 %token FIGURE_SPACE "_"
 307 %token HYPHEN "--"
 308
 309 %token MULTI_MEASURE_REST
 310
 311
 312 %token E_UNSIGNED
 313 %token UNSIGNED
 314
 315 /* Artificial tokens, for more generic function syntax */
 316 %token EXPECT_MARKUP "markup?"
 317 %token EXPECT_SCM "scheme?"
 318 %token BACKUP "(backed-up?)"
 319 %token REPARSE "(reparsed?)"
 320 %token EXPECT_MARKUP_LIST "markup-list?"
 321 %token EXPECT_OPTIONAL "optional?"
 322 /* After the last argument. */
 323 %token EXPECT_NO_MORE_ARGS;
 324
 325 /* An artificial token for parsing embedded Lilypond */
 326 %token EMBEDDED_LILY "#{"
 327
 328 %token BOOK_IDENTIFIER
 329 %token CHORD_BODY_IDENTIFIER
 330 %token CHORD_MODIFIER
 331 %token CHORD_REPETITION
 332 %token CONTEXT_DEF_IDENTIFIER
 333 %token CONTEXT_MOD_IDENTIFIER
 334 %token DRUM_PITCH
 335 %token PITCH_IDENTIFIER
 336 %token DURATION_IDENTIFIER
 337 %token EVENT_IDENTIFIER
 338 %token EVENT_FUNCTION
 339 %token FRACTION
 340 %token LYRIC_ELEMENT
 341 %token MARKUP_FUNCTION
 342 %token MARKUP_LIST_FUNCTION
 343 %token MARKUP_IDENTIFIER
 344 %token MARKUPLIST_IDENTIFIER
 345 %token MUSIC_FUNCTION
 346 %token MUSIC_IDENTIFIER
 347 %token NOTENAME_PITCH
 348 %token NUMBER_IDENTIFIER
 349 %token OUTPUT_DEF_IDENTIFIER
 350 %token REAL
 351 %token REPEAT_IDENTIFIER
 352 %token RESTNAME
 353 %token SCM_ARG
 354 %token SCM_FUNCTION
 355 %token SCM_IDENTIFIER
 356 %token SCM_TOKEN
 357 %token STRING
 358 %token SYMBOL_LIST
 359 %token TONICNAME_PITCH
 360
 361 %left '-' '+'
 362
 363 /* We don't assign precedence to / and *, because we might need varied
 364 prec levels in different prods */
 365
 366 %left UNARY_MINUS
 367
 368 %%
 369
 370 start_symbol:
 371         lilypond
 372         | EMBEDDED_LILY {
 373                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
 374                 parser->lexer_->push_note_state (nn);
 375         } embedded_lilypond {
 376                 parser->lexer_->pop_state ();
 377                 *retval = $3;
 378         }
 379         ;
 380
 381 lilypond:       /* empty */ { $$ = SCM_UNSPECIFIED; }
 382         | lilypond toplevel_expression {
 383         }
 384         | lilypond assignment {
 385         }
 386         | lilypond error {
 387                 parser->error_level_ = 1;
 388         }
 389         | lilypond INVALID      {
 390                 parser->error_level_ = 1;
 391         }
 392         ;
 393
 394
 395 toplevel_expression:
 396         {
 397                 parser->lexer_->add_scope (get_header (parser));
 398         } lilypond_header {
 399                 parser->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $2);
 400         }
 401         | book_block {
 402                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-book-handler");
 403                 scm_call_2 (proc, parser->self_scm (), $1);
 404         }
 405         | bookpart_block {
 406                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler");
 407                 scm_call_2 (proc, parser->self_scm (), $1);
 408         }
 409         | score_block {
 410                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
 411                 scm_call_2 (proc, parser->self_scm (), $1);
 412         }
 413         | composite_music {
 414                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-music-handler");
 415                 scm_call_2 (proc, parser->self_scm (), $1);
 416         }
 417         | full_markup {
 418                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
 419                 scm_call_2 (proc, parser->self_scm (), scm_list_1 ($1));
 420         }
 421         | full_markup_list {
 422                 SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
 423                 scm_call_2 (proc, parser->self_scm (), $1);
 424         }
 425         | SCM_TOKEN {
 426                 // Evaluate and ignore #xxx, as opposed to \xxx
 427                 parser->lexer_->eval_scm_token ($1);
 428         }
 429         | embedded_scm_active
 430         {
 431                 SCM out = SCM_UNDEFINED;
 432                 if (Text_interface::is_markup ($1))
 433                         out = scm_list_1 ($1);
 434                 else if (Text_interface::is_markup_list ($1))
 435                         out = $1;
 436                 if (scm_is_pair (out))
 437                 {
 438                         SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
 439                         scm_call_2 (proc, parser->self_scm (), out);
 440                 } else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
 441                         parser->parser_error (@1, _("bad expression type"));
 442         }
 443         | output_def {
 444                 SCM id = SCM_EOL;
 445                 Output_def * od = unsmob_output_def ($1);
 446
 447                 if (od->c_variable ("is-paper") == SCM_BOOL_T)
 448                         id = ly_symbol2scm ("$defaultpaper");
 449                 else if (od->c_variable ("is-midi") == SCM_BOOL_T)
 450                         id = ly_symbol2scm ("$defaultmidi");
 451                 else if (od->c_variable ("is-layout") == SCM_BOOL_T)
 452                         id = ly_symbol2scm ("$defaultlayout");
 453
 454                 parser->lexer_->set_identifier (id, $1);
 455         }
 456         ;
 457
 458 embedded_scm_bare:
 459         SCM_TOKEN
 460         {
 461                 $$ = parser->lexer_->eval_scm_token ($1);
 462         }
 463         | SCM_IDENTIFIER
 464         ;
 465
 466 embedded_scm_active:
 467         SCM_IDENTIFIER
 468         | scm_function_call
 469         ;
 470
 471 embedded_scm_bare_arg:
 472         SCM_ARG
 473         | SCM_TOKEN
 474         {
 475                 $$ = parser->lexer_->eval_scm_token ($1);
 476         }
 477         | FRACTION
 478         | full_markup_list
 479         | context_modification
 480         | score_block
 481         | context_def_spec_block
 482         | book_block
 483         | bookpart_block
 484         | output_def
 485         ;
 486
 487 /* The generic version may end in music, or not */
 488
 489 embedded_scm:
 490         embedded_scm_bare
 491         | scm_function_call
 492         ;
 493
 494 /* embedded_scm_arg is _not_ casting pitches to music by default, this
 495  * has to be done by the function itself.  Note that this may cause
 496  * the results of scm_function_call or embedded_scm_bare_arg to be
 497  * turned into music from pitches as well.  Note that this creates a
 498  * distinctly awkward situation for calculated drum pitches.  Those
 499  * are at the current point of time rejected as music constituents as
 500  * they can't be distinguished from "proper" symbols.
 501  */
 502
 503 embedded_scm_arg:
 504         embedded_scm_bare_arg
 505         | scm_function_call
 506         | music_assign
 507         ;
 508
 509 scm_function_call:
 510         SCM_FUNCTION function_arglist {
 511                 $$ = MAKE_SYNTAX ("music-function", @$,
 512                                          $1, $2);
 513         }
 514         ;
 515
 516 embedded_lilypond_number:
 517         '-' embedded_lilypond_number
 518         {
 519                 $$ = scm_difference ($2, SCM_UNDEFINED);
 520         }
 521         | bare_number_common
 522         | UNSIGNED NUMBER_IDENTIFIER
 523         {
 524                 $$ = scm_product ($1, $2);
 525         }
 526         ;
 527
 528 embedded_lilypond:
 529         /* empty */
 530         {
 531                 // FIXME: @$ does not contain a useful source location
 532                 // for empty rules, and the only token in the whole
 533                 // production, EMBEDDED_LILY, is synthetic and also
 534                 // contains no source location.
 535                 $$ = MAKE_SYNTAX ("void-music", @$);
 536         }
 537         | identifier_init_nonumber
 538         | embedded_lilypond_number
 539         | post_event post_events
 540         {
 541                 $$ = scm_reverse_x ($2, SCM_EOL);
 542                 if (Music *m = unsmob_music ($1))
 543                 {
 544                         if (m->is_mus_type ("post-event-wrapper"))
 545                                 $$ = scm_append
 546                                         (scm_list_2 (m->get_property ("elements"),
 547                                                      $$));
 548                         else
 549                                 $$ = scm_cons ($1, $$);
 550                 }
 551                 if (scm_is_pair ($$)
 552                     && scm_is_null (scm_cdr ($$)))
 553                         $$ = scm_car ($$);
 554                 else
 555                 {
 556                         Music * m = MY_MAKE_MUSIC ("PostEvents", @$);
 557                         m->set_property ("elements", $$);
 558                         $$ = m->unprotect ();
 559                 }
 560         }
 561         | multiplied_duration
 562         | music_embedded music_embedded music_list {
 563                 $3 = scm_reverse_x ($3, SCM_EOL);
 564                 if (unsmob_music ($2))
 565                         $3 = scm_cons ($2, $3);
 566                 if (unsmob_music ($1))
 567                         $3 = scm_cons ($1, $3);
 568                 $$ = MAKE_SYNTAX ("sequential-music", @$, $3);
 569         }
 570         | error {
 571                 parser->error_level_ = 1;
 572                 $$ = SCM_UNSPECIFIED;
 573         }
 574         | INVALID embedded_lilypond {
 575                 parser->error_level_ = 1;
 576                 $$ = $2;
 577         }
 578         ;
 579
 580
 581 lilypond_header_body:
 582         /* empty */ { $$ = SCM_UNSPECIFIED; }
 583         | lilypond_header_body assignment  {
 584
 585         }
 586         | lilypond_header_body embedded_scm  {
 587
 588         }
 589         ;
 590
 591 lilypond_header:
 592         HEADER '{' lilypond_header_body '}'     {
 593                 $$ = parser->lexer_->remove_scope ();
 594         }
 595         ;
 596
 597 /*
 598         DECLARATIONS
 599 */
 600 assignment_id:
 601         STRING          { $$ = $1; }
 602         ;
 603
 604 assignment:
 605         assignment_id '=' identifier_init  {
 606                 parser->lexer_->set_identifier ($1, $3);
 607                 $$ = SCM_UNSPECIFIED;
 608         }
 609         | assignment_id property_path '=' identifier_init {
 610                 SCM path = scm_cons (scm_string_to_symbol ($1), $2);
 611                 parser->lexer_->set_identifier (path, $4);
 612                 $$ = SCM_UNSPECIFIED;
 613         }
 614         ;
 615
 616
 617 identifier_init:
 618         identifier_init_nonumber
 619         | number_expression
 620         | post_event_nofinger post_events
 621         {
 622                 $$ = scm_reverse_x ($2, SCM_EOL);
 623                 if (Music *m = unsmob_music ($1))
 624                 {
 625                         if (m->is_mus_type ("post-event-wrapper"))
 626                                 $$ = scm_append
 627                                         (scm_list_2 (m->get_property ("elements"),
 628                                                      $$));
 629                         else
 630                                 $$ = scm_cons ($1, $$);
 631                 }
 632                 if (scm_is_pair ($$)
 633                     && scm_is_null (scm_cdr ($$)))
 634                         $$ = scm_car ($$);
 635                 else
 636                 {
 637                         Music * m = MY_MAKE_MUSIC ("PostEvents", @$);
 638                         m->set_property ("elements", $$);
 639                         $$ = m->unprotect ();
 640                 }
 641         }
 642         ;
 643
 644 identifier_init_nonumber:
 645         score_block
 646         | book_block
 647         | bookpart_block
 648         | output_def
 649         | context_def_spec_block
 650         | music_assign
 651         | FRACTION
 652         | string
 653         | embedded_scm
 654         | full_markup_list
 655         | context_modification
 656         ;
 657
 658 context_def_spec_block:
 659         CONTEXT '{' context_def_spec_body '}'
 660                 {
 661                 $$ = $3;
 662                 unsmob_context_def ($$)->origin ()->set_spot (@$);
 663         }
 664         ;
 665
 666 context_mod_arg:
 667         embedded_scm
 668         |
 669         {
 670                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
 671                 parser->lexer_->push_note_state (nn);
 672         }
 673         composite_music
 674         {
 675                 parser->lexer_->pop_state ();
 676                 $$ = $2;
 677         }
 678         ;
 679
 680 context_mod_embedded:
 681         context_mod_arg
 682         {
 683                 if (unsmob_music ($1)) {
 684                         SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
 685                         $1 = scm_call_2 (proc, parser->self_scm (), $1);
 686                 }
 687                 if (unsmob_context_mod ($1))
 688                         $$ = $1;
 689                 else {
 690                         parser->parser_error (@1, _ ("not a context mod"));
 691                         $$ = Context_mod ().smobbed_copy ();
 692                 }
 693         }
 694         ;
 695
 696
 697 context_def_spec_body:
 698         /**/ {
 699                 $$ = Context_def::make_scm ();
 700         }
 701         | CONTEXT_DEF_IDENTIFIER {
 702                 $$ = $1;
 703         }
 704         | context_def_spec_body context_mod {
 705                 if (!SCM_UNBNDP ($2))
 706                         unsmob_context_def ($$)->add_context_mod ($2);
 707         }
 708         | context_def_spec_body context_modification {
 709                 Context_def *td = unsmob_context_def ($$);
 710                 SCM new_mods = unsmob_context_mod ($2)->get_mods ();
 711                 for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
 712                     td->add_context_mod (scm_car (m));
 713                 }
 714         }
 715         | context_def_spec_body context_mod_embedded {
 716                 Context_def *td = unsmob_context_def ($$);
 717                 SCM new_mods = unsmob_context_mod ($2)->get_mods ();
 718                 for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
 719                     td->add_context_mod (scm_car (m));
 720                 }
 721         }
 722         ;
 723
 724
 725
 726 book_block:
 727         BOOK '{' book_body '}'  {
 728                 $$ = $3;
 729                 unsmob_book ($$)->origin ()->set_spot (@$);
 730                 pop_paper (parser);
 731                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F);
 732         }
 733         ;
 734
 735 /* FIXME:
 736    * Use 'handlers' like for toplevel-* stuff?
 737    * grok \layout and \midi?  */
 738 book_body:
 739         {
 740                 Book *book = new Book;
 741                 init_papers (parser);
 742                 book->paper_ = dynamic_cast<Output_def*> (unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
 743                 book->paper_->unprotect ();
 744                 push_paper (parser, book->paper_);
 745                 book->header_ = get_header (parser);
 746                 $$ = book->unprotect ();
 747                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $$);
 748         }
 749         | BOOK_IDENTIFIER {
 750                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1);
 751         }
 752         | book_body paper_block {
 753                 unsmob_book ($1)->paper_ = unsmob_output_def ($2);
 754                 set_paper (parser, unsmob_output_def ($2));
 755         }
 756         | book_body bookpart_block {
 757                 SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler");
 758                 scm_call_2 (proc, $1, $2);
 759         }
 760         | book_body score_block {
 761                 SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
 762                 scm_call_2 (proc, $1, $2);
 763         }
 764         | book_body composite_music {
 765                 SCM proc = parser->lexer_->lookup_identifier ("book-music-handler");
 766                 scm_call_3 (proc, parser->self_scm (), $1, $2);
 767         }
 768         | book_body full_markup {
 769                 SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
 770                 scm_call_2 (proc, $1, scm_list_1 ($2));
 771         }
 772         | book_body full_markup_list {
 773                 SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
 774                 scm_call_2 (proc, $1, $2);
 775         }
 776         | book_body SCM_TOKEN {
 777                 // Evaluate and ignore #xxx, as opposed to \xxx
 778                 parser->lexer_->eval_scm_token ($2);
 779         }
 780         | book_body embedded_scm_active
 781         {
 782                 SCM out = SCM_UNDEFINED;
 783                 if (Text_interface::is_markup ($2))
 784                         out = scm_list_1 ($2);
 785                 else if (Text_interface::is_markup_list ($2))
 786                         out = $2;
 787                 if (scm_is_pair (out))
 788                 {
 789                         SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
 790                         scm_call_2 (proc, $1, out);
 791                 } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
 792                         parser->parser_error (@2, _("bad expression type"));
 793         }
 794         | book_body
 795         {
 796                 parser->lexer_->add_scope (unsmob_book ($1)->header_);
 797         } lilypond_header
 798         | book_body error {
 799                 Book *book = unsmob_book ($1);
 800                 book->paper_ = 0;
 801                 book->scores_ = SCM_EOL;
 802                 book->bookparts_ = SCM_EOL;
 803         }
 804         ;
 805
 806 bookpart_block:
 807         BOOKPART '{' bookpart_body '}' {
 808                 $$ = $3;
 809                 unsmob_book ($$)->origin ()->set_spot (@$);
 810                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
 811         }
 812         ;
 813
 814 bookpart_body:
 815         {
 816                 Book *book = new Book;
 817                 $$ = book->unprotect ();
 818                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $$);
 819         }
 820         | BOOK_IDENTIFIER {
 821                 parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1);
 822         }
 823         | bookpart_body paper_block {
 824                 unsmob_book ($$)->paper_ = unsmob_output_def ($2);
 825         }
 826         | bookpart_body score_block {
 827                 SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
 828                 scm_call_2 (proc, $1, $2);
 829         }
 830         | bookpart_body composite_music {
 831                 SCM proc = parser->lexer_->lookup_identifier ("bookpart-music-handler");
 832                 scm_call_3 (proc, parser->self_scm (), $1, $2);
 833         }
 834         | bookpart_body full_markup {
 835                 SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
 836                 scm_call_2 (proc, $1, scm_list_1 ($2));
 837         }
 838         | bookpart_body full_markup_list {
 839                 SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
 840                 scm_call_2 (proc, $1, $2);
 841         }
 842         | bookpart_body SCM_TOKEN {
 843                 // Evaluate and ignore #xxx, as opposed to \xxx
 844                 parser->lexer_->eval_scm_token ($2);
 845         }
 846         | bookpart_body embedded_scm_active
 847         {
 848                 SCM out = SCM_UNDEFINED;
 849                 if (Text_interface::is_markup ($2))
 850                         out = scm_list_1 ($2);
 851                 else if (Text_interface::is_markup_list ($2))
 852                         out = $2;
 853                 if (scm_is_pair (out))
 854                 {
 855                         SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
 856                         scm_call_2 (proc, $1, out);
 857                 } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
 858                         parser->parser_error (@2, _("bad expression type"));
 859         }
 860         | bookpart_body
 861         {
 862                 Book *book = unsmob_book ($1);
 863                 if (!ly_is_module (book->header_))
 864                         book->header_ = ly_make_module (false);
 865                 parser->lexer_->add_scope (book->header_);
 866         } lilypond_header
 867         | bookpart_body error {
 868                 Book *book = unsmob_book ($1);
 869                 book->paper_ = 0;
 870                 book->scores_ = SCM_EOL;
 871         }
 872         ;
 873
 874 score_block:
 875         SCORE '{' score_body '}'        {
 876                 $$ = $3;
 877         }
 878         ;
 879
 880 score_body:
 881         music {
 882                 SCM scorify = ly_lily_module_constant ("scorify-music");
 883                 $$ = scm_call_2 (scorify, $1, parser->self_scm ());
 884
 885                 unsmob_score ($$)->origin ()->set_spot (@$);
 886         }
 887         | embedded_scm_active {
 888                 Score *score;
 889                 if (unsmob_score ($1))
 890                         score = new Score (*unsmob_score ($1));
 891                 else {
 892                         score = new Score;
 893                         parser->parser_error (@1, _("score expected"));
 894                 }
 895                 unsmob_score ($$)->origin ()->set_spot (@$);
 896                 $$ = score->unprotect ();
 897         }
 898         | score_body
 899         {
 900                 Score *score = unsmob_score ($1);
 901                 if (!ly_is_module (score->get_header ()))
 902                         score->set_header (ly_make_module (false));
 903                 parser->lexer_->add_scope (score->get_header ());
 904         } lilypond_header
 905         | score_body output_def {
 906                 Output_def *od = unsmob_output_def ($2);
 907                 if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
 908                 {
 909                         parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
 910
 911                 }
 912                 else
 913                 {
 914                         unsmob_score ($1)->add_output_def (od);
 915                 }
 916         }
 917         | score_body error {
 918                 unsmob_score ($$)->error_found_ = true;
 919         }
 920         ;
 921
 922
 923 /*
 924         OUTPUT DEF
 925 */
 926
 927 paper_block:
 928         output_def {
 929                 Output_def *od = unsmob_output_def ($1);
 930
 931                 if (od->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T)
 932                 {
 933                         parser->parser_error (@1, _ ("need \\paper for paper block"));
 934                         $$ = get_paper (parser)->unprotect ();
 935                 }
 936         }
 937         ;
 938
 939
 940 output_def:
 941         output_def_body '}' {
 942                 $$ = $1;
 943
 944                 parser->lexer_->remove_scope ();
 945                 parser->lexer_->pop_state ();
 946         }
 947         ;
 948
 949 output_def_head:
 950         PAPER {
 951                 Output_def *p = get_paper (parser);
 952                 p->input_origin_ = @$;
 953                 parser->lexer_->add_scope (p->scope_);
 954                 $$ = p->unprotect ();
 955         }
 956         | MIDI    {
 957                 Output_def *p = get_midi (parser);
 958                 $$ = p->unprotect ();
 959                 parser->lexer_->add_scope (p->scope_);
 960         }
 961         | LAYOUT        {
 962                 Output_def *p = get_layout (parser);
 963
 964                 parser->lexer_->add_scope (p->scope_);
 965                 $$ = p->unprotect ();
 966         }
 967         ;
 968
 969 output_def_head_with_mode_switch:
 970         output_def_head {
 971                 parser->lexer_->push_initial_state ();
 972                 $$ = $1;
 973         }
 974         ;
 975
 976 // We need this weird nonterminal because both music as well as a
 977 // context definition can start with \context and the difference is
 978 // only apparent after looking at the next token.  If it is '{', there
 979 // is still time to escape from notes mode.
 980
 981 music_or_context_def:
 982         music_arg
 983         | context_def_spec_block
 984         ;
 985
 986 output_def_body:
 987         output_def_head_with_mode_switch '{' {
 988                 $$ = $1;
 989                 unsmob_output_def ($$)->input_origin_.set_spot (@$);
 990         }
 991         | output_def_head_with_mode_switch '{' OUTPUT_DEF_IDENTIFIER    {
 992                 Output_def *o = unsmob_output_def ($3);
 993                 o->input_origin_.set_spot (@$);
 994                 $$ = o->self_scm ();
 995                 parser->lexer_->remove_scope ();
 996                 parser->lexer_->add_scope (o->scope_);
 997         }
 998         | output_def_body assignment  {
 999
1000         }
1001         | output_def_body embedded_scm  {
1002
1003         }
1004         | output_def_body
1005         {
1006                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
1007                 parser->lexer_->push_note_state (nn);
1008         } music_or_context_def
1009         {
1010                 parser->lexer_->pop_state ();
1011                 if (unsmob_context_def ($3))
1012                         assign_context_def (unsmob_output_def ($1), $3);
1013                 else {
1014
1015                         SCM proc = parser->lexer_->lookup_identifier
1016                                      ("output-def-music-handler");
1017                         scm_call_3 (proc, parser->self_scm (),
1018                                     $1, $3);
1019                 }
1020         }
1021         | output_def_body error {
1022
1023         }
1024         ;
1025
1026 tempo_event:
1027         TEMPO steno_duration '=' tempo_range    {
1028                 $$ = MAKE_SYNTAX ("tempo", @$, SCM_EOL, $2, $4);
1029         }
1030         | TEMPO scalar steno_duration '=' tempo_range   {
1031                 $$ = MAKE_SYNTAX ("tempo", @$, $2, $3, $5);
1032         }
1033         | TEMPO scalar {
1034                 $$ = MAKE_SYNTAX ("tempo", @$, $2);
1035         } %prec ':'
1036         ;
1037
1038 /*
1039 The representation of a  list is reversed to have efficient append.  */
1040
1041 music_list:
1042         /* empty */ {
1043                 $$ = SCM_EOL;
1044         }
1045         | music_list music_embedded {
1046                 if (unsmob_music ($2))
1047                         $$ = scm_cons ($2, $1);
1048         }
1049         | music_list error {
1050                 Music *m = MY_MAKE_MUSIC("Music", @$);
1051                 // ugh. code dup
1052                 m->set_property ("error-found", SCM_BOOL_T);
1053                 $$ = scm_cons (m->self_scm (), $1);
1054                 m->unprotect (); /* UGH */
1055         }
1056         ;
1057
1058 braced_music_list:
1059         '{' music_list '}'
1060         {
1061                 $$ = scm_reverse_x ($2, SCM_EOL);
1062         }
1063         ;
1064
1065 music:  music_arg
1066         | lyric_element_music
1067         ;
1068
1069 music_embedded:
1070         music
1071         {
1072                 if (unsmob_music ($1)->is_mus_type ("post-event")) {
1073                         parser->parser_error (@1, _ ("unexpected post-event"));
1074                         $$ = SCM_UNSPECIFIED;
1075                 }
1076         }
1077         | music_embedded_backup
1078         {
1079                 $$ = $1;
1080         }
1081         | music_embedded_backup BACKUP lyric_element_music
1082         {
1083                 $$ = $3;
1084         }
1085         | multiplied_duration post_events
1086         {
1087                 Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
1088
1089                 parser->default_duration_ = *unsmob_duration ($1);
1090                 n->set_property ("duration", $1);
1091
1092                 if (scm_is_pair ($2))
1093                         n->set_property ("articulations",
1094                                          scm_reverse_x ($2, SCM_EOL));
1095                 $$ = n->unprotect ();
1096         }
1097         ;
1098
1099 music_embedded_backup:
1100         embedded_scm
1101         {
1102                 if (scm_is_eq ($1, SCM_UNSPECIFIED))
1103                         $$ = $1;
1104                 else if (Music *m = unsmob_music ($1)) {
1105                         if (m->is_mus_type ("post-event")) {
1106                                 parser->parser_error
1107                                         (@1, _ ("unexpected post-event"));
1108                                 $$ = SCM_UNSPECIFIED;
1109                         } else
1110                                 $$ = $1;
1111                 } else if (parser->lexer_->is_lyric_state ()
1112                            && Text_interface::is_markup ($1))
1113                         MYBACKUP (LYRIC_ELEMENT, $1, @1);
1114                 else {
1115                         @$.warning (_ ("Ignoring non-music expression"));
1116                         $$ = $1;
1117                 }
1118         }
1119         ;
1120
1121 music_arg:
1122         simple_music
1123         {
1124                 $$ = make_music_from_simple (parser, @1, $1);
1125                 if (!unsmob_music ($$))
1126                 {
1127                         parser->parser_error (@1, _ ("music expected"));
1128                         $$ = MAKE_SYNTAX ("void-music", @$);
1129                 }
1130         }
1131         | composite_music %prec COMPOSITE
1132         ;
1133
1134 music_assign:
1135         simple_music
1136         | composite_music %prec COMPOSITE
1137         ;
1138
1139 repeated_music:
1140         REPEAT simple_string unsigned_number music
1141         {
1142                 $$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, SCM_EOL);
1143         }
1144         | REPEAT_IDENTIFIER music
1145         {
1146                 $$ = MAKE_SYNTAX ("repeat", @$, scm_car ($1), scm_cdr ($1),
1147                                   $2, SCM_EOL);
1148         }
1149         | REPEAT simple_string unsigned_number music ALTERNATIVE braced_music_list
1150         {
1151                 $$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, $6);
1152         }
1153         | REPEAT_IDENTIFIER music ALTERNATIVE braced_music_list
1154         {
1155                 $$ = MAKE_SYNTAX ("repeat", @$, scm_car ($1), scm_cdr ($1),
1156                                   $2, $4);
1157         }
1158         ;
1159
1160 sequential_music:
1161         SEQUENTIAL braced_music_list {
1162                 $$ = MAKE_SYNTAX ("sequential-music", @$, $2);
1163         }
1164         | braced_music_list {
1165                 $$ = MAKE_SYNTAX ("sequential-music", @$, $1);
1166         }
1167         ;
1168
1169 simultaneous_music:
1170         SIMULTANEOUS braced_music_list {
1171                 $$ = MAKE_SYNTAX ("simultaneous-music", @$, $2);
1172         }
1173         | DOUBLE_ANGLE_OPEN music_list DOUBLE_ANGLE_CLOSE       {
1174                 $$ = MAKE_SYNTAX ("simultaneous-music", @$, scm_reverse_x ($2, SCM_EOL));
1175         }
1176         ;
1177
1178 simple_music:
1179         event_chord
1180         | music_property_def
1181         | context_change
1182         ;
1183
1184 context_modification:
1185         WITH
1186         {
1187                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
1188                 parser->lexer_->push_note_state (nn);
1189         } '{' context_mod_list '}'
1190         {
1191                 parser->lexer_->pop_state ();
1192                 $$ = $4;
1193         }
1194         | WITH CONTEXT_MOD_IDENTIFIER
1195         {
1196                 $$ = $2;
1197         }
1198         | CONTEXT_MOD_IDENTIFIER
1199         {
1200                 $$ = $1;
1201         }
1202         | WITH context_modification_arg
1203         {
1204                 if (unsmob_music ($2)) {
1205                         SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
1206                         $2 = scm_call_2 (proc, parser->self_scm (), $2);
1207                 }
1208                 if (unsmob_context_mod ($2))
1209                         $$ = $2;
1210                 else {
1211                         parser->parser_error (@2, _ ("not a context mod"));
1212                         $$ = Context_mod ().smobbed_copy ();
1213                 }
1214         }
1215         ;
1216
1217 context_modification_arg:
1218         embedded_scm_closed
1219         | MUSIC_IDENTIFIER
1220         ;
1221
1222 optional_context_mod:
1223         /**/ {
1224             $$ = SCM_EOL;
1225         }
1226         | context_modification
1227         {
1228               $$ = $1;
1229         }
1230         ;
1231
1232 context_mod_list:
1233         /**/ {
1234             $$ = Context_mod ().smobbed_copy ();
1235         }
1236         | context_mod_list context_mod  {
1237                 if (!SCM_UNBNDP ($2))
1238                         unsmob_context_mod ($1)->add_context_mod ($2);
1239         }
1240         | context_mod_list CONTEXT_MOD_IDENTIFIER {
1241                  Context_mod *md = unsmob_context_mod ($2);
1242                  if (md)
1243                      unsmob_context_mod ($1)->add_context_mods (md->get_mods ());
1244         }
1245         | context_mod_list context_mod_embedded {
1246                 unsmob_context_mod ($1)->add_context_mods
1247                         (unsmob_context_mod ($2)->get_mods ());
1248         }
1249         ;
1250
1251 composite_music:
1252         complex_music
1253         | music_bare
1254         ;
1255
1256 /* Music that can be parsed without lookahead */
1257 closed_music:
1258         music_bare
1259         | complex_music_prefix closed_music
1260         {
1261                 $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
1262         }
1263         | music_function_call_closed
1264         ;
1265
1266 music_bare:
1267         mode_changed_music
1268         | MUSIC_IDENTIFIER
1269         | grouped_music_list
1270         ;
1271
1272 grouped_music_list:
1273         simultaneous_music              { $$ = $1; }
1274         | sequential_music              { $$ = $1; }
1275         ;
1276
1277 /* Function argument lists are arguably the most complex part in the
1278  * parser.  They are pretty tricky to understand because of the way
1279  * they are processed, and because of optional arguments that can be
1280  * omitted.  When there are several optional arguments in a row,
1281  * omitting one automatically omits all following arguments.  Optional
1282  * arguments can only be omitted when either
1283  *
1284  * a) the omission is explicitly started with \default
1285  * b) the omission is implicitly started by an argument not matching
1286  *    its predicate, and there is a mandatory argument later that can
1287  *    "catch" the argument that does not fit.
1288  *
1289  * When argument parsing starts, the lexer pushes EXPECT_SCM tokens
1290  * (corresponding to mandatory arguments and having a predicate
1291  * function as semantic value) or EXPECT_OPTIONAL EXPECT_SCM (where
1292  * the semantic value of the EXPECT_OPTIONAL token is the default to
1293  * use when the optional argument is omitted, and EXPECT_SCM again has
1294  * the argument predicate as semantic value) in reverse order to the
1295  * parser, followed by EXPECT_NO_MORE_ARGS.  The argument list is then
1296  * processed inside-out while actual tokens are consumed.
1297  *
1298  * This means that the argument list tokens determine the actions
1299  * taken as they arrive.  The structure of the argument list is known
1300  * to the parser and stored in its parse stack when the first argument
1301  * is being parsed.  What the parser does not know is which predicates
1302  * will match and whether or not \default will be appearing in the
1303  * argument list, and where.
1304  *
1305  * Many of the basic nonterminals used for argument list scanning come
1306  * in a "normal" and a "closed" flavor.  A closed expression is one
1307  * that can be parsed without a lookahead token.  That makes it
1308  * feasible for an optional argument that may need to be skipped:
1309  * skipping can only be accomplished by pushing back the token into
1310  * the lexer, and that only works when there is no lookahead token.
1311  *
1312  * Sequences of 0 or more optional arguments are scanned using either
1313  * function_arglist_backup or function_arglist_nonbackup.  The first
1314  * is used when optional arguments are followed by at least one
1315  * mandatory argument: in that case optional arguments may be skipped
1316  * by either a false predicate (in which case the expression will be
1317  * pushed back as one or more tokens, preceded by a BACKUP token) or
1318  * by using \default.
1319  *
1320  * If optional arguments are at the end of the argument list, they are
1321  * instead scanned using function_arglist_nonbackup: here the only
1322  * manner to enter into skipping of optional arguments is the use of
1323  * \default.
1324  *
1325  * The argument list of a normal function call is parsed using
1326  * function_arglist.  The part of an argument list before a mandatory
1327  * argument is parsed using function_arglist_optional.
1328  *
1329  * The difference is that leading optional arguments are scanned using
1330  * function_arglist_nonbackup and function_arglist_backup,
1331  * respectively.
1332  *
1333  * Most other details are obvious in the rules themselves.
1334  *
1335  */
1336
1337 function_arglist_nonbackup_common:
1338         EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
1339         {
1340                 $$ = check_scheme_arg (parser, @4, $4, $3, $2);
1341         }
1342         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
1343         {
1344                 SCM n = scm_difference ($5, SCM_UNDEFINED);
1345                 if (scm_is_true (scm_call_1 ($2, n)))
1346                         $$ = scm_cons (n, $3);
1347                 else {
1348                         Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
1349                         t->set_property ("digit", $5);
1350                         $$ = check_scheme_arg (parser, @4, t->unprotect (),
1351                                                $3, $2, n);
1352                 }
1353
1354         }
1355         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
1356         {
1357                 $$ = check_scheme_arg (parser, @4,
1358                                        scm_difference ($5, SCM_UNDEFINED),
1359                                        $3, $2);
1360         }
1361         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
1362         {
1363                 $$ = check_scheme_arg (parser, @4,
1364                                        scm_difference ($5, SCM_UNDEFINED),
1365                                        $3, $2);
1366         }
1367         ;
1368
1369 function_arglist_closed_nonbackup:
1370         function_arglist_nonbackup_common
1371         | function_arglist_closed_common
1372         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg_closed
1373         {
1374                 $$ = check_scheme_arg (parser, @4, $4, $3, $2);
1375         }
1376         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_closed
1377         {
1378                 $$ = check_scheme_arg (parser, @4, $4, $3, $2);
1379         }
1380         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
1381         {
1382                 $$ = check_scheme_arg (parser, @4,
1383                                        try_string_variants ($2, $4),
1384                                        $3, $2, $4);
1385         }
1386         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
1387         {
1388                 $$ = check_scheme_arg (parser, @4,
1389                                        try_string_variants ($2, $4),
1390                                        $3, $2, $4);
1391         }
1392         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
1393         {
1394                 $$ = check_scheme_arg (parser, @4, $4, $3, $2);
1395         }
1396         ;
1397
1398 symbol_list_arg:
1399         SYMBOL_LIST
1400         | SYMBOL_LIST '.' symbol_list_rev
1401         {
1402                 $$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
1403         }
1404         ;
1405
1406 symbol_list_rev:
1407         symbol_list_part
1408         | symbol_list_rev '.' symbol_list_part
1409         {
1410                 $$ = scm_append_x (scm_list_2 ($3, $1));
1411         }
1412         ;
1413
1414 // symbol_list_part delivers elements in reverse copy.
1415
1416 symbol_list_part:
1417         symbol_list_element
1418         {
1419                 SCM sym_l_p = ly_lily_module_constant ("symbol-list?");
1420                 $$ = try_string_variants (sym_l_p, $1);
1421                 if (SCM_UNBNDP ($$)) {
1422                         parser->parser_error (@1, _("not a symbol"));
1423                         $$ = SCM_EOL;
1424                 } else
1425                         $$ = scm_reverse ($$);
1426         }
1427         ;
1428
1429
1430 symbol_list_element:
1431         STRING
1432         | embedded_scm_bare
1433         ;
1434
1435
1436 function_arglist_nonbackup:
1437         function_arglist_nonbackup_common
1438         | function_arglist_common
1439         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg
1440         {
1441                 if (scm_is_true (scm_call_1 ($2, $4)))
1442                         $$ = scm_cons ($4, $3);
1443                 else
1444                         $$ = check_scheme_arg (parser, @4,
1445                                                make_music_from_simple
1446                                                (parser, @4, $4),
1447                                                $3, $2);
1448         }
1449         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
1450         {
1451                 $$ = check_scheme_arg (parser, @4, $4, $3, $2);
1452         }
1453         | function_arglist_nonbackup_reparse REPARSE duration_length
1454         {
1455                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1456         }
1457         | function_arglist_nonbackup_reparse REPARSE bare_number_common
1458         {
1459                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1460         }
1461         | function_arglist_nonbackup_reparse REPARSE SCM_ARG
1462         {
1463                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1464         }
1465         | function_arglist_nonbackup_reparse REPARSE lyric_element_music
1466         {
1467                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1468         }
1469         | function_arglist_nonbackup_reparse REPARSE symbol_list_arg
1470         {
1471                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1472         }
1473         ;
1474
1475 function_arglist_nonbackup_reparse:
1476         EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
1477         {
1478                 $$ = $3;
1479                 SCM res = try_string_variants ($2, $4);
1480                 if (!SCM_UNBNDP (res))
1481                         if (scm_is_pair (res))
1482                                 MYREPARSE (@4, $2, SYMBOL_LIST, res);
1483                         else
1484                                 MYREPARSE (@4, $2, SCM_ARG, res);
1485                 else if (scm_is_true
1486                          (scm_call_1
1487                           ($2, make_music_from_simple
1488                            (parser, @4, $4))))
1489                         MYREPARSE (@4, $2, STRING, $4);
1490                 else
1491                         MYREPARSE (@4, $2, SCM_ARG, $4);
1492         }
1493         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
1494         {
1495                 $$ = $3;
1496                 SCM res = try_string_variants ($2, $4);
1497                 if (!SCM_UNBNDP (res))
1498                         if (scm_is_pair (res))
1499                                 MYREPARSE (@4, $2, SYMBOL_LIST, res);
1500                         else
1501                                 MYREPARSE (@4, $2, SCM_ARG, res);
1502                 else if (scm_is_true
1503                          (scm_call_1
1504                           ($2, make_music_from_simple
1505                            (parser, @4, $4))))
1506                         MYREPARSE (@4, $2, STRING, $4);
1507                 else
1508                         MYREPARSE (@4, $2, SCM_ARG, $4);
1509         }
1510         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
1511         {
1512                 $$ = $3;
1513                 if (scm_is_true (scm_call_1 ($2, $4)))
1514                         MYREPARSE (@4, $2, SCM_ARG, $4);
1515                 else if (scm_is_true
1516                          (scm_call_1
1517                           ($2, make_music_from_simple
1518                            (parser, @4, $4))))
1519                         MYREPARSE (@4, $2, STRING, $4);
1520                 else
1521                         MYREPARSE (@4, $2, SCM_ARG, $4);
1522         }
1523         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup UNSIGNED
1524         {
1525                 $$ = $3;
1526                 if (scm_is_true (scm_call_1 ($2, $4)))
1527                         MYREPARSE (@4, $2, REAL, $4);
1528                 else {
1529                         SCM d = make_duration ($4);
1530                         if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($2, d)))
1531                                 MYREPARSE (@4, $2, REAL, $4); // trigger error
1532                         else
1533                                 MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
1534                 }
1535         }
1536         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup DURATION_IDENTIFIER {
1537                 $$ = $3;
1538                 MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
1539         }
1540         ;
1541
1542
1543 function_arglist_backup:
1544         function_arglist_common
1545         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg_closed
1546         {
1547                 if (scm_is_true (scm_call_1 ($2, $4)))
1548                 {
1549                         $$ = scm_cons ($4, $3);
1550                 } else {
1551                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1552                         MYBACKUP (SCM_ARG, $4, @4);
1553                 }
1554         }
1555         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REPEAT simple_string unsigned_number
1556         {
1557                 $4 = MAKE_SYNTAX ("repeat", @4, $5, $6,
1558                                   MY_MAKE_MUSIC ("Music", @4)->unprotect (),
1559                                   SCM_EOL);
1560                 if (scm_is_true (scm_call_1 ($2, $4)))
1561                 {
1562                         $$ = $3;
1563                         MYREPARSE (@4, $2, REPEAT_IDENTIFIER, scm_cons ($5, $6));
1564                 } else {
1565                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1566                         MYBACKUP (REPEAT_IDENTIFIER, scm_cons ($5, $6), @4);
1567                 }
1568         }
1569         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup chord_body
1570         {
1571                 if (scm_is_true (scm_call_1 ($2, $4)))
1572                 {
1573                         $$ = $3;
1574                         MYREPARSE (@4, $2, CHORD_BODY_IDENTIFIER, $4);
1575                 } else {
1576                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1577                         MYBACKUP (CHORD_BODY_IDENTIFIER, $4, @4);
1578                 }
1579         }
1580         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
1581         {
1582                 if (scm_is_true (scm_call_1 ($2, $4)))
1583                 {
1584                         $$ = scm_cons ($4, $3);
1585                 } else {
1586                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1587                         MYBACKUP (EVENT_IDENTIFIER, $4, @4);
1588                 }
1589         }
1590         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup full_markup
1591         {
1592                 if (scm_is_true (scm_call_1 ($2, $4)))
1593                         $$ = scm_cons ($4, $3);
1594                 else {
1595                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1596                         MYBACKUP (LYRIC_ELEMENT, $4, @4);
1597                 }
1598         }
1599         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup UNSIGNED
1600         {
1601                 if (scm_is_true (scm_call_1 ($2, $4)))
1602                 {
1603                         MYREPARSE (@4, $2, REAL, $4);
1604                         $$ = $3;
1605                 } else {
1606                         SCM d = make_duration ($4);
1607                         if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($2, d)))
1608                         {
1609                                 $$ = scm_cons (loc_on_music (@3, $1), $3);
1610                                 MYBACKUP (UNSIGNED, $4, @4);
1611                         } else {
1612                                 MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
1613                                 $$ = $3;
1614                         }
1615                 }
1616         }
1617         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REAL
1618         {
1619                 if (scm_is_true (scm_call_1 ($2, $4)))
1620                 {
1621                         $$ = $3;
1622                         MYREPARSE (@4, $2, REAL, $4);
1623                 } else {
1624                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1625                         MYBACKUP (REAL, $4, @4);
1626                 }
1627         }
1628         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NUMBER_IDENTIFIER
1629         {
1630                 if (scm_is_true (scm_call_1 ($2, $4)))
1631                 {
1632                         $$ = scm_cons ($4, $3);
1633                 } else {
1634                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1635                         MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
1636                 }
1637         }
1638         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' UNSIGNED
1639         {
1640                 SCM n = scm_difference ($5, SCM_UNDEFINED);
1641                 if (scm_is_true (scm_call_1 ($2, n))) {
1642                         $$ = $3;
1643                         MYREPARSE (@5, $2, REAL, n);
1644                 } else {
1645                         Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
1646                         t->set_property ("digit", $5);
1647                         $$ = t->unprotect ();
1648                         if (scm_is_true (scm_call_1 ($2, $$)))
1649                                 $$ = scm_cons ($$, $3);
1650                         else {
1651                                 $$ = scm_cons (loc_on_music (@3, $1), $3);
1652                                 MYBACKUP (UNSIGNED, $5, @5);
1653                                 parser->lexer_->push_extra_token ('-');
1654                         }
1655                 }
1656
1657         }
1658         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' REAL
1659         {
1660                 SCM n = scm_difference ($5, SCM_UNDEFINED);
1661                 if (scm_is_true (scm_call_1 ($2, n))) {
1662                         MYREPARSE (@5, $2, REAL, n);
1663                         $$ = $3;
1664                 } else {
1665                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1666                         MYBACKUP (REAL, n, @5);
1667                 }
1668         }
1669         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' NUMBER_IDENTIFIER
1670         {
1671                 SCM n = scm_difference ($5, SCM_UNDEFINED);
1672                 if (scm_is_true (scm_call_1 ($2, n))) {
1673                         $$ = scm_cons (n, $3);
1674                 } else {
1675                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1676                         MYBACKUP (NUMBER_IDENTIFIER, n, @5);
1677                 }
1678         }
1679         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup PITCH_IDENTIFIER
1680         {
1681                 if (scm_is_true (scm_call_1 ($2, $4)))
1682                 {
1683                         $$ = scm_cons ($4, $3);
1684                 } else {
1685                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1686                         MYBACKUP (PITCH_IDENTIFIER, $4, @4);
1687                 }
1688         }
1689         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NOTENAME_PITCH
1690         {
1691                 if (scm_is_true (scm_call_1 ($2, $4)))
1692                 {
1693                         MYREPARSE (@4, $2, NOTENAME_PITCH, $4);
1694                         $$ = $3;
1695                 } else {
1696                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1697                         MYBACKUP (NOTENAME_PITCH, $4, @4);
1698                 }
1699         }
1700         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup TONICNAME_PITCH
1701         {
1702                 if (scm_is_true (scm_call_1 ($2, $4)))
1703                 {
1704                         MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
1705                         $$ = $3;
1706                 } else {
1707                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1708                         MYBACKUP (TONICNAME_PITCH, $4, @4);
1709                 }
1710         }
1711         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
1712         {
1713                 if (scm_is_true (scm_call_1 ($2, $4)))
1714                 {
1715                         MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
1716                         $$ = $3;
1717                 } else {
1718                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1719                         MYBACKUP (DURATION_IDENTIFIER, $4, @4);
1720                 }
1721         }
1722         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup SCM_IDENTIFIER
1723         {
1724                 SCM res = try_string_variants ($2, $4);
1725                 if (!SCM_UNBNDP (res))
1726                         if (scm_is_pair (res)) {
1727                                 $$ = $3;
1728                                 MYREPARSE (@4, $2, SYMBOL_LIST, res);
1729                         }
1730                         else
1731                                 $$ = scm_cons (res, $3);
1732                 else {
1733                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1734                         MYBACKUP (SCM_IDENTIFIER, $4, @4);
1735                 }
1736         }
1737         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup STRING
1738         {
1739                 SCM res = try_string_variants ($2, $4);
1740                 if (!SCM_UNBNDP (res))
1741                         if (scm_is_pair (res)) {
1742                                 $$ = $3;
1743                                 MYREPARSE (@4, $2, SYMBOL_LIST, res);
1744                         }
1745                         else
1746                                 $$ = scm_cons (res, $3);
1747                 else {
1748                         $$ = scm_cons (loc_on_music (@3, $1), $3);
1749                         MYBACKUP (STRING, $4, @4);
1750                 }
1751         }
1752         | function_arglist_backup REPARSE music_assign
1753         {
1754                 if (scm_is_true (scm_call_1 ($2, $3)))
1755                         $$ = scm_cons ($3, $1);
1756                 else
1757                         $$ = check_scheme_arg (parser, @3,
1758                                                make_music_from_simple
1759                                                (parser, @3, $3),
1760                                                $1, $2);
1761         }
1762         | function_arglist_backup REPARSE bare_number_common
1763         {
1764                 $$ = check_scheme_arg (parser, @3,
1765                                        $3, $1, $2);
1766         }
1767         | function_arglist_backup REPARSE duration_length
1768         {
1769                 $$ = check_scheme_arg (parser, @3,
1770                                        $3, $1, $2);
1771         }
1772         | function_arglist_backup REPARSE symbol_list_arg
1773         {
1774                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1775         }
1776         ;
1777
1778 function_arglist:
1779         function_arglist_nonbackup
1780         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
1781         {
1782                 $$ = scm_cons (loc_on_music (@4, $1), $3);
1783         }
1784         ;
1785
1786 function_arglist_skip_nonbackup:
1787         function_arglist_nonbackup
1788         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
1789         {
1790                 $$ = scm_cons (loc_on_music (@3, $1), $3);
1791         }
1792         ;
1793
1794 function_arglist_common:
1795         EXPECT_NO_MORE_ARGS {
1796                 $$ = SCM_EOL;
1797         }
1798         | EXPECT_SCM function_arglist_optional embedded_scm_arg
1799         {
1800                 if (scm_is_true (scm_call_1 ($1, $3)))
1801                         $$ = scm_cons ($3, $2);
1802                 else
1803                         $$ = check_scheme_arg (parser, @3,
1804                                                make_music_from_simple
1805                                                (parser, @3, $3),
1806                                                $2, $1);
1807         }
1808         | EXPECT_SCM function_arglist_optional bare_number_common
1809         {
1810                 $$ = check_scheme_arg (parser, @3,
1811                                        $3, $2, $1);
1812         }
1813         | EXPECT_SCM function_arglist_optional post_event_nofinger
1814         {
1815                 $$ = check_scheme_arg (parser, @3,
1816                                        $3, $2, $1);
1817         }
1818         | EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
1819         {
1820                 SCM n = scm_difference ($4, SCM_UNDEFINED);
1821                 $$ = check_scheme_arg (parser, @4, n, $2, $1);
1822         }
1823         | function_arglist_common_reparse REPARSE SCM_ARG
1824         {
1825                 $$ = check_scheme_arg (parser, @3,
1826                                        $3, $1, $2);
1827         }
1828         | function_arglist_common_reparse REPARSE lyric_element_music
1829         {
1830                 $$ = check_scheme_arg (parser, @3,
1831                                        $3, $1, $2);
1832         }
1833         | function_arglist_common_reparse REPARSE bare_number_common
1834         {
1835                 $$ = check_scheme_arg (parser, @3,
1836                                        $3, $1, $2);
1837         }
1838         | function_arglist_common_reparse REPARSE duration_length
1839         {
1840                 $$ = check_scheme_arg (parser, @3,
1841                                        $3, $1, $2);
1842         }
1843         | function_arglist_common_reparse REPARSE symbol_list_arg
1844         {
1845                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1846         }
1847         ;
1848
1849 function_arglist_common_reparse:
1850         EXPECT_SCM function_arglist_optional SCM_IDENTIFIER
1851         {
1852                 $$ = $2;
1853                 SCM res = try_string_variants ($1, $3);
1854                 if (!SCM_UNBNDP (res))
1855                         if (scm_is_pair (res))
1856                                 MYREPARSE (@3, $1, SYMBOL_LIST, res);
1857                         else
1858                                 MYREPARSE (@3, $1, SCM_ARG, res);
1859                 else if (scm_is_true
1860                          (scm_call_1
1861                           ($1, make_music_from_simple (parser, @3, $3))))
1862                         MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
1863                 else
1864                         // This is going to flag a syntax error, we
1865                         // know the predicate to be false.
1866                         MYREPARSE (@3, $1, SCM_ARG, $3);
1867         }
1868         | EXPECT_SCM function_arglist_optional STRING
1869         {
1870                 $$ = $2;
1871                 SCM res = try_string_variants ($1, $3);
1872                 if (!SCM_UNBNDP (res))
1873                         if (scm_is_pair (res))
1874                                 MYREPARSE (@3, $1, SYMBOL_LIST, res);
1875                         else
1876                                 MYREPARSE (@3, $1, SCM_ARG, res);
1877                 else if (scm_is_true
1878                          (scm_call_1
1879                           ($1, make_music_from_simple (parser, @3, $3))))
1880                         MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
1881                 else
1882                         // This is going to flag a syntax error, we
1883                         // know the predicate to be false.
1884                         MYREPARSE (@3, $1, SCM_ARG, $3);
1885         }
1886         | EXPECT_SCM function_arglist_optional full_markup
1887         {
1888                 $$ = $2;
1889                 if (scm_is_true (scm_call_1 ($1, $3)))
1890                         MYREPARSE (@3, $1, SCM_ARG, $3);
1891                 else if (scm_is_true
1892                          (scm_call_1
1893                           ($1, make_music_from_simple (parser, @3, $3))))
1894                         MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
1895                 else
1896                         // This is going to flag a syntax error, we
1897                         // know the predicate to be false.
1898                         MYREPARSE (@3, $1, SCM_ARG, $3);
1899         }
1900         | EXPECT_SCM function_arglist_optional UNSIGNED
1901         {
1902                 $$ = $2;
1903                 if (scm_is_true (scm_call_1 ($1, $3)))
1904                         MYREPARSE (@3, $1, REAL, $3);
1905                 else {
1906                         SCM d = make_duration ($3);
1907                         if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($1, d)))
1908                                 MYREPARSE (@3, $1, REAL, $3);
1909                         else
1910                                 MYREPARSE (@3, $1, DURATION_IDENTIFIER, d);
1911                 }
1912         }
1913         | EXPECT_SCM function_arglist_optional DURATION_IDENTIFIER
1914         {
1915                 $$ = $2;
1916                 MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
1917         }
1918         | EXPECT_SCM function_arglist_optional '-' UNSIGNED
1919         {
1920                 $$ = $2;
1921                 SCM n = scm_difference ($4, SCM_UNDEFINED);
1922                 if (scm_is_true (scm_call_1 ($1, n)))
1923                         MYREPARSE (@4, $1, REAL, n);
1924                 else {
1925                         Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4);
1926                         t->set_property ("digit", $4);
1927                         SCM m = t->unprotect ();
1928                         if (scm_is_true (scm_call_1 ($1, m)))
1929                                 MYREPARSE (@4, $1, SCM_ARG, m);
1930                         else
1931                                 MYREPARSE (@4, $1, SCM_ARG, $4);
1932                 }
1933
1934         }
1935         | EXPECT_SCM function_arglist_optional '-' REAL
1936         {
1937                 $$ = $2;
1938                 SCM n = scm_difference ($4, SCM_UNDEFINED);
1939                 MYREPARSE (@4, $1, REAL, n);
1940         }
1941         ;
1942
1943 function_arglist_closed:
1944         function_arglist_closed_nonbackup
1945         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
1946         {
1947                 $$ = scm_cons (loc_on_music (@4, $1), $3);
1948         }
1949         ;
1950
1951 function_arglist_closed_common:
1952         EXPECT_NO_MORE_ARGS {
1953                 $$ = SCM_EOL;
1954         }
1955         | EXPECT_SCM function_arglist_optional embedded_scm_arg_closed
1956         {
1957                 $$ = check_scheme_arg (parser, @3,
1958                                        $3, $2, $1);
1959         }
1960         | EXPECT_SCM function_arglist_optional bare_number_common_closed
1961         {
1962                 $$ = check_scheme_arg (parser, @3,
1963                                        $3, $2, $1);
1964         }
1965         | EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
1966         {
1967                 $$ = check_scheme_arg (parser, @3,
1968                                        scm_difference ($4, SCM_UNDEFINED),
1969                                        $2, $1);
1970         }
1971         | EXPECT_SCM function_arglist_optional post_event_nofinger
1972         {
1973                 $$ = check_scheme_arg (parser, @3,
1974                                        $3, $2, $1);
1975         }
1976         | function_arglist_common_reparse REPARSE SCM_ARG
1977         {
1978                 $$ = check_scheme_arg (parser, @3,
1979                                        $3, $1, $2);
1980         }
1981         | function_arglist_common_reparse REPARSE bare_number_common_closed
1982         {
1983                 $$ = check_scheme_arg (parser, @3,
1984                                        $3, $1, $2);
1985         }
1986         | function_arglist_common_reparse REPARSE symbol_list_arg
1987         {
1988                 $$ = check_scheme_arg (parser, @3, $3, $1, $2);
1989         }
1990         ;
1991
1992 function_arglist_optional:
1993         function_arglist_backup
1994         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
1995         {
1996                 $$ = scm_cons (loc_on_music (@4, $1), $3);
1997         }
1998         | function_arglist_skip_backup BACKUP
1999         ;
2000
2001 function_arglist_skip_backup:
2002         function_arglist_backup
2003         | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
2004         {
2005                 $$ = scm_cons (loc_on_music (@3, $1), $3);
2006         }
2007         ;
2008
2009 embedded_scm_closed:
2010         embedded_scm_bare
2011         | scm_function_call_closed
2012         ;
2013
2014 embedded_scm_arg_closed:
2015         embedded_scm_bare_arg
2016         | scm_function_call_closed
2017         | closed_music
2018         ;
2019
2020 scm_function_call_closed:
2021         SCM_FUNCTION function_arglist_closed {
2022                 $$ = MAKE_SYNTAX ("music-function", @$,
2023                                          $1, $2);
2024         }
2025         ;
2026
2027 music_function_call:
2028         MUSIC_FUNCTION function_arglist {
2029                 $$ = MAKE_SYNTAX ("music-function", @$,
2030                                          $1, $2);
2031         }
2032         ;
2033
2034
2035 optional_id:
2036         /**/ { $$ = SCM_EOL; }
2037         | '=' simple_string {
2038                 $$ = $2;
2039         }
2040         ;
2041
2042 complex_music:
2043         music_function_call
2044         | repeated_music                { $$ = $1; }
2045         | re_rhythmed_music     { $$ = $1; }
2046         | complex_music_prefix music
2047         {
2048                 $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
2049         }
2050         ;
2051
2052 complex_music_prefix:
2053         CONTEXT symbol optional_id optional_context_mod {
2054                 Context_mod *ctxmod = unsmob_context_mod ($4);
2055                 SCM mods = SCM_EOL;
2056                 if (ctxmod)
2057                         mods = ctxmod->get_mods ();
2058                 $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F);
2059         }
2060         | NEWCONTEXT symbol optional_id optional_context_mod {
2061                 Context_mod *ctxmod = unsmob_context_mod ($4);
2062                 SCM mods = SCM_EOL;
2063                 if (ctxmod)
2064                         mods = ctxmod->get_mods ();
2065                 $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_T);
2066         }
2067         ;
2068
2069 mode_changed_music:
2070         mode_changing_head grouped_music_list {
2071                 if ($1 == ly_symbol2scm ("chords"))
2072                 {
2073                   $$ = MAKE_SYNTAX ("unrelativable-music", @$, $2);
2074                 }
2075                 else
2076                 {
2077                   $$ = $2;
2078                 }
2079                 parser->lexer_->pop_state ();
2080         }
2081         | mode_changing_head_with_context optional_context_mod grouped_music_list {
2082                 Context_mod *ctxmod = unsmob_context_mod ($2);
2083                 SCM mods = SCM_EOL;
2084                 if (ctxmod)
2085                         mods = ctxmod->get_mods ();
2086                 $$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3);
2087                 if ($1 == ly_symbol2scm ("ChordNames"))
2088                 {
2089                   $$ = MAKE_SYNTAX ("unrelativable-music", @$, $$);
2090                 }
2091                 parser->lexer_->pop_state ();
2092         }
2093         ;
2094
2095 mode_changing_head:
2096         NOTEMODE {
2097                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
2098                 parser->lexer_->push_note_state (nn);
2099
2100                 $$ = ly_symbol2scm ("notes");
2101         }
2102         | DRUMMODE
2103                 {
2104                 SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
2105                 parser->lexer_->push_note_state (nn);
2106
2107                 $$ = ly_symbol2scm ("drums");
2108         }
2109         | FIGUREMODE {
2110                 parser->lexer_->push_figuredbass_state ();
2111
2112                 $$ = ly_symbol2scm ("figures");
2113         }
2114         | CHORDMODE {
2115                 SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
2116                 parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
2117                 nn = parser->lexer_->lookup_identifier ("pitchnames");
2118                 parser->lexer_->push_chord_state (nn);
2119                 $$ = ly_symbol2scm ("chords");
2120
2121         }
2122         | LYRICMODE
2123                 { parser->lexer_->push_lyric_state ();
2124                 $$ = ly_symbol2scm ("lyrics");
2125         }
2126         ;
2127
2128 mode_changing_head_with_context:
2129         DRUMS {
2130                 SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
2131                 parser->lexer_->push_note_state (nn);
2132
2133                 $$ = ly_symbol2scm ("DrumStaff");
2134         }
2135         | FIGURES {
2136                 parser->lexer_->push_figuredbass_state ();
2137
2138                 $$ = ly_symbol2scm ("FiguredBass");
2139         }
2140         | CHORDS {
2141                 SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
2142                 parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
2143                 nn = parser->lexer_->lookup_identifier ("pitchnames");
2144                 parser->lexer_->push_chord_state (nn);
2145                 $$ = ly_symbol2scm ("ChordNames");
2146         }
2147         | LYRICS
2148                 { parser->lexer_->push_lyric_state ();
2149                 $$ = ly_symbol2scm ("Lyrics");
2150         }
2151         ;
2152
2153 new_lyrics:
2154         ADDLYRICS { parser->lexer_->push_lyric_state (); }
2155         /*cont */
2156         composite_music {
2157         /* Can also use music at the expensive of two S/Rs similar to
2158            \repeat \alternative */
2159                 parser->lexer_->pop_state ();
2160
2161                 $$ = scm_cons ($3, SCM_EOL);
2162         }
2163         | new_lyrics ADDLYRICS {
2164                 parser->lexer_->push_lyric_state ();
2165         } composite_music {
2166                 parser->lexer_->pop_state ();
2167                 $$ = scm_cons ($4, $1);
2168         }
2169         ;
2170
2171 re_rhythmed_music:
2172         composite_music new_lyrics {
2173                 $$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL));
2174         } %prec COMPOSITE
2175         | LYRICSTO simple_string {
2176                 parser->lexer_->push_lyric_state ();
2177         } music {
2178                 parser->lexer_->pop_state ();
2179                 $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, $4);
2180         }
2181         ;
2182
2183 context_change:
2184         CHANGE STRING '=' STRING  {
2185                 $$ = MAKE_SYNTAX ("context-change", @$, scm_string_to_symbol ($2), $4);
2186         }
2187         ;
2188
2189
2190 property_path:
2191         symbol_list_rev  {
2192                 $$ = scm_reverse_x ($1, SCM_EOL);
2193         }
2194         | symbol_list_rev property_path {
2195                 $$ = scm_reverse_x ($1, $2);
2196         }
2197         ;
2198
2199 property_operation:
2200         symbol '=' scalar {
2201                 $$ = scm_list_3 (ly_symbol2scm ("assign"), $1, $3);
2202         }
2203         | UNSET symbol {
2204                 $$ = scm_list_2 (ly_symbol2scm ("unset"), $2);
2205         }
2206         | OVERRIDE property_path '=' scalar {
2207                 if (scm_ilength ($2) < 2) {
2208                         parser->parser_error (@2, _("bad grob property path"));
2209                         $$ = SCM_UNDEFINED;
2210                 } else {
2211                         $$ = scm_cons (ly_symbol2scm ("push"),
2212                                        scm_cons2 (scm_car ($2),
2213                                                   $4,
2214                                                   scm_cdr ($2)));
2215                 }
2216         }
2217         | REVERT revert_arg {
2218                 $$ = scm_cons (ly_symbol2scm ("pop"), $2);
2219         }
2220         ;
2221
2222 // This is all quite awkward for the sake of substantial backward
2223 // compatibility while at the same time allowing a more "natural" form
2224 // of specification not separating grob specification from grob
2225 // property path.  The purpose of this definition of revert_arg is to
2226 // allow the symbol list which specifies grob and property to revert
2227 // to be optionally be split into two parts after the grob (which in
2228 // this case is just the first element of the list).  symbol_list_part
2229 // is only one path component, but it can be parsed without lookahead,
2230 // so we can follow it with a synthetic BACKUP token when needed.  If
2231 // the first symbol_list_part already contains multiple elements (only
2232 // possible if a Scheme expression provides them), we just parse for
2233 // additional elements introduced by '.', which is what the
2234 // SYMBOL_LIST backup in connection with the immediately following
2235 // rule using symbol_list_arg does.
2236 //
2237 // As long as we don't have our coffers filled with both grob and at
2238 // least one grob property specification, the rest of the required
2239 // symbol list chain may be provided either with or without a leading
2240 // dot.  This is for both allowing the traditional
2241 // \revert Accidental #'color
2242 // as well as well as the "naive" form
2243 // \revert Accidental.color
2244
2245 revert_arg:
2246         revert_arg_backup BACKUP symbol_list_arg
2247         {
2248                 $$ = $3;
2249         }
2250         ;
2251
2252 revert_arg_backup:
2253         revert_arg_part
2254         {
2255                 if (scm_is_null ($1)
2256                     || scm_is_null (scm_cdr ($1)))
2257                         MYBACKUP (SCM_ARG, $1, @1);
2258                 else
2259                         MYBACKUP (SYMBOL_LIST, scm_reverse_x ($1, SCM_EOL), @1);
2260         }
2261         ;
2262
2263 // revert_arg_part delivers results in reverse
2264 revert_arg_part:
2265         symbol_list_part
2266         | revert_arg_backup BACKUP SCM_ARG '.' symbol_list_part
2267         {
2268                 $$ = scm_append_x (scm_list_2 ($5, $3));
2269         }
2270         | revert_arg_backup BACKUP SCM_ARG symbol_list_part
2271         {
2272                 $$ = scm_append_x (scm_list_2 ($4, $3));
2273         }
2274         ;
2275
2276 context_def_mod:
2277         CONSISTS { $$ = ly_symbol2scm ("consists"); }
2278         | REMOVE { $$ = ly_symbol2scm ("remove"); }
2279
2280         | ACCEPTS { $$ = ly_symbol2scm ("accepts"); }
2281         | DEFAULTCHILD { $$ = ly_symbol2scm ("default-child"); }
2282         | DENIES { $$ = ly_symbol2scm ("denies"); }
2283
2284         | ALIAS { $$ = ly_symbol2scm ("alias"); }
2285         | TYPE { $$ = ly_symbol2scm ("translator-type"); }
2286         | DESCRIPTION { $$ = ly_symbol2scm ("description"); }
2287         | NAME { $$ = ly_symbol2scm ("context-name"); }
2288         ;
2289
2290 context_mod:
2291         property_operation { $$ = $1; }
2292         | context_def_mod STRING {
2293                 $$ = scm_list_2 ($1, $2);
2294         }
2295         | context_def_mod embedded_scm
2296         {
2297                 if (!scm_is_string ($2)
2298                     && ly_symbol2scm ("consists") != $1
2299                     && ly_symbol2scm ("remove") != $1)
2300                 {
2301                         $$ = SCM_EOL;
2302                         parser->parser_error (@1, _ ("only \\consists and \\remove take non-string argument."));
2303                 }
2304                 else
2305                 {
2306                         $$ = scm_list_2 ($1, $2);
2307                 }
2308         }
2309         ;
2310
2311 // If defined, at least two members.
2312 grob_prop_spec:
2313         symbol_list_rev
2314         {
2315                 SCM l = scm_reverse_x ($1, SCM_EOL);
2316                 if (scm_is_pair (l)
2317                     && to_boolean
2318                     (scm_object_property (scm_car (l),
2319                                           ly_symbol2scm ("is-grob?"))))
2320                         l = scm_cons (ly_symbol2scm ("Bottom"), l);
2321                 if (scm_is_null (l) || scm_is_null (scm_cdr (l))) {
2322                         parser->parser_error (@1, _ ("bad grob property path"));
2323                         l = SCM_UNDEFINED;
2324                 }
2325                 $$ = l;
2326         }
2327         ;
2328
2329 // If defined, at least three members
2330 grob_prop_path:
2331         grob_prop_spec
2332         {
2333                 if (!SCM_UNBNDP ($1) && scm_is_null (scm_cddr ($1)))
2334                 {
2335                         parser->parser_error (@1, _ ("bad grob property path"));
2336                         $$ = SCM_UNDEFINED;
2337                 }
2338         }
2339         | grob_prop_spec property_path
2340         {
2341                 if (!SCM_UNBNDP ($1)) {
2342                         $$ = scm_append_x (scm_list_2 ($1, $2));
2343                         if (scm_is_null (scm_cddr ($$))) {
2344                                 parser->parser_error (@$, _ ("bad grob property path"));
2345                                 $$ = SCM_UNDEFINED;
2346                         }
2347                 }
2348
2349         }
2350         ;
2351
2352 // Exactly two elements or undefined
2353 context_prop_spec:
2354         symbol_list_rev
2355         {
2356                 SCM l = scm_reverse_x ($1, SCM_EOL);
2357                 switch (scm_ilength (l)) {
2358                 case 1:
2359                         l = scm_cons (ly_symbol2scm ("Bottom"), l);
2360                 case 2:
2361                         break;
2362                 default:
2363                         parser->parser_error (@1, _ ("bad context property path"));
2364                         l = SCM_UNDEFINED;
2365                 }
2366                 $$ = l;
2367         }
2368         ;
2369
2370 simple_music_property_def:
2371         OVERRIDE grob_prop_path '=' scalar {
2372                 if (SCM_UNBNDP ($2))
2373                         $$ = SCM_UNDEFINED;
2374                 else {
2375                         $$ = scm_list_5 (scm_car ($2),
2376                                          ly_symbol2scm ("OverrideProperty"),
2377                                          scm_cadr ($2),
2378                                          $4,
2379                                          scm_cddr ($2));
2380                 }
2381         }
2382         | REVERT simple_revert_context revert_arg {
2383                 $$ = scm_list_4 ($2,
2384                                  ly_symbol2scm ("RevertProperty"),
2385                                  scm_car ($3),
2386                                  scm_cdr ($3));
2387         }
2388         | SET context_prop_spec '=' scalar {
2389                 if (SCM_UNBNDP ($2))
2390                         $$ = SCM_UNDEFINED;
2391                 else
2392                         $$ = scm_list_4 (scm_car ($2),
2393                                          ly_symbol2scm ("PropertySet"),
2394                                          scm_cadr ($2),
2395                                          $4);
2396         }
2397         | UNSET context_prop_spec {
2398                 if (SCM_UNBNDP ($2))
2399                         $$ = SCM_UNDEFINED;
2400                 else
2401                         $$ = scm_list_3 (scm_car ($2),
2402                                          ly_symbol2scm ("PropertyUnset"),
2403                                          scm_cadr ($2));
2404         }
2405         ;
2406
2407
2408 // This is all quite awkward for the sake of substantial backward
2409 // compatibility while at the same time allowing a more "natural" form
2410 // of specification not separating grob specification from grob
2411 // property path.  The purpose of this definition of
2412 // simple_revert_context is to allow the symbol list which specifies
2413 // grob and property to revert to be optionally be split into two
2414 // parts after the grob (which may be preceded by a context
2415 // specification, a case which we distinguish by checking whether the
2416 // first symbol is a valid grob symbol instead).
2417 //
2418 // See revert_arg above for the main work horse of this arrangement.
2419 // simple_revert_context just caters for the context and delegates the
2420 // rest of the job to revert_arg.
2421
2422 simple_revert_context:
2423         symbol_list_part
2424         {
2425                 $1 = scm_reverse_x ($1, SCM_EOL);
2426                 if (scm_is_null ($1)
2427                     || to_boolean
2428                     (scm_object_property (scm_car ($1),
2429                                           ly_symbol2scm ("is-grob?")))) {
2430                         $$ = ly_symbol2scm ("Bottom");
2431                         parser->lexer_->push_extra_token (SCM_IDENTIFIER, $1);
2432                 } else {
2433                         $$ = scm_car ($1);
2434                         parser->lexer_->push_extra_token (SCM_IDENTIFIER,
2435                                                           scm_cdr ($1));
2436                 }
2437         }
2438         ;
2439
2440 music_property_def:
2441         simple_music_property_def {
2442                 if (SCM_UNBNDP ($1))
2443                         $$ = MAKE_SYNTAX ("void-music", @1);
2444                 else
2445                         $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons2 (parser->self_scm (), make_input (@$), $1));
2446         }
2447         ;
2448
2449 string:
2450         STRING {
2451                 $$ = $1;
2452         }
2453         | full_markup
2454         ;
2455
2456 simple_string: STRING {
2457                 $$ = $1;
2458         }
2459         | embedded_scm_bare
2460         {
2461                 if (scm_is_string ($1)) {
2462                         $$ = $1;
2463                 } else {
2464                         parser->parser_error (@1, (_ ("simple string expected")));
2465                         $$ = scm_string (SCM_EOL);
2466                 }
2467         }
2468         ;
2469
2470 symbol:
2471         STRING {
2472                 $$ = scm_string_to_symbol ($1);
2473         }
2474         | embedded_scm_bare
2475         {
2476                 // This is a bit of overkill but makes the same
2477                 // routine responsible for all symbol interpretations.
2478                 $$ = try_string_variants (ly_lily_module_constant ("symbol?"),
2479                                           $1);
2480                 if (SCM_UNBNDP ($$))
2481                 {
2482                         parser->parser_error (@1, (_ ("symbol expected")));
2483                         // Generate a unique symbol in case it is used
2484                         // for an assignment or similar
2485                         $$ = scm_make_symbol (ly_string2scm ("undefined"));
2486                 }
2487         }
2488         ;
2489
2490 scalar:
2491         embedded_scm_arg
2492         | SCM_IDENTIFIER
2493         | bare_number
2494         // The following is a rather defensive variant of admitting
2495         // negative numbers: the grammar would permit number_factor or
2496         // even number_expression.  However, function arguments allow
2497         // only this simple kind of negative number, so to have things
2498         // like \tweak and \override behave reasonably similar, it
2499         // makes sense to rule out things like -- which are rather an
2500         // accent in function argument contexts.
2501         | '-' bare_number
2502         {
2503                 $$ = scm_difference ($2, SCM_UNDEFINED);
2504         }
2505         | STRING
2506         | full_markup
2507         ;
2508
2509 event_chord:
2510         simple_element post_events {
2511                 // Let the rhythmic music iterator sort this mess out.
2512                 if (scm_is_pair ($2)) {
2513                         $$ = make_music_from_simple (parser, @1, $1);
2514                         if (unsmob_music ($$))
2515                                 unsmob_music ($$)->set_property ("articulations",
2516                                                                  scm_reverse_x ($2, SCM_EOL));
2517                         else
2518                         {
2519                                 parser->parser_error (@1, _("music expected"));
2520                                 $$ = MAKE_SYNTAX ("void-music", @1);
2521                         }
2522                 }
2523         } %prec ':'
2524         | simple_chord_elements post_events     {
2525                 SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
2526
2527                 Input i;
2528                 /* why is this giving wrong start location? -ns
2529                  * i = @$; */
2530                 i.set_location (@1, @2);
2531                 $$ = MAKE_SYNTAX ("event-chord", i, elts);
2532         } %prec ':'
2533         | CHORD_REPETITION optional_notemode_duration post_events {
2534                 Input i;
2535                 i.set_location (@1, @3);
2536                 $$ = MAKE_SYNTAX ("repetition-chord", i,
2537                                   $2, scm_reverse_x ($3, SCM_EOL));
2538         } %prec ':'
2539         | MULTI_MEASURE_REST optional_notemode_duration post_events {
2540                 Input i;
2541                 i.set_location (@1, @3);
2542                 $$ = MAKE_SYNTAX ("multi-measure-rest", i, $2,
2543                                   scm_reverse_x ($3, SCM_EOL));
2544         } %prec ':'
2545         | command_element
2546         | note_chord_element
2547         ;
2548
2549
2550 note_chord_element:
2551         chord_body optional_notemode_duration post_events
2552         {
2553                 Music *m = unsmob_music ($1);
2554                 SCM dur = unsmob_duration ($2)->smobbed_copy ();
2555                 SCM es = m->get_property ("elements");
2556                 SCM postevs = scm_reverse_x ($3, SCM_EOL);
2557
2558                 for (SCM s = es; scm_is_pair (s); s = scm_cdr (s))
2559                   unsmob_music (scm_car (s))->set_property ("duration", dur);
2560                 es = ly_append2 (es, postevs);
2561
2562                 m-> set_property ("elements", es);
2563                 m->set_spot (@$);
2564                 $$ = m->self_scm ();
2565         } %prec ':'
2566         ;
2567
2568 chord_body:
2569         ANGLE_OPEN chord_body_elements ANGLE_CLOSE
2570         {
2571                 $$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
2572         }
2573         | CHORD_BODY_IDENTIFIER
2574         ;
2575
2576 chord_body_elements:
2577         /* empty */             { $$ = SCM_EOL; }
2578         | chord_body_elements chord_body_element {
2579                 if (!SCM_UNBNDP ($2))
2580                         $$ = scm_cons ($2, $1);
2581         }
2582         ;
2583
2584 chord_body_element:
2585         pitch exclamations questions octave_check post_events
2586         {
2587                 bool q = to_boolean ($3);
2588                 bool ex = to_boolean ($2);
2589                 SCM check = $4;
2590                 SCM post = $5;
2591
2592                 Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
2593                 n->set_property ("pitch", $1);
2594                 if (q)
2595                         n->set_property ("cautionary", SCM_BOOL_T);
2596                 if (ex || q)
2597                         n->set_property ("force-accidental", SCM_BOOL_T);
2598
2599                 if (scm_is_pair (post)) {
2600                         SCM arts = scm_reverse_x (post, SCM_EOL);
2601                         n->set_property ("articulations", arts);
2602                 }
2603                 if (scm_is_number (check))
2604                 {
2605                         int q = scm_to_int (check);
2606                         n->set_property ("absolute-octave", scm_from_int (q-1));
2607                 }
2608
2609                 $$ = n->unprotect ();
2610         }
2611         | DRUM_PITCH post_events {
2612                 Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
2613                 n->set_property ("drum-type", $1);
2614
2615                 if (scm_is_pair ($2)) {
2616                         SCM arts = scm_reverse_x ($2, SCM_EOL);
2617                         n->set_property ("articulations", arts);
2618                 }
2619                 $$ = n->unprotect ();
2620         }
2621         | music_function_chord_body
2622         {
2623                 Music *m = unsmob_music ($1);
2624
2625                 while (m && m->is_mus_type ("music-wrapper-music")) {
2626                         $$ = m->get_property ("element");
2627                         m = unsmob_music ($$);
2628                 }
2629
2630                 if (!(m && m->is_mus_type ("rhythmic-event"))) {
2631                         parser->parser_error (@$, _ ("not a rhythmic event"));
2632                         $$ = SCM_UNDEFINED;
2633                 }
2634         }
2635         ;
2636
2637 music_function_chord_body:
2638         music_function_call
2639         | MUSIC_IDENTIFIER
2640         ;
2641
2642 // Event functions may only take closed arglists, otherwise it would
2643 // not be clear whether a following postevent should be associated
2644 // with the last argument of the event function or with the expression
2645 // for which the function call acts itself as event.
2646
2647 music_function_call_closed:
2648         MUSIC_FUNCTION function_arglist_closed {
2649                 $$ = MAKE_SYNTAX ("music-function", @$,
2650                                          $1, $2);
2651         }
2652         ;
2653
2654 event_function_event:
2655         EVENT_FUNCTION function_arglist_closed {
2656                 $$ = MAKE_SYNTAX ("music-function", @$,
2657                                          $1, $2);
2658         }
2659         ;
2660
2661 command_element:
2662         command_event {
2663                 $$ = $1;
2664         }
2665         ;
2666
2667 command_event:
2668         tempo_event {
2669                 $$ = $1;
2670         }
2671         ;
2672
2673
2674 post_events:
2675         /* empty */ {
2676                 $$ = SCM_EOL;
2677         }
2678         | post_events post_event {
2679                 $$ = $1;
2680                 if (Music *m = unsmob_music ($2))
2681                 {
2682                         if (m->is_mus_type ("post-event-wrapper"))
2683                         {
2684                                 for (SCM p = m->get_property ("elements");
2685                                      scm_is_pair (p);
2686                                      p = scm_cdr (p))
2687                                 {
2688                                         $$ = scm_cons (scm_car (p), $$);
2689                                 }
2690                         } else {
2691                                 m->set_spot (@2);
2692                                 $$ = scm_cons ($2, $$);
2693                         }
2694                 }
2695         }
2696         ;
2697
2698 post_event_nofinger:
2699         direction_less_event {
2700                 $$ = $1;
2701         }
2702         | script_dir music_function_call_closed {
2703                 $$ = $2;
2704                 if (!unsmob_music ($2)->is_mus_type ("post-event")) {
2705                         parser->parser_error (@2, _ ("post-event expected"));
2706                         $$ = SCM_UNSPECIFIED;
2707                 } else if (!SCM_UNBNDP ($1))
2708                 {
2709                         unsmob_music ($$)->set_property ("direction", $1);
2710                 }
2711         }
2712         | HYPHEN {
2713                 if (!parser->lexer_->is_lyric_state ())
2714                         parser->parser_error (@1, _ ("have to be in Lyric mode for lyrics"));
2715                 $$ = MY_MAKE_MUSIC ("HyphenEvent", @$)->unprotect ();
2716         }
2717         | EXTENDER {
2718                 if (!parser->lexer_->is_lyric_state ())
2719                         parser->parser_error (@1, _ ("have to be in Lyric mode for lyrics"));
2720                 $$ = MY_MAKE_MUSIC ("ExtenderEvent", @$)->unprotect ();
2721         }
2722         | script_dir direction_reqd_event {
2723                 if (!SCM_UNBNDP ($1))
2724                 {
2725                         Music *m = unsmob_music ($2);
2726                         m->set_property ("direction", $1);
2727                 }
2728                 $$ = $2;
2729         }
2730         | script_dir direction_less_event {
2731                 if (!SCM_UNBNDP ($1))
2732                 {
2733                         Music *m = unsmob_music ($2);
2734                         m->set_property ("direction", $1);
2735                 }
2736                 $$ = $2;
2737         }
2738         | '^' fingering
2739         {
2740                 $$ = $2;
2741                 unsmob_music ($$)->set_property ("direction", scm_from_int (UP));
2742         }
2743         | '_' fingering
2744         {
2745                 $$ = $2;
2746                 unsmob_music ($$)->set_property ("direction", scm_from_int (DOWN));
2747         }
2748         ;
2749
2750 post_event:
2751         post_event_nofinger
2752         | '-' fingering {
2753                 $$ = $2;
2754         }
2755         ;
2756
2757 string_number_event:
2758         E_UNSIGNED {
2759                 Music *s = MY_MAKE_MUSIC ("StringNumberEvent", @$);
2760                 s->set_property ("string-number", $1);
2761                 $$ = s->unprotect ();
2762         }
2763         ;
2764
2765 direction_less_event:
2766         string_number_event
2767         | EVENT_IDENTIFIER      {
2768                 $$ = $1;
2769         }
2770         | tremolo_type  {
2771                Music *a = MY_MAKE_MUSIC ("TremoloEvent", @$);
2772                a->set_property ("tremolo-type", $1);
2773                $$ = a->unprotect ();
2774         }
2775         | event_function_event
2776         ;
2777
2778 direction_reqd_event:
2779         gen_text_def {
2780                 $$ = $1;
2781         }
2782         | script_abbreviation {
2783                 SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
2784                 Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
2785                 if (scm_is_string (s))
2786                         a->set_property ("articulation-type", s);
2787                 else parser->parser_error (@1, _ ("expecting string as script definition"));
2788                 $$ = a->unprotect ();
2789         }
2790         ;
2791
2792 octave_check:
2793         /**/ { $$ = SCM_EOL; }
2794         | '=' quotes { $$ = $2; }
2795         ;
2796
2797 quotes:
2798         /* empty */
2799         {
2800                 $$ = SCM_INUM0;
2801         }
2802         | sub_quotes
2803         | sup_quotes
2804         ;
2805
2806 sup_quotes:
2807         '\'' {
2808                 $$ = scm_from_int (1);
2809         }
2810         | sup_quotes '\'' {
2811                 $$ = scm_oneplus ($1);
2812         }
2813         ;
2814
2815 sub_quotes:
2816         ',' {
2817                 $$ = scm_from_int (-1);
2818         }
2819         | sub_quotes ',' {
2820                 $$ = scm_oneminus ($1);
2821         }
2822         ;
2823
2824 steno_pitch:
2825         NOTENAME_PITCH quotes {
2826                 if (!scm_is_eq (SCM_INUM0, $2))
2827                 {
2828                         Pitch p = *unsmob_pitch ($1);
2829                         p = p.transposed (Pitch (scm_to_int ($2),0,0));
2830                         $$ = p.smobbed_copy ();
2831                 }
2832         }
2833         ;
2834
2835 /*
2836 ugh. duplication
2837 */
2838
2839 steno_tonic_pitch:
2840         TONICNAME_PITCH quotes {
2841                 if (!scm_is_eq (SCM_INUM0, $2))
2842                 {
2843                         Pitch p = *unsmob_pitch ($1);
2844                         p = p.transposed (Pitch (scm_to_int ($2),0,0));
2845                         $$ = p.smobbed_copy ();
2846                 }
2847         }
2848         ;
2849
2850 pitch:
2851         steno_pitch
2852         | PITCH_IDENTIFIER
2853         ;
2854
2855 gen_text_def:
2856         full_markup {
2857                 Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
2858                 t->set_property ("text", $1);
2859                 $$ = t->unprotect ();
2860         }
2861         | STRING {
2862                 Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
2863                 t->set_property ("text",
2864                         make_simple_markup ($1));
2865                 $$ = t->unprotect ();
2866         }
2867         | embedded_scm_closed
2868         {
2869                 Music *m = unsmob_music ($1);
2870                 if (m && m->is_mus_type ("post-event"))
2871                         $$ = $1;
2872                 else if (Text_interface::is_markup ($1)) {
2873                         Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
2874                         t->set_property ("text", $1);
2875                         $$ = t->unprotect ();
2876                 } else
2877                         parser->parser_error (@1, _ ("not an articulation"));
2878         }
2879         ;
2880
2881 fingering:
2882         UNSIGNED {
2883                 Music *t = MY_MAKE_MUSIC ("FingeringEvent", @$);
2884                 t->set_property ("digit", $1);
2885                 $$ = t->unprotect ();
2886         }
2887         ;
2888
2889 script_abbreviation:
2890         '^'             {
2891                 $$ = scm_from_locale_string ("Hat");
2892         }
2893         | '+'           {
2894                 $$ = scm_from_locale_string ("Plus");
2895         }
2896         | '-'           {
2897                 $$ = scm_from_locale_string ("Dash");
2898         }
2899         | '!'           {
2900                 $$ = scm_from_locale_string ("Bang");
2901         }
2902         | ANGLE_CLOSE   {
2903                 $$ = scm_from_locale_string ("Larger");
2904         }
2905         | '.'           {
2906                 $$ = scm_from_locale_string ("Dot");
2907         }
2908         | '_' {
2909                 $$ = scm_from_locale_string ("Underscore");
2910         }
2911         ;
2912
2913 script_dir:
2914         '_'     { $$ = scm_from_int (DOWN); }
2915         | '^'   { $$ = scm_from_int (UP); }
2916         | '-'   { $$ = SCM_UNDEFINED; }
2917         ;
2918
2919 duration_length:
2920         multiplied_duration {
2921                 $$ = $1;
2922         }
2923         ;
2924
2925 maybe_notemode_duration:
2926         {
2927                 $$ = SCM_UNDEFINED;
2928         } %prec ':'
2929         | multiplied_duration   {
2930                 $$ = $1;
2931                 parser->default_duration_ = *unsmob_duration ($$);
2932         }
2933 ;
2934
2935
2936 optional_notemode_duration:
2937         maybe_notemode_duration
2938         {
2939                 if (SCM_UNBNDP ($$))
2940                         $$ = parser->default_duration_.smobbed_copy ();
2941         }
2942         ;
2943
2944 steno_duration:
2945         UNSIGNED dots           {
2946                 $$ = make_duration ($1, scm_to_int ($2));
2947                 if (SCM_UNBNDP ($$))
2948                 {
2949                         parser->parser_error (@1, _ ("not a duration"));
2950                         $$ = Duration ().smobbed_copy ();
2951                 }
2952         }
2953         | DURATION_IDENTIFIER dots      {
2954                 Duration *d = unsmob_duration ($1);
2955                 Duration k (d->duration_log (),
2956                             d->dot_count () + scm_to_int ($2));
2957                 k = k.compressed (d->factor ());
2958                 scm_remember_upto_here_1 ($1);
2959                 $$ = k.smobbed_copy ();
2960         }
2961         ;
2962
2963 multiplied_duration:
2964         steno_duration {
2965                 $$ = $1;
2966         }
2967         | multiplied_duration '*' UNSIGNED {
2968                 $$ = unsmob_duration ($$)->compressed (scm_to_int ($3)).smobbed_copy ();
2969         }
2970         | multiplied_duration '*' FRACTION {
2971                 Rational  m (scm_to_int (scm_car ($3)), scm_to_int (scm_cdr ($3)));
2972
2973                 $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
2974         }
2975         ;
2976
2977 dots:
2978         /* empty */     {
2979                 $$ = SCM_INUM0;
2980         }
2981         | dots '.' {
2982                 $$ = scm_oneplus ($1);
2983         }
2984         ;
2985
2986 tremolo_type:
2987         ':'     {
2988                 $$ = SCM_INUM0;
2989         }
2990         | ':' UNSIGNED {
2991                 if (SCM_UNBNDP (make_duration ($2)))
2992                         parser->parser_error (@2, _ ("not a duration"));
2993                 $$ = $2;
2994         }
2995         ;
2996
2997 bass_number:
2998         UNSIGNED { $$ = $1; }
2999         | STRING { $$ = $1; }
3000         | full_markup { $$ = $1; }
3001         | embedded_scm_bare
3002         {
3003                 // as an integer, it needs to be non-negative, and otherwise
3004                 // it needs to be suitable as a markup.
3005                 if (scm_is_integer ($1)
3006                     ? scm_is_true (scm_negative_p ($1))
3007                     : !Text_interface::is_markup ($1))
3008                 {
3009                         parser->parser_error (@1, _ ("bass number expected"));
3010                         $$ = SCM_INUM0;
3011                 }
3012         }
3013         ;
3014
3015 figured_bass_alteration:
3016         '-'     { $$ = ly_rational2scm (FLAT_ALTERATION); }
3017         | '+'   { $$ = ly_rational2scm (SHARP_ALTERATION); }
3018         | '!'   { $$ = scm_from_int (0); }
3019         ;
3020
3021 bass_figure:
3022         FIGURE_SPACE {
3023                 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent", @$);
3024                 $$ = bfr->unprotect ();
3025         }
3026         | bass_number  {
3027                 Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent", @$);
3028                 $$ = bfr->self_scm ();
3029
3030                 if (scm_is_number ($1))
3031                         bfr->set_property ("figure", $1);
3032                 else if (Text_interface::is_markup ($1))
3033                         bfr->set_property ("text", $1);
3034
3035                 bfr->unprotect ();
3036         }
3037         | bass_figure ']' {
3038                 $$ = $1;
3039                 unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
3040         }
3041         | bass_figure figured_bass_alteration {
3042                 Music *m = unsmob_music ($1);
3043                 if (scm_to_double ($2)) {
3044                         SCM salter = m->get_property ("alteration");
3045                         SCM alter = scm_is_number (salter) ? salter : scm_from_int (0);
3046                         m->set_property ("alteration",
3047                                          scm_sum (alter, $2));
3048                 } else {
3049                         m->set_property ("alteration", scm_from_int (0));
3050                 }
3051         }
3052         | bass_figure figured_bass_modification  {
3053                 Music *m = unsmob_music ($1);
3054                 m->set_property ($2, SCM_BOOL_T);
3055         }
3056         ;
3057
3058
3059 figured_bass_modification:
3060         E_PLUS          {
3061                 $$ = ly_symbol2scm ("augmented");
3062         }
3063         | E_EXCLAMATION {
3064                 $$ = ly_symbol2scm ("no-continuation");
3065         }
3066         | '/'           {
3067                 $$ = ly_symbol2scm ("diminished");
3068         }
3069         | E_BACKSLASH {
3070                 $$ = ly_symbol2scm ("augmented-slash");
3071         }
3072         ;
3073
3074 br_bass_figure:
3075         bass_figure {
3076                 $$ = $1;
3077         }
3078         | '[' bass_figure {
3079                 $$ = $2;
3080                 unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
3081         }
3082         ;
3083
3084 figure_list:
3085         /**/            {
3086                 $$ = SCM_EOL;
3087         }
3088         | figure_list br_bass_figure {
3089                 $$ = scm_cons ($2, $1);
3090         }
3091         ;
3092
3093 figure_spec:
3094         FIGURE_OPEN figure_list FIGURE_CLOSE {
3095                 $$ = scm_reverse_x ($2, SCM_EOL);
3096         }
3097         ;
3098
3099
3100 optional_rest:
3101         /**/   { $$ = SCM_BOOL_F; }
3102         | REST { $$ = SCM_BOOL_T; }
3103         ;
3104
3105 simple_element:
3106         pitch exclamations questions octave_check maybe_notemode_duration optional_rest {
3107                 if (!parser->lexer_->is_note_state ())
3108                         parser->parser_error (@1, _ ("have to be in Note mode for notes"));
3109                 if (!SCM_UNBNDP ($2)
3110                     || !SCM_UNBNDP ($3)
3111                     || scm_is_number ($4)
3112                     || !SCM_UNBNDP ($5)
3113                     || scm_is_true ($6))
3114                 {
3115                         Music *n = 0;
3116                         if (scm_is_true ($6))
3117                                 n = MY_MAKE_MUSIC ("RestEvent", @$);
3118                         else
3119                                 n = MY_MAKE_MUSIC ("NoteEvent", @$);
3120
3121                         n->set_property ("pitch", $1);
3122                         if (SCM_UNBNDP ($5))
3123                                 n->set_property ("duration",
3124                                                  parser->default_duration_.smobbed_copy ());
3125                         else
3126                                 n->set_property ("duration", $5);
3127
3128                         if (scm_is_number ($4))
3129                         {
3130                                 int q = scm_to_int ($4);
3131                                 n->set_property ("absolute-octave", scm_from_int (q-1));
3132                         }
3133
3134                         if (to_boolean ($3))
3135                                 n->set_property ("cautionary", SCM_BOOL_T);
3136                         if (to_boolean ($2) || to_boolean ($3))
3137                                 n->set_property ("force-accidental", SCM_BOOL_T);
3138
3139                         $$ = n->unprotect ();
3140                 }
3141         }
3142         | DRUM_PITCH optional_notemode_duration {
3143                 Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
3144                 n->set_property ("duration", $2);
3145                 n->set_property ("drum-type", $1);
3146
3147                 $$ = n->unprotect ();
3148         }
3149         | RESTNAME optional_notemode_duration           {
3150                 Music *ev = 0;
3151                 if (ly_scm2string ($1) == "s") {
3152                         /* Space */
3153                         ev = MY_MAKE_MUSIC ("SkipEvent", @$);
3154                   }
3155                 else {
3156                         ev = MY_MAKE_MUSIC ("RestEvent", @$);
3157
3158                     }
3159                 ev->set_property ("duration", $2);
3160                 $$ = ev->unprotect ();
3161         }
3162         ;
3163
3164 simple_chord_elements:
3165         new_chord {
3166                 if (!parser->lexer_->is_chord_state ())
3167                         parser->parser_error (@1, _ ("have to be in Chord mode for chords"));
3168                 $$ = $1;
3169         }
3170         | figure_spec optional_notemode_duration {
3171                 for (SCM s = $1; scm_is_pair (s); s = scm_cdr (s))
3172                 {
3173                         unsmob_music (scm_car (s))->set_property ("duration", $2);
3174                 }
3175                 $$ = $1;
3176         }
3177         ;
3178
3179 lyric_element:
3180         full_markup {
3181                 if (!parser->lexer_->is_lyric_state ())
3182                         parser->parser_error (@1, _ ("markup outside of text script or \\lyricmode"));
3183                 $$ = $1;
3184         }
3185         | STRING {
3186                 if (!parser->lexer_->is_lyric_state ())
3187                         parser->parser_error (@1, _ ("unrecognized string, not in text script or \\lyricmode"));
3188                 $$ = $1;
3189         }
3190         | LYRIC_ELEMENT
3191         ;
3192
3193 lyric_element_music:
3194         lyric_element optional_notemode_duration post_events {
3195                 $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
3196                 if (scm_is_pair ($3))
3197                         unsmob_music ($$)->set_property
3198                                 ("articulations", scm_reverse_x ($3, SCM_EOL));
3199         } %prec ':'
3200         ;
3201
3202 new_chord:
3203         steno_tonic_pitch optional_notemode_duration   {
3204                 $$ = make_chord_elements (@$, $1, $2, SCM_EOL);
3205         }
3206         | steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
3207                 SCM its = scm_reverse_x ($4, SCM_EOL);
3208                 $$ = make_chord_elements (@$, $1, $2, scm_cons ($3, its));
3209         } %prec ':'
3210         ;
3211
3212 chord_items:
3213         /**/ {
3214                 $$ = SCM_EOL;
3215         }
3216         | chord_items chord_item {
3217                 $$ = scm_cons ($2, $$);
3218         }
3219         ;
3220
3221 chord_separator:
3222         CHORD_COLON {
3223                 $$ = ly_symbol2scm ("chord-colon");
3224         }
3225         | CHORD_CARET {
3226                 $$ = ly_symbol2scm ("chord-caret");
3227         }
3228         | CHORD_SLASH steno_tonic_pitch {
3229                 $$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2);
3230         }
3231         | CHORD_BASS steno_tonic_pitch {
3232                 $$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2);
3233         }
3234         ;
3235
3236 chord_item:
3237         chord_separator {
3238                 $$ = $1;
3239         }
3240         | step_numbers {
3241                 $$ = scm_reverse_x ($1, SCM_EOL);
3242         }
3243         | CHORD_MODIFIER  {
3244                 $$ = $1;
3245         }
3246         ;
3247
3248 step_numbers:
3249         step_number { $$ = scm_cons ($1, SCM_EOL); }
3250         | step_numbers '.' step_number {
3251                 $$ = scm_cons ($3, $$);
3252         }
3253         ;
3254
3255 step_number:
3256         UNSIGNED {
3257                 $$ = make_chord_step ($1, 0);
3258         }
3259         | UNSIGNED '+' {
3260                 $$ = make_chord_step ($1, SHARP_ALTERATION);
3261         }
3262         | UNSIGNED CHORD_MINUS {
3263                 $$ = make_chord_step ($1, FLAT_ALTERATION);
3264         }
3265         ;
3266
3267 tempo_range:
3268         UNSIGNED {
3269                 $$ = $1;
3270         }
3271         | UNSIGNED '-' UNSIGNED {
3272                 $$ = scm_cons ($1, $3);
3273         }
3274         ;
3275
3276 /*
3277         UTILITIES
3278
3279 TODO: should deprecate in favor of Scheme?
3280
3281  */
3282 number_expression:
3283         number_expression '+' number_term {
3284                 $$ = scm_sum ($1, $3);
3285         }
3286         | number_expression '-' number_term {
3287                 $$ = scm_difference ($1, $3);
3288         }
3289         | number_term
3290         ;
3291
3292 number_term:
3293         number_factor {
3294                 $$ = $1;
3295         }
3296         | number_factor '*' number_factor {
3297                 $$ = scm_product ($1, $3);
3298         }
3299         | number_factor '/' number_factor {
3300                 $$ = scm_divide ($1, $3);
3301         }
3302         ;
3303
3304 number_factor:
3305         '-'  number_factor { /* %prec UNARY_MINUS */
3306                 $$ = scm_difference ($2, SCM_UNDEFINED);
3307         }
3308         | bare_number
3309         ;
3310
3311 bare_number_common:
3312         bare_number_common_closed
3313         | REAL NUMBER_IDENTIFIER
3314         {
3315                 $$ = scm_product ($1, $2);
3316         }
3317         ;
3318
3319 bare_number_common_closed:
3320         REAL
3321         | NUMBER_IDENTIFIER
3322         ;
3323
3324 bare_number:
3325         bare_number_common
3326         | UNSIGNED
3327         | UNSIGNED NUMBER_IDENTIFIER    {
3328                 $$ = scm_product ($1, $2);
3329         }
3330         ;
3331
3332 bare_number_closed:
3333         UNSIGNED
3334         | bare_number_common_closed
3335         ;
3336
3337 unsigned_number:
3338         UNSIGNED
3339         | NUMBER_IDENTIFIER
3340         ;
3341
3342 exclamations:
3343                 { $$ = SCM_UNDEFINED; }
3344         | exclamations '!'
3345         {
3346                 if (SCM_UNBNDP ($1))
3347                         $$ = SCM_BOOL_T;
3348                 else
3349                         $$ = scm_not ($1);
3350         }
3351         ;
3352
3353 questions:
3354         { $$ = SCM_UNDEFINED; }
3355         | questions '?'
3356         {
3357                 if (SCM_UNBNDP ($1))
3358                         $$ = SCM_BOOL_T;
3359                 else
3360                         $$ = scm_not ($1);
3361         }
3362         ;
3363
3364 full_markup_list:
3365         MARKUPLIST
3366                 { parser->lexer_->push_markup_state (); }
3367         markup_list {
3368                 $$ = $3;
3369                 parser->lexer_->pop_state ();
3370         }
3371         ;
3372
3373 full_markup:
3374         MARKUP
3375                 { parser->lexer_->push_markup_state (); }
3376         markup_top {
3377                 $$ = $3;
3378                 parser->lexer_->pop_state ();
3379         }
3380         ;
3381
3382 markup_top:
3383         markup_list {
3384                 $$ = scm_list_2 (ly_lily_module_constant ("line-markup"),  $1);
3385         }
3386         | markup_head_1_list simple_markup
3387         {
3388                 $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
3389                                            @2, $1, scm_list_1 ($2)));
3390         }
3391         | simple_markup {
3392                 $$ = $1;
3393         }
3394         ;
3395
3396 markup_scm:
3397         embedded_scm_bare
3398         {
3399                 if (Text_interface::is_markup ($1))
3400                         MYBACKUP (MARKUP_IDENTIFIER, $1, @1);
3401                 else if (Text_interface::is_markup_list ($1))
3402                         MYBACKUP (MARKUPLIST_IDENTIFIER, $1, @1);
3403                 else {
3404                         parser->parser_error (@1, _ ("not a markup"));
3405                         MYBACKUP (MARKUP_IDENTIFIER, scm_string (SCM_EOL), @1);
3406                 }
3407         } BACKUP
3408         ;
3409
3410
3411 markup_list:
3412         markup_composed_list {
3413                 $$ = $1;
3414         }
3415         | markup_uncomposed_list
3416         ;
3417
3418 markup_uncomposed_list:
3419         markup_braced_list {
3420                 $$ = $1;
3421         }
3422         | markup_command_list {
3423                 $$ = scm_list_1 ($1);
3424         }
3425         | markup_scm MARKUPLIST_IDENTIFIER
3426         {
3427                 $$ = $2;
3428         }
3429         | SCORELINES {
3430                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
3431                 parser->lexer_->push_note_state (nn);
3432         } '{' score_body '}' {
3433                 $$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $4));
3434                 parser->lexer_->pop_state ();
3435         }
3436         ;
3437
3438 markup_composed_list:
3439         markup_head_1_list markup_uncomposed_list {
3440                 $$ = MAKE_SYNTAX ("composed-markup-list",
3441                                   @2, $1, $2);
3442         }
3443         ;
3444
3445 markup_braced_list:
3446         '{' markup_braced_list_body '}' {
3447                 $$ = scm_reverse_x ($2, SCM_EOL);
3448         }
3449         ;
3450
3451 markup_braced_list_body:
3452         /* empty */     {  $$ = SCM_EOL; }
3453         | markup_braced_list_body markup {
3454                 $$ = scm_cons ($2, $1);
3455         }
3456         | markup_braced_list_body markup_list {
3457                 $$ = scm_reverse_x ($2, $1);
3458         }
3459         ;
3460
3461 markup_command_list:
3462         MARKUP_LIST_FUNCTION markup_command_list_arguments {
3463           $$ = scm_cons ($1, scm_reverse_x($2, SCM_EOL));
3464         }
3465         ;
3466
3467 markup_command_basic_arguments:
3468         EXPECT_MARKUP_LIST markup_command_list_arguments markup_list {
3469           $$ = scm_cons ($3, $2);
3470         }
3471         | EXPECT_SCM markup_command_list_arguments embedded_scm_closed {
3472           $$ = check_scheme_arg (parser, @3, $3, $2, $1);
3473         }
3474         | EXPECT_NO_MORE_ARGS {
3475           $$ = SCM_EOL;
3476         }
3477         ;
3478
3479 markup_command_list_arguments:
3480         markup_command_basic_arguments { $$ = $1; }
3481         | EXPECT_MARKUP markup_command_list_arguments markup {
3482           $$ = scm_cons ($3, $2);
3483         }
3484         ;
3485
3486 markup_head_1_item:
3487         MARKUP_FUNCTION EXPECT_MARKUP markup_command_list_arguments {
3488           $$ = scm_cons ($1, scm_reverse_x ($3, SCM_EOL));
3489         }
3490         ;
3491
3492 markup_head_1_list:
3493         markup_head_1_item      {
3494                 $$ = scm_list_1 ($1);
3495         }
3496         | markup_head_1_list markup_head_1_item {
3497                 $$ = scm_cons ($2, $1);
3498         }
3499         ;
3500
3501 simple_markup:
3502         STRING {
3503                 $$ = make_simple_markup ($1);
3504         }
3505         | SCORE {
3506                 SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
3507                 parser->lexer_->push_note_state (nn);
3508         } '{' score_body '}' {
3509                 $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $4);
3510                 parser->lexer_->pop_state ();
3511         }
3512         | MARKUP_FUNCTION markup_command_basic_arguments {
3513                 $$ = scm_cons ($1, scm_reverse_x ($2, SCM_EOL));
3514         }
3515         | markup_scm MARKUP_IDENTIFIER
3516         {
3517                 $$ = $2;
3518         }
3519         ;
3520
3521 markup:
3522         markup_head_1_list simple_markup
3523         {
3524                 $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
3525                                            @2, $1, scm_list_1 ($2)));
3526         }
3527         | simple_markup {
3528                 $$ = $1;
3529         }
3530         ;
3531
3532 %%
3533
3534 void
3535 Lily_parser::set_yydebug (bool x)
3536 {
3537         yydebug = x;
3538 }
3539
3540 SCM
3541 Lily_parser::do_yyparse ()
3542 {
3543         SCM retval = SCM_UNDEFINED;
3544         yyparse (this, &retval);
3545         return retval;
3546 }
3547
3548
3549
3550
3551
3552 /*
3553
3554 It is a little strange to have this function in this file, but
3555 otherwise, we have to import music classes into the lexer.
3556
3557 */
3558 int
3559 Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
3560 {
3561         if (unsmob_book (sid)) {
3562                 Book *book =  unsmob_book (sid)->clone ();
3563                 *destination = book->self_scm ();
3564                 book->unprotect ();
3565
3566                 return BOOK_IDENTIFIER;
3567         } else if (scm_is_number (sid)) {
3568                 *destination = sid;
3569                 return NUMBER_IDENTIFIER;
3570         } else if (unsmob_context_def (sid)) {
3571                 Context_def *def= unsmob_context_def (sid)->clone ();
3572
3573                 *destination = def->self_scm ();
3574                 def->unprotect ();
3575
3576                 return CONTEXT_DEF_IDENTIFIER;
3577         } else if (unsmob_context_mod (sid)) {
3578                 *destination = unsmob_context_mod (sid)->smobbed_copy ();
3579
3580                 return CONTEXT_MOD_IDENTIFIER;
3581         } else if (Music *mus = unsmob_music (sid)) {
3582                 mus = mus->clone ();
3583                 *destination = mus->self_scm ();
3584                 bool is_event = mus->is_mus_type ("post-event");
3585                 mus->unprotect ();
3586                 return is_event ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
3587         } else if (unsmob_pitch (sid)) {
3588                 *destination = unsmob_pitch (sid)->smobbed_copy ();
3589                 return PITCH_IDENTIFIER;
3590         } else if (unsmob_duration (sid)) {
3591                 *destination = unsmob_duration (sid)->smobbed_copy ();
3592                 return DURATION_IDENTIFIER;
3593         } else if (unsmob_output_def (sid)) {
3594                 Output_def *p = unsmob_output_def (sid);
3595                 p = p->clone ();
3596
3597                 *destination = p->self_scm ();
3598                 p->unprotect ();
3599                 return OUTPUT_DEF_IDENTIFIER;
3600         }
3601
3602         return -1;
3603 }
3604
3605 SCM
3606 get_next_unique_context_id ()
3607 {
3608         return scm_from_locale_string ("$uniqueContextId");
3609 }
3610
3611
3612 SCM
3613 get_next_unique_lyrics_context_id ()
3614 {
3615         static int new_context_count;
3616         char s[128];
3617         snprintf (s, sizeof (s)-1, "uniqueContext%d", new_context_count++);
3618         return scm_from_locale_string (s);
3619 }
3620
3621 // check_scheme_arg checks one argument with a given predicate for use
3622 // in an argument list and throws a syntax error if it is unusable.
3623 // The argument is prepended to the argument list in any case.  After
3624 // throwing a syntax error, the argument list is terminated with #f as
3625 // its last cdr in order to mark it as uncallable while not losing
3626 // track of its total length.
3627 //
3628 // There are a few special considerations: if optional argument disp
3629 // is given (otherwise it defaults to SCM_UNDEFINED), it will be used
3630 // instead of arg in a prospective error message.  This is useful if
3631 // arg is not the actual argument but rather a transformation of it.
3632 //
3633 // If arg itself is SCM_UNDEFINED, the predicate is considered false
3634 // and an error message using disp is produced unconditionally.
3635
3636 SCM check_scheme_arg (Lily_parser *parser, Input loc,
3637                       SCM arg, SCM args, SCM pred, SCM disp)
3638 {
3639         if (SCM_UNBNDP (arg))
3640                 args = scm_cons (disp, args);
3641         else {
3642                 args = scm_cons (arg, args);
3643                 if (scm_is_true (scm_call_1 (pred, arg)))
3644                         return args;
3645         }
3646         scm_set_cdr_x (scm_last_pair (args), SCM_EOL);
3647         MAKE_SYNTAX ("argument-error", loc, scm_length (args), pred,
3648                      SCM_UNBNDP (disp) ? arg : disp);
3649         scm_set_cdr_x (scm_last_pair (args), SCM_BOOL_F);
3650         return args;
3651 }
3652
3653 SCM loc_on_music (Input loc, SCM arg)
3654 {
3655         if (Music *m = unsmob_music (arg))
3656         {
3657                 m = m->clone ();
3658                 m->set_spot (loc);
3659                 return m->unprotect ();
3660         }
3661         return arg;
3662 }
3663
3664 SCM
3665 try_string_variants (SCM pred, SCM str)
3666 {
3667         // a matching predicate is always ok
3668         if (scm_is_true (scm_call_1 (pred, str)))
3669                 return str;
3670         // a symbol may be interpreted as a list of symbols if it helps
3671         if (scm_is_symbol (str)) {
3672                 str = scm_list_1 (str);
3673                 if (scm_is_true (scm_call_1 (pred, str)))
3674                         return str;
3675                 return SCM_UNDEFINED;
3676         }
3677
3678         // If this cannot be a string representation of a symbol list,
3679         // we are through.
3680
3681         if (!is_regular_identifier (str, true))
3682                 return SCM_UNDEFINED;
3683
3684         str = scm_string_split (str, SCM_MAKE_CHAR ('.'));
3685         for (SCM p = str; scm_is_pair (p); p = scm_cdr (p))
3686                 scm_set_car_x (p, scm_string_to_symbol (scm_car (p)));
3687
3688         // Let's attempt the symbol list interpretation first.
3689
3690         if (scm_is_true (scm_call_1 (pred, str)))
3691                 return str;
3692
3693         // If there is just one symbol in the list, we might interpret
3694         // it as a single symbol
3695
3696         if (scm_is_null (scm_cdr (str)))
3697         {
3698                 str = scm_car (str);
3699                 if (scm_is_true (scm_call_1 (pred, str)))
3700                         return str;
3701         }
3702
3703         return SCM_UNDEFINED;
3704 }
3705
3706 bool
3707 is_regular_identifier (SCM id, bool multiple)
3708 {
3709   if (!scm_is_string (id))
3710           return false;
3711
3712   string str = ly_scm2string (id);
3713
3714   bool middle = false;
3715
3716   for (string::iterator it=str.begin(); it != str.end (); it++)
3717   {
3718           int c = *it & 0xff;
3719           if ((c >= 'a' && c <= 'z')
3720               || (c >= 'A' && c <= 'Z')
3721               || c > 0x7f)
3722                   middle = true;
3723           else if (middle && (c == '-' || c == '_' || (multiple && c == '.')))
3724                   middle = false;
3725           else
3726                   return false;
3727   }
3728   return middle;
3729 }
3730
3731 SCM
3732 make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
3733 {
3734         if (unsmob_music (simple))
3735                 return simple;
3736         if (parser->lexer_->is_note_state ()) {
3737                 if (scm_is_symbol (simple)) {
3738                         Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
3739                         n->set_property ("duration", parser->default_duration_.smobbed_copy ());
3740                         n->set_property ("drum-type", simple);
3741                         return n->unprotect ();
3742                 }
3743                 if (unsmob_pitch (simple)) {
3744                         Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
3745                         n->set_property ("duration", parser->default_duration_.smobbed_copy ());
3746                         n->set_property ("pitch", simple);
3747                         return n->unprotect ();
3748                 }
3749                 return simple;
3750         } else if (parser->lexer_->is_lyric_state ()) {
3751                 if (Text_interface::is_markup (simple))
3752                         return MAKE_SYNTAX ("lyric-event", loc, simple,
3753                                             parser->default_duration_.smobbed_copy ());
3754         } else if (parser->lexer_->is_chord_state ()) {
3755                 if (unsmob_pitch (simple))
3756                         return make_chord_elements (loc, simple,
3757                                                     parser->default_duration_.smobbed_copy (),
3758                                                     SCM_EOL);
3759         }
3760         return simple;
3761 }
3762
3763 Music *
3764 make_music_with_input (SCM name, Input where)
3765 {
3766        Music *m = make_music_by_name (name);
3767        m->set_spot (where);
3768        return m;
3769 }
3770
3771 SCM
3772 make_simple_markup (SCM a)
3773 {
3774         return a;
3775 }
3776
3777 SCM
3778 make_duration (SCM d, int dots)
3779 {
3780         int t = scm_to_int (d);
3781         if (t > 0 && (t & (t-1)) == 0)
3782                 return Duration (intlog2 (t), dots).smobbed_copy ();
3783         else
3784                 return SCM_UNDEFINED;
3785 }
3786
3787 SCM
3788 make_chord_step (SCM step_scm, Rational alter)
3789 {
3790         int step = scm_to_int (step_scm);
3791
3792         if (step == 7)
3793                 alter += FLAT_ALTERATION;
3794
3795         while (step < 0)
3796                 step += 7;
3797         Pitch m ((step -1) / 7, (step - 1) % 7, alter);
3798         return m.smobbed_copy ();
3799 }
3800
3801
3802 SCM
3803 make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list)
3804 {
3805         SCM chord_ctor = ly_lily_module_constant ("construct-chord-elements");
3806         SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list);
3807         for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
3808         {
3809                 unsmob_music (scm_car (s))->set_spot (loc);
3810         }
3811         return res;
3812 }
3813
3814 int
3815 yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser)
3816 {
3817         Lily_lexer *lex = parser->lexer_;
3818
3819         lex->lexval_ = s;
3820         lex->lexloc_ = loc;
3821         lex->prepare_for_next_token ();
3822         return lex->yylex ();
3823 }