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