X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=8ea6f1958daf8ec5d883557c7851d422ec7cb091;hb=9e781b7dc83b60a543ce218aa1a5f139f74c760f;hp=48dc5680b3bc5cae6b1d16fa962a50b68e2e8d96;hpb=29d5e0a64d0eee69e4ebee1e76e4df26ae58190b;p=lilypond.git

diff --git a/lily/parser.yy b/lily/parser.yy
index 48dc5680b3..8ea6f1958d 100644
--- a/lily/parser.yy
+++ b/lily/parser.yy
@@ -2,7 +2,7 @@
 /*
   This file is part of LilyPond, the GNU music typesetter.
 
-  Copyright (C) 1997--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1997--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
                  Jan Nieuwenhuizen <janneke@gnu.org>
 
   LilyPond is free software: you can redistribute it and/or modify
@@ -80,33 +80,17 @@ or
 %nonassoc COMPOSITE
 %left ADDLYRICS
 
- /* ADDLYRICS needs to have lower precedence than argument scanning,
-  * or we won't be able to tell music apart from closed_music without
-  * lookahead in the context of function calls.
-  */
+%right ':' UNSIGNED REAL E_UNSIGNED EVENT_IDENTIFIER EVENT_FUNCTION '^' '_'
+       HYPHEN EXTENDER DURATION_IDENTIFIER '!'
 
-%nonassoc DEFAULT
-
- /* \default is only applied after exhausting function arguments */
-
-%nonassoc FUNCTION_ARGLIST
-
- /* expressions with units are permitted into argument lists */
-
-%right PITCH_IDENTIFIER NOTENAME_PITCH TONICNAME_PITCH
-      UNSIGNED REAL DURATION_IDENTIFIER ':'
-
- /* The above are the symbols that can start optional function arguments
-    that are recognized in the grammar rather than by predicate
+ /* The above are needed for collecting tremoli and other items (that
+    could otherwise be interpreted as belonging to the next function
+    argument) greedily, and together with the next rule will serve to
+    join numbers and units greedily instead of allowing them into
+    separate function arguments
  */
 
-%nonassoc NUMBER_IDENTIFIER '/'
-
- /* Number-unit expressions, where permitted, are concatenated into
-  * function arguments, just like fractions and tremoli.  Tremoli must
-  * not have higher precedence than UNSIGNED, or Lilypond will not
-  * join ':' with a following optional number.
-  */
+%nonassoc NUMBER_IDENTIFIER
 
 %left PREC_TOP
 
@@ -157,37 +141,41 @@ using namespace std;
 #include "warn.hh"
 
 void
-Lily_parser::parser_error (Input const *i, Lily_parser *parser, SCM *, string s)
+Lily_parser::parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s)
 {
 	parser->parser_error (*i, s);
 }
 
+// The following are somewhat precarious constructs as they may change
+// the value of the lookahead token.  That implies that the lookahead
+// token must not yet have made an impact on the state stack other
+// than causing the reduction of the current rule, or switching the
+// lookahead token while Bison is mulling it over will cause trouble.
+
 #define MYBACKUP(Token, Value, Location)				\
-do									\
-	if (yychar == YYEMPTY)						\
-	{								\
+	do {								\
+		if (yychar != YYEMPTY)					\
+			parser->lexer_->push_extra_token		\
+				(yylloc, yychar, yylval);		\
 		if (Token)						\
-			parser->lexer_->push_extra_token (Token, Value); \
-		parser->lexer_->push_extra_token (BACKUP);		\
-	} else {							\
-		parser->parser_error					\
-			(Location, _("Too much lookahead"));		\
-	}								\
-while (0)
+			parser->lexer_->push_extra_token		\
+				(Location, Token, Value);		\
+		parser->lexer_->push_extra_token (Location, BACKUP);	\
+		yychar = YYEMPTY;					\
+	} while (0)
 
 
 #define MYREPARSE(Location, Pred, Token, Value)				\
-do									\
-	if (yychar == YYEMPTY)						\
-	{								\
-		parser->lexer_->push_extra_token (Token, Value);	\
-		parser->lexer_->push_extra_token (REPARSE,		\
-						  Pred);		\
-	} else {							\
-		parser->parser_error					\
-			(Location, _("Too much lookahead"));		\
-	}								\
-while (0)
+	do {								\
+		if (yychar != YYEMPTY)					\
+			parser->lexer_->push_extra_token		\
+				(yylloc, yychar, yylval);		\
+		parser->lexer_->push_extra_token			\
+			(Location, Token, Value);			\
+		parser->lexer_->push_extra_token			\
+			(Location, REPARSE, Pred);			\
+		yychar = YYEMPTY;					\
+	} while (0)
 
 %}
 
@@ -232,7 +220,7 @@ SCM loc_on_music (Input loc, SCM arg);
 SCM make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list);
 SCM make_chord_step (SCM step, Rational alter);
 SCM make_simple_markup (SCM a);
-bool is_duration (int t);
+SCM make_duration (SCM t, int dots = 0);
 bool is_regular_identifier (SCM id, bool multiple=false);
 SCM try_string_variants (SCM pred, SCM str);
 int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
@@ -285,6 +273,7 @@ int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
 %token REST "\\rest"
 %token REVERT "\\revert"
 %token SCORE "\\score"
+%token SCORELINES "\\score-lines"
 %token SEQUENTIAL "\\sequential"
 %token SET "\\set"
 %token SIMULTANEOUS "\\simultaneous"
@@ -321,7 +310,6 @@ If we give names, Bison complains.
 %token FIGURE_SPACE "_"
 %token HYPHEN "--"
 
-%token CHORDMODIFIERS
 %token MULTI_MEASURE_REST
 
 
@@ -330,8 +318,6 @@ If we give names, Bison complains.
 
 /* Artificial tokens, for more generic function syntax */
 %token EXPECT_MARKUP "markup?"
-%token EXPECT_PITCH "ly:pitch?"
-%token EXPECT_DURATION "ly:duration?"
 %token EXPECT_SCM "scheme?"
 %token BACKUP "(backed-up?)"
 %token REPARSE "(reparsed?)"
@@ -344,7 +330,6 @@ If we give names, Bison complains.
 %token EMBEDDED_LILY "#{"
 
 %token BOOK_IDENTIFIER
-%token CHORDMODIFIER_PITCH
 %token CHORD_MODIFIER
 %token CHORD_REPETITION
 %token CONTEXT_DEF_IDENTIFIER
@@ -423,6 +408,13 @@ toplevel_expression:
 		SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler");
 		scm_call_2 (proc, parser->self_scm (), $1);
 	}
+	| BOOK_IDENTIFIER {
+		SCM proc = parser->lexer_->lookup_identifier
+			(unsmob_book($1)->paper_
+			 ? "toplevel-book-handler"
+			 : "toplevel-bookpart-handler");
+		scm_call_2 (proc, parser->self_scm (), $1);
+	}
 	| score_block {
 		SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
 		scm_call_2 (proc, parser->self_scm (), $1);
@@ -454,6 +446,10 @@ toplevel_expression:
 		{
 			SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
 			scm_call_2 (proc, parser->self_scm (), out);
+		} else if (unsmob_score ($1))
+		{
+			SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
+			scm_call_2 (proc, parser->self_scm (), $1);
 		} else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
 			parser->parser_error (@1, _("bad expression type"));
 	}
@@ -491,6 +487,7 @@ embedded_scm_bare_arg:
 	{
 		$$ = parser->lexer_->eval_scm_token ($1);
 	}
+	| FRACTION
 	| full_markup_list
 	| context_modification
 	| score_block
@@ -507,10 +504,19 @@ embedded_scm:
 	| scm_function_call
 	;
 
+/* embedded_scm_arg is _not_ casting pitches to music by default, this
+ * has to be done by the function itself.  Note that this may cause
+ * the results of scm_function_call or embedded_scm_bare_arg to be
+ * turned into music from pitches as well.  Note that this creates a
+ * distinctly awkward situation for calculated drum pitches.  Those
+ * are at the current point of time rejected as music constituents as
+ * they can't be distinguished from "proper" symbols.
+ */
+
 embedded_scm_arg:
 	embedded_scm_bare_arg
 	| scm_function_call
-	| music_arg
+	| music_assign
 	;
 
 scm_function_call:
@@ -520,12 +526,52 @@ scm_function_call:
 	}
 	;
 
+embedded_lilypond_number:
+	'-' embedded_lilypond_number
+	{
+		$$ = scm_difference ($2, SCM_UNDEFINED);
+	}
+	| bare_number_common
+	| UNSIGNED NUMBER_IDENTIFIER
+	{
+		$$ = scm_product ($1, $2);
+	}
+	;
+
 embedded_lilypond:
 	/* empty */
 	{
+		// FIXME: @$ does not contain a useful source location
+		// for empty rules, and the only token in the whole
+		// production, EMBEDDED_LILY, is synthetic and also
+		// contains no source location.
 		$$ = MAKE_SYNTAX ("void-music", @$);
 	}
-	| identifier_init
+	| identifier_init_nonumber
+	| embedded_lilypond_number
+	| post_event post_events
+	{
+		$$ = scm_reverse_x ($2, SCM_EOL);
+		if (Music *m = unsmob_music ($1))
+		{
+			if (m->is_mus_type ("post-event-wrapper"))
+				$$ = scm_append
+					(scm_list_2 (m->get_property ("elements"),
+						     $$));
+			else
+				$$ = scm_cons ($1, $$);
+		}
+		if (scm_is_pair ($$)
+		    && scm_is_null (scm_cdr ($$)))
+			$$ = scm_car ($$);
+		else
+		{
+			Music * m = MY_MAKE_MUSIC ("PostEvents", @$);
+			m->set_property ("elements", $$);
+			$$ = m->unprotect ();
+		}
+	}
+	| multiplied_duration
 	| music_embedded music_embedded music_list {
 		$3 = scm_reverse_x ($3, SCM_EOL);
 		if (unsmob_music ($2))
@@ -578,16 +624,17 @@ assignment:
 		parser->lexer_->set_identifier (path, $4);
                 $$ = SCM_UNSPECIFIED;
 	}
+	| assignment_id '.' property_path '=' identifier_init {
+		SCM path = scm_cons (scm_string_to_symbol ($1), $3);
+		parser->lexer_->set_identifier (path, $5);
+                $$ = SCM_UNSPECIFIED;
+	}
 	;
 
 
 identifier_init:
-	score_block
-	| book_block
-	| bookpart_block
-	| output_def
-	| context_def_spec_block
-	| music_assign
+	identifier_init_nonumber
+	| number_expression
 	| post_event_nofinger post_events
 	{
 		$$ = scm_reverse_x ($2, SCM_EOL);
@@ -610,7 +657,16 @@ identifier_init:
 			$$ = m->unprotect ();
 		}
 	}
-	| number_expression
+	;
+
+identifier_init_nonumber:
+	score_block
+	| book_block
+	| bookpart_block
+	| output_def
+	| context_def_spec_block
+	| music_assign
+	| pitch_or_music
 	| FRACTION
 	| string
         | embedded_scm
@@ -622,6 +678,7 @@ context_def_spec_block:
 	CONTEXT '{' context_def_spec_body '}'
 		{
 		$$ = $3;
+		unsmob_context_def ($$)->origin ()->set_spot (@$);
 	}
 	;
 
@@ -650,6 +707,7 @@ context_mod_embedded:
 			$$ = $1;
 		else {
 			parser->parser_error (@1, _ ("not a context mod"));
+			$$ = Context_mod ().smobbed_copy ();
 		}
 	}
 	;
@@ -658,11 +716,9 @@ context_mod_embedded:
 context_def_spec_body:
 	/**/ {
 		$$ = Context_def::make_scm ();
-		unsmob_context_def ($$)->origin ()->set_spot (@$);
 	}
 	| CONTEXT_DEF_IDENTIFIER {
 		$$ = $1;
-		unsmob_context_def ($$)->origin ()->set_spot (@$);
 	}
 	| context_def_spec_body context_mod {
 		if (!SCM_UNBNDP ($2))
@@ -689,6 +745,7 @@ context_def_spec_body:
 book_block:
 	BOOK '{' book_body '}' 	{
 		$$ = $3;
+		unsmob_book ($$)->origin ()->set_spot (@$);
 		pop_paper (parser);
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F);
 	}
@@ -701,7 +758,6 @@ book_body:
 	{
 		Book *book = new Book;
 		init_papers (parser);
-		book->origin ()->set_spot (@$);
 		book->paper_ = dynamic_cast<Output_def*> (unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
 		book->paper_->unprotect ();
 		push_paper (parser, book->paper_);
@@ -710,7 +766,6 @@ book_body:
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $$);
 	}
 	| BOOK_IDENTIFIER {
-		unsmob_book ($1)->origin ()->set_spot (@$);
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1);
 	}
 	| book_body paper_block {
@@ -752,6 +807,10 @@ book_body:
 		{
 			SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
 			scm_call_2 (proc, $1, out);
+		} else if (unsmob_score ($2))
+		{
+			SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
+			scm_call_2 (proc, $1, $2);
 		} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
 			parser->parser_error (@2, _("bad expression type"));
 	}
@@ -770,6 +829,7 @@ book_body:
 bookpart_block:
 	BOOKPART '{' bookpart_body '}' {
 		$$ = $3;
+		unsmob_book ($$)->origin ()->set_spot (@$);
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
 	}
 	;
@@ -777,12 +837,10 @@ bookpart_block:
 bookpart_body:
 	{
 		Book *book = new Book;
-		book->origin ()->set_spot (@$);
                 $$ = book->unprotect ();
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $$);
 	}
 	| BOOK_IDENTIFIER {
-		unsmob_book ($1)->origin ()->set_spot (@$);
 		parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1);
 	}
 	| bookpart_body paper_block {
@@ -819,6 +877,10 @@ bookpart_body:
 		{
 			SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
 			scm_call_2 (proc, $1, out);
+		} else if (unsmob_score ($2))
+		{
+			SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
+			scm_call_2 (proc, $1, $2);
 		} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
 			parser->parser_error (@2, _("bad expression type"));
 	}
@@ -838,27 +900,69 @@ bookpart_body:
 
 score_block:
 	SCORE '{' score_body '}' 	{
+		unsmob_score ($3)->origin ()->set_spot (@$);
 		$$ = $3;
 	}
 	;
 
+score_headers:
+	/* empty */
+	{
+		$$ = SCM_EOL;
+	}
+	| score_headers
+	{
+		if (!scm_is_pair ($1)
+		    || !ly_is_module (scm_car ($1)))
+			$1 = scm_cons (ly_make_module (false), $1);
+		parser->lexer_->add_scope (scm_car ($1));
+	} lilypond_header
+	{
+		$$ = $1;
+	}
+	| score_headers output_def
+	{
+                Output_def *od = unsmob_output_def ($2);
+		if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+		{
+			parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
+
+		}
+		else
+		{
+			if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+				scm_set_cdr_x ($1, scm_cons ($2, scm_cdr ($1)));
+			else
+				$$ = scm_cons ($2, $1);
+		}
+	}
+	;
+
+		
+
 score_body:
-	music {
+	score_headers music {
 		SCM scorify = ly_lily_module_constant ("scorify-music");
-		$$ = scm_call_2 (scorify, $1, parser->self_scm ());
+		$$ = scm_call_2 (scorify, $2, parser->self_scm ());
 
-		unsmob_score ($$)->origin ()->set_spot (@$);
+		if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+		{
+			unsmob_score ($$)->set_header (scm_car ($1));
+			$1 = scm_cdr ($1);
+		}
+		for (SCM p = scm_reverse_x ($1, SCM_EOL);
+		     scm_is_pair (p); p = scm_cdr (p))
+		{
+			unsmob_score ($$)->
+				add_output_def (unsmob_output_def (scm_car (p)));
+		}
 	}
 	| embedded_scm_active {
-		Score *score;
-		if (unsmob_score ($1))
-			score = new Score (*unsmob_score ($1));
-		else {
-			score = new Score;
+		if (!unsmob_score ($1))
+		{
+			$$ = (new Score)->unprotect ();
 			parser->parser_error (@1, _("score expected"));
 		}
-		unsmob_score ($$)->origin ()->set_spot (@$);
-		$$ = score->unprotect ();
 	}
 	| score_body
 	{
@@ -944,17 +1048,8 @@ output_def_head_with_mode_switch:
 // is still time to escape from notes mode.
 
 music_or_context_def:
-	music_arg
-	{
-		parser->lexer_->pop_state ();
-	}
-	| CONTEXT
-	{
-		parser->lexer_->pop_state ();
-	} '{' context_def_spec_body '}'
-	{
-		$$ = $4;
-	}
+	music_assign
+	| context_def_spec_block
 	;
 
 output_def_body:
@@ -981,6 +1076,7 @@ output_def_body:
 		parser->lexer_->push_note_state (nn);
 	} music_or_context_def
 	{
+		parser->lexer_->pop_state ();
 		if (unsmob_context_def ($3))
 			assign_context_def (unsmob_output_def ($1), $3);
 		else {
@@ -1000,12 +1096,12 @@ tempo_event:
 	TEMPO steno_duration '=' tempo_range	{
 		$$ = MAKE_SYNTAX ("tempo", @$, SCM_EOL, $2, $4);
 	}
-	| TEMPO scalar_closed steno_duration '=' tempo_range	{
+	| TEMPO scalar steno_duration '=' tempo_range	{
 		$$ = MAKE_SYNTAX ("tempo", @$, $2, $3, $5);
 	}
 	| TEMPO scalar {
 		$$ = MAKE_SYNTAX ("tempo", @$, $2);
-	}
+	} %prec ':'
 	;
 
 /*
@@ -1035,8 +1131,17 @@ braced_music_list:
 	}
 	;
 
-music:	music_arg
+music:	music_assign
 	| lyric_element_music
+	| pitch_or_music
+	{
+	        $$ = make_music_from_simple (parser, @1, $1);
+                if (!unsmob_music ($$))
+		{
+                        parser->parser_error (@1, _ ("music expected"));
+			$$ = MAKE_SYNTAX ("void-music", @$);
+		}
+	}
 	;
 
 music_embedded:
@@ -1055,6 +1160,18 @@ music_embedded:
 	{
 		$$ = $3;
 	}
+	| multiplied_duration post_events
+	{
+		Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
+
+		parser->default_duration_ = *unsmob_duration ($1);
+		n->set_property ("duration", $1);
+
+		if (scm_is_pair ($2))
+			n->set_property ("articulations",
+					 scm_reverse_x ($2, SCM_EOL));
+		$$ = n->unprotect ();
+	}
 	;
 
 music_embedded_backup:
@@ -1079,16 +1196,8 @@ music_embedded_backup:
 	}
 	;
 
-music_arg:
-	simple_music
-	{
-	        $$ = make_music_from_simple (parser, @1, $1);
-                if (!unsmob_music ($$))
-                        parser->parser_error (@1, _ ("music expected"));
-	}
-	| composite_music %prec COMPOSITE
-	;
-
+// music_assign does not need to contain lyrics: there are no
+// assignments in lyricmode.
 music_assign:
 	simple_music
 	| composite_music %prec COMPOSITE
@@ -1130,7 +1239,11 @@ simple_music:
 	;
 
 context_modification:
-        WITH { parser->lexer_->push_initial_state (); } '{' context_mod_list '}'
+        WITH
+	{
+		SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+		parser->lexer_->push_note_state (nn);
+	} '{' context_mod_list '}'
         {
                 parser->lexer_->pop_state ();
                 $$ = $4;
@@ -1143,8 +1256,12 @@ context_modification:
         {
                 $$ = $1;
         }
-	| WITH embedded_scm_closed
+	| WITH context_modification_arg
 	{
+		if (unsmob_music ($2)) {
+			SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+			$2 = scm_call_2 (proc, parser->self_scm (), $2);
+		}
 		if (unsmob_context_mod ($2))
 			$$ = $2;
 		else {
@@ -1154,6 +1271,11 @@ context_modification:
 	}
         ;
 
+context_modification_arg:
+	embedded_scm
+	| MUSIC_IDENTIFIER
+	;
+
 optional_context_mod:
         /**/ {
             $$ = SCM_EOL;
@@ -1188,16 +1310,6 @@ composite_music:
 	| music_bare
 	;
 
-/* Music that can be parsed without lookahead */
-closed_music:
-	music_bare
-	| complex_music_prefix closed_music
-	{
-		$$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
-	}
-	| music_function_call_closed
-	;
-
 music_bare:
 	mode_changed_music
 	| MUSIC_IDENTIFIER
@@ -1209,125 +1321,59 @@ grouped_music_list:
 	| sequential_music		{ $$ = $1; }
 	;
 
-/* An argument list. If a function \foo expects scm scm pitch, then the lexer expands \foo into the token sequence:
- MUSIC_FUNCTION EXPECT_PITCH EXPECT_SCM EXPECT_SCM EXPECT_NO_MORE_ARGS
-and this rule returns the reversed list of arguments. */
-
-/* Function argument lists come in a number of flavors.  Whenever
- * LilyPond has to pick between different flavors, the decision is
- * either made because of tokens it has already seen, or it is
- * postponed until tokens suitable for making the decision come up.
- * For postponing decisions, it may be necessary that the competing
- * rules are written in a way making them compatible until a decision
- * can be made.  Sometimes this is done by putting common traits into
- * a separate "common" rule set.
+/* Function argument lists are arguably the most complex part in the
+ * parser.  They are pretty tricky to understand because of the way
+ * they are processed, and because of optional arguments that can be
+ * omitted.  When there are several optional arguments in a row,
+ * omitting one automatically omits all following arguments.  Optional
+ * arguments can only be omitted when either
+ *
+ * a) the omission is explicitly started with \default
+ * b) the omission is implicitly started by an argument not matching
+ *    its predicate, and there is a mandatory argument later that can
+ *    "catch" the argument that does not fit.
  *
- * function_arglist: a full argument list.  Optional arguments at the
- * end of the list can only be skipped by writing \default in their
- * place.
+ * When argument parsing starts, the lexer pushes EXPECT_SCM tokens
+ * (corresponding to mandatory arguments and having a predicate
+ * function as semantic value) or EXPECT_OPTIONAL EXPECT_SCM (where
+ * the semantic value of the EXPECT_OPTIONAL token is the default to
+ * use when the optional argument is omitted, and EXPECT_SCM again has
+ * the argument predicate as semantic value) in reverse order to the
+ * parser, followed by EXPECT_NO_MORE_ARGS.  The argument list is then
+ * processed inside-out while actual tokens are consumed.
  *
- * function_arglist_backup: an argument list ending in an optional
- * argument that may be skipped depending on its predicate.
+ * This means that the argument list tokens determine the actions
+ * taken as they arrive.  The structure of the argument list is known
+ * to the parser and stored in its parse stack when the first argument
+ * is being parsed.  What the parser does not know is which predicates
+ * will match and whether or not \default will be appearing in the
+ * argument list, and where.
  *
- * function_arglist_skip: an argument list _not_ ending in an optional
- * argument that is actually taken.
+ * Sequences of 0 or more optional arguments are scanned using either
+ * function_arglist_backup or function_arglist_nonbackup.  The first
+ * is used when optional arguments are followed by at least one
+ * mandatory argument: in that case optional arguments may be skipped
+ * by either a false predicate (in which case the expression will be
+ * pushed back as one or more tokens, preceded by a BACKUP token) or
+ * by using \default.
  *
- * function_arglist_nonbackup: an argument list ending in an optional
- * argument that may not be skipped because it is in end position and
- * has not been shortcircuited with \default.
+ * If optional arguments are at the end of the argument list, they are
+ * instead scanned using function_arglist_nonbackup: here the only
+ * manner to enter into skipping of optional arguments is the use of
+ * \default.
+ *
+ * The argument list of a normal function call is parsed using
+ * function_arglist.  The part of an argument list before a mandatory
+ * argument is parsed using function_arglist_optional.
+ *
+ * The difference is that leading optional arguments are scanned using
+ * function_arglist_nonbackup and function_arglist_backup,
+ * respectively.
+ *
+ * Most other details are obvious in the rules themselves.
  *
- * function_arglist* / function_arglist_closed*: The closed variants
- * don't end in simple music expressions that might still accept
- * things like a duration or a postevent.
  */
 
-function_arglist_skip:
-	function_arglist_common
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip
-	{
-		$$ = scm_cons ($1, $3);
-	} %prec FUNCTION_ARGLIST
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_skip
-	{
-		$$ = scm_cons ($1, $3);
-	} %prec FUNCTION_ARGLIST
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip
-	{
-		$$ = scm_cons ($1, $3);
-	} %prec FUNCTION_ARGLIST
-	;
-
-
-function_arglist_nonbackup_common:
-	EXPECT_OPTIONAL EXPECT_PITCH function_arglist pitch_also_in_chords {
-		$$ = scm_cons ($4, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed duration_length {
-		$$ = scm_cons ($4, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist FRACTION
-	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed post_event_nofinger
-	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' UNSIGNED
-	{
-		SCM n = scm_difference ($5, SCM_UNDEFINED);
-		if (scm_is_true (scm_call_1 ($2, n)))
-			$$ = scm_cons (n, $3);
-		else {
-			Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
-			t->set_property ("digit", $5);
-			$$ = check_scheme_arg (parser, @4, t->unprotect (),
-					       $3, $2, n);
-		}
-		
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' REAL
-	{
-		$$ = check_scheme_arg (parser, @4,
-				       scm_difference ($5, SCM_UNDEFINED),
-				       $3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' NUMBER_IDENTIFIER
-	{
-		$$ = check_scheme_arg (parser, @4,
-				       scm_difference ($5, SCM_UNDEFINED),
-				       $3, $2);
-	}
-	;
-
-function_arglist_closed_nonbackup:
-	function_arglist_nonbackup_common
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg_closed
-	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number_closed
-	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist SCM_IDENTIFIER
-	{
-		$$ = check_scheme_arg (parser, @4,
-				       try_string_variants ($2, $4),
-				       $3, $2, $4);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist STRING
-	{
-		$$ = check_scheme_arg (parser, @4,
-				       try_string_variants ($2, $4),
-				       $3, $2, $4);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist full_markup
-	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
-	}
-	;
-
 symbol_list_arg:
 	SYMBOL_LIST
 	| SYMBOL_LIST '.' symbol_list_rev
@@ -1367,15 +1413,68 @@ symbol_list_element:
 
 
 function_arglist_nonbackup:
-	function_arglist_nonbackup_common
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg
+	function_arglist_common
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
+	{
+		SCM n = scm_difference ($5, SCM_UNDEFINED);
+		if (scm_is_true (scm_call_1 ($2, n)))
+			$$ = scm_cons (n, $3);
+		else {
+			Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
+			t->set_property ("digit", $5);
+			$$ = check_scheme_arg (parser, @4, t->unprotect (),
+					       $3, $2, n);
+		}
+		
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
+	{
+		$$ = check_scheme_arg (parser, @4,
+				       scm_difference ($5, SCM_UNDEFINED),
+				       $3, $2);
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
+	{
+		$$ = check_scheme_arg (parser, @4,
+				       scm_difference ($5, SCM_UNDEFINED),
+				       $3, $2);
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg
+	{
+		if (scm_is_true (scm_call_1 ($2, $4)))
+			$$ = scm_cons ($4, $3);
+		else
+			$$ = check_scheme_arg (parser, @4,
+					       make_music_from_simple
+					       (parser, @4, $4),
+					       $3, $2);
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
 	}
+	| function_arglist_nonbackup_reparse REPARSE pitch_or_music
+	{
+		if (scm_is_true (scm_call_1 ($2, $3)))
+			$$ = scm_cons ($3, $1);
+		else
+			$$ = check_scheme_arg (parser, @3,
+					       make_music_from_simple
+					       (parser, @3, $3),
+					       $1, $2);
+	}
+	| function_arglist_nonbackup_reparse REPARSE duration_length
+	{
+		$$ = check_scheme_arg (parser, @3, $3, $1, $2);
+	}
+	| function_arglist_nonbackup_reparse REPARSE bare_number_common
+	{
+		$$ = check_scheme_arg (parser, @3, $3, $1, $2);
+	}
 	| function_arglist_nonbackup_reparse REPARSE SCM_ARG
 	{
 		$$ = check_scheme_arg (parser, @3, $3, $1, $2);
@@ -1391,7 +1490,7 @@ function_arglist_nonbackup:
 	;
 
 function_arglist_nonbackup_reparse:
-	EXPECT_OPTIONAL EXPECT_SCM function_arglist SCM_IDENTIFIER
+	EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
 	{
 		$$ = $3;
 		SCM res = try_string_variants ($2, $4);
@@ -1408,7 +1507,29 @@ function_arglist_nonbackup_reparse:
 		else
 			MYREPARSE (@4, $2, SCM_ARG, $4);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist STRING
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup pitch
+	{
+		$$ = $3;
+		if (scm_is_true
+		    (scm_call_1
+		     ($2, make_music_from_simple
+		      (parser, @4, $4))))
+			MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+		else
+			MYREPARSE (@4, $2, SCM_ARG, $4);
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup steno_tonic_pitch
+	{
+		$$ = $3;
+		if (scm_is_true
+		    (scm_call_1
+		     ($2, make_music_from_simple
+		      (parser, @4, $4))))
+			MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+		else
+			MYREPARSE (@4, $2, SCM_ARG, $4);
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
 	{
 		$$ = $3;
 		SCM res = try_string_variants ($2, $4);
@@ -1425,7 +1546,7 @@ function_arglist_nonbackup_reparse:
 		else
 			MYREPARSE (@4, $2, SCM_ARG, $4);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist full_markup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
 	{
 		$$ = $3;
 		if (scm_is_true (scm_call_1 ($2, $4)))
@@ -1438,40 +1559,88 @@ function_arglist_nonbackup_reparse:
 		else
 			MYREPARSE (@4, $2, SCM_ARG, $4);
 	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup UNSIGNED
+	{
+		$$ = $3;
+		if (scm_is_true (scm_call_1 ($2, $4)))
+			MYREPARSE (@4, $2, REAL, $4);
+		else {
+			SCM d = make_duration ($4);
+			if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($2, d)))
+				MYREPARSE (@4, $2, REAL, $4); // trigger error
+			else
+				MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup DURATION_IDENTIFIER {
+		$$ = $3;
+		MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+	}
 	;
 
-function_arglist_keep:
-	function_arglist_common
-	| function_arglist_backup
-	;
-
-function_arglist_closed_keep:
-	function_arglist_closed_common
-	| function_arglist_backup
-	;
 
+// function_arglist_backup can't occur at the end of an argument
+// list.
 function_arglist_backup:
-	EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep embedded_scm_arg_closed
+	function_arglist_common
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg
+	{
+		if (scm_is_true (scm_call_1 ($2, $4)))
+			$$ = scm_cons ($4, $3);
+		else {
+			$$ = make_music_from_simple (parser, @4, $4);
+			if (scm_is_true (scm_call_1 ($2, $$)))
+				$$ = scm_cons ($$, $3);
+			else
+			{
+				$$ = scm_cons (loc_on_music (@3, $1), $3);
+				MYBACKUP (SCM_ARG, $4, @4);
+			}
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
 			$$ = scm_cons ($4, $3);
 		} else {
 			$$ = scm_cons (loc_on_music (@3, $1), $3);
-			MYBACKUP (SCM_ARG, $4, @4);
+			MYBACKUP (EVENT_IDENTIFIER, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep post_event_nofinger
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup pitch
 	{
-		if (scm_is_true (scm_call_1 ($2, $4)))
+		if (scm_is_true
+		    (scm_call_1
+		     ($2, make_music_from_simple
+		      (parser, @4, $4))))
 		{
+			$$ = $3;
+			MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+		} else if (scm_is_true (scm_call_1 ($2, $4)))
+			$$ = scm_cons ($4, $3);
+		else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (PITCH_IDENTIFIER, $4, @4);
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup steno_tonic_pitch
+	{
+		if (scm_is_true
+		    (scm_call_1
+		     ($2, make_music_from_simple
+		      (parser, @4, $4))))
+		{
+			$$ = $3;
+			MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+		} else if (scm_is_true (scm_call_1 ($2, $4)))
 			$$ = scm_cons ($4, $3);
-		} else {
+		else {
 			$$ = scm_cons (loc_on_music (@3, $1), $3);
-			MYBACKUP (EVENT_IDENTIFIER, $4, @4);
+			MYBACKUP (TONICNAME_PITCH, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep full_markup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup full_markup
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 			$$ = scm_cons ($4, $3);
@@ -1480,18 +1649,25 @@ function_arglist_backup:
 			MYBACKUP (LYRIC_ELEMENT, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep UNSIGNED
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup UNSIGNED
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
+			MYREPARSE (@4, $2, REAL, $4);
 			$$ = $3;
-			MYREPARSE (@4, $2, UNSIGNED, $4);
 		} else {
-			$$ = scm_cons (loc_on_music (@3, $1), $3);
-			MYBACKUP (UNSIGNED, $4, @4);
+			SCM d = make_duration ($4);
+			if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($2, d)))
+			{
+				$$ = scm_cons (loc_on_music (@3, $1), $3);
+				MYBACKUP (UNSIGNED, $4, @4);
+			} else {
+				MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+				$$ = $3;
+			}
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep REAL
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REAL
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
@@ -1502,7 +1678,7 @@ function_arglist_backup:
 			MYBACKUP (REAL, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep NUMBER_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NUMBER_IDENTIFIER
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
@@ -1512,17 +1688,7 @@ function_arglist_backup:
 			MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep FRACTION
-	{
-		if (scm_is_true (scm_call_1 ($2, $4)))
-		{
-			$$ = scm_cons ($4, $3);
-		} else {
-			$$ = scm_cons (loc_on_music (@3, $1), $3);
-			MYBACKUP (FRACTION, $4, @4);
-		}
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' UNSIGNED
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' UNSIGNED
 	{
 		SCM n = scm_difference ($5, SCM_UNDEFINED);
 		if (scm_is_true (scm_call_1 ($2, n))) {
@@ -1537,12 +1703,12 @@ function_arglist_backup:
 			else {
 				$$ = scm_cons (loc_on_music (@3, $1), $3);
 				MYBACKUP (UNSIGNED, $5, @5);
-				parser->lexer_->push_extra_token ('-');
+				parser->lexer_->push_extra_token (@4, '-');
 			}
 		}
 		
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' REAL
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' REAL
 	{
 		SCM n = scm_difference ($5, SCM_UNDEFINED);
 		if (scm_is_true (scm_call_1 ($2, n))) {
@@ -1553,7 +1719,7 @@ function_arglist_backup:
 			MYBACKUP (REAL, n, @5);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' NUMBER_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' NUMBER_IDENTIFIER
 	{
 		SCM n = scm_difference ($5, SCM_UNDEFINED);
 		if (scm_is_true (scm_call_1 ($2, n))) {
@@ -1563,15 +1729,18 @@ function_arglist_backup:
 			MYBACKUP (NUMBER_IDENTIFIER, n, @5);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_keep pitch_also_in_chords
-	{
-		$$ = scm_cons ($4, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_keep duration_length
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
 	{
-		$$ = scm_cons ($4, $3);
+		if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+			$$ = $3;
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (DURATION_IDENTIFIER, $4, @4);
+		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep SCM_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup SCM_IDENTIFIER
 	{
 		SCM res = try_string_variants ($2, $4);
 		if (!SCM_UNBNDP (res))
@@ -1586,7 +1755,7 @@ function_arglist_backup:
 			MYBACKUP (SCM_IDENTIFIER, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep STRING
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup STRING
 	{
 		SCM res = try_string_variants ($2, $4);
 		if (!SCM_UNBNDP (res))
@@ -1601,12 +1770,22 @@ function_arglist_backup:
 			MYBACKUP (STRING, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup BACKUP
+	| function_arglist_backup REPARSE pitch_or_music
 	{
-		$$ = scm_cons ($1, $3);
-		MYBACKUP(0, SCM_UNDEFINED, @3);
+		if (scm_is_true (scm_call_1 ($2, $3)))
+			$$ = scm_cons ($3, $1);
+		else
+			$$ = check_scheme_arg (parser, @3,
+					       make_music_from_simple
+					       (parser, @3, $3),
+					       $1, $2);
+	}
+	| function_arglist_backup REPARSE bare_number_common
+	{
+		$$ = check_scheme_arg (parser, @3,
+				       $3, $1, $2);
 	}
-	| function_arglist_backup REPARSE bare_number
+	| function_arglist_backup REPARSE duration_length
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
@@ -1618,33 +1797,46 @@ function_arglist_backup:
 	;
 
 function_arglist:
-	function_arglist_common
-	| function_arglist_nonbackup
+	function_arglist_nonbackup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
+	{
+		$$ = scm_cons (loc_on_music (@4, $1), $3);
+	}
 	;
 
-function_arglist_common:
-	function_arglist_bare
-	| EXPECT_SCM function_arglist_optional embedded_scm_arg
+function_arglist_skip_nonbackup:
+	function_arglist_nonbackup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
 	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
+		$$ = scm_cons (loc_on_music (@3, $1), $3);
+	}
+	;
+
+function_arglist_common:
+	EXPECT_NO_MORE_ARGS {
+		$$ = SCM_EOL;
 	}
-	| EXPECT_SCM function_arglist_closed_optional bare_number
+	| EXPECT_SCM function_arglist_optional embedded_scm_arg
 	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
+		if (scm_is_true (scm_call_1 ($1, $3)))
+			$$ = scm_cons ($3, $2);
+		else
+			$$ = check_scheme_arg (parser, @3,
+					       make_music_from_simple
+					       (parser, @3, $3),
+					       $2, $1);
 	}
-	| EXPECT_SCM function_arglist_optional FRACTION
+	| EXPECT_SCM function_arglist_optional bare_number_common
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $2, $1);
 	}
-	| EXPECT_SCM function_arglist_closed_optional post_event_nofinger
+	| EXPECT_SCM function_arglist_optional post_event_nofinger
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $2, $1);
 	}
-	| EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER
+	| EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
 	{
 		SCM n = scm_difference ($4, SCM_UNDEFINED);
 		$$ = check_scheme_arg (parser, @4, n, $2, $1);
@@ -1659,7 +1851,22 @@ function_arglist_common:
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
 	}
-	| function_arglist_common_reparse REPARSE bare_number
+	| function_arglist_common_reparse REPARSE pitch_or_music
+	{
+		if (scm_is_true (scm_call_1 ($2, $3)))
+			$$ = scm_cons ($3, $1);
+		else
+			$$ = check_scheme_arg (parser, @3,
+					       make_music_from_simple
+					       (parser, @3, $3),
+					       $1, $2);
+	}
+	| function_arglist_common_reparse REPARSE bare_number_common
+	{
+		$$ = check_scheme_arg (parser, @3,
+				       $3, $1, $2);
+	}
+	| function_arglist_common_reparse REPARSE duration_length
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
@@ -1689,6 +1896,28 @@ function_arglist_common_reparse:
 			// know the predicate to be false.
 			MYREPARSE (@3, $1, SCM_ARG, $3);
 	}
+	| EXPECT_SCM function_arglist_optional pitch
+	{
+		$$ = $2;
+		if (scm_is_true
+		    (scm_call_1
+		     ($1, make_music_from_simple
+		      (parser, @3, $3))))
+			MYREPARSE (@3, $1, PITCH_IDENTIFIER, $3);
+		else
+			MYREPARSE (@3, $1, SCM_ARG, $3);
+	}
+	| EXPECT_SCM function_arglist_optional steno_tonic_pitch
+	{
+		$$ = $2;
+		if (scm_is_true
+		    (scm_call_1
+		     ($1, make_music_from_simple
+		      (parser, @3, $3))))
+			MYREPARSE (@3, $1, TONICNAME_PITCH, $3);
+		else
+			MYREPARSE (@3, $1, SCM_ARG, $3);
+	}
 	| EXPECT_SCM function_arglist_optional STRING
 	{
 		$$ = $2;
@@ -1721,7 +1950,25 @@ function_arglist_common_reparse:
 			// know the predicate to be false.
 			MYREPARSE (@3, $1, SCM_ARG, $3);
 	}
-	| EXPECT_SCM function_arglist_closed_optional '-' UNSIGNED
+	| EXPECT_SCM function_arglist_optional UNSIGNED
+	{
+		$$ = $2;
+		if (scm_is_true (scm_call_1 ($1, $3)))
+			MYREPARSE (@3, $1, REAL, $3);
+		else {
+			SCM d = make_duration ($3);
+			if (SCM_UNBNDP (d) || scm_is_false (scm_call_1 ($1, d)))
+				MYREPARSE (@3, $1, REAL, $3);
+			else
+				MYREPARSE (@3, $1, DURATION_IDENTIFIER, d);
+		}
+	}
+	| EXPECT_SCM function_arglist_optional DURATION_IDENTIFIER
+	{
+		$$ = $2;
+		MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
+	}
+	| EXPECT_SCM function_arglist_optional '-' UNSIGNED
 	{
 		$$ = $2;
 		SCM n = scm_difference ($4, SCM_UNDEFINED);
@@ -1738,7 +1985,7 @@ function_arglist_common_reparse:
 		}
 		
 	}
-	| EXPECT_SCM function_arglist_closed_optional '-' REAL
+	| EXPECT_SCM function_arglist_optional '-' REAL
 	{
 		$$ = $2;
 		SCM n = scm_difference ($4, SCM_UNDEFINED);
@@ -1746,117 +1993,20 @@ function_arglist_common_reparse:
 	}
 	;
 
-function_arglist_closed:
-	function_arglist_closed_common
-	| function_arglist_closed_nonbackup
-	;
-
-function_arglist_closed_common:
-	function_arglist_bare
-	| EXPECT_SCM function_arglist_optional embedded_scm_arg_closed
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
-	}
-	| EXPECT_SCM function_arglist_closed_optional bare_number
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
-	}
-	| EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       scm_difference ($4, SCM_UNDEFINED),
-				       $2, $1);
-	}
-	| EXPECT_SCM function_arglist_closed_optional post_event_nofinger
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
-	}
-	| EXPECT_SCM function_arglist_optional FRACTION
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $2, $1);
-	}
-	| function_arglist_common_reparse REPARSE SCM_ARG
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $1, $2);
-	}
-	| function_arglist_common_reparse REPARSE bare_number
-	{
-		$$ = check_scheme_arg (parser, @3,
-				       $3, $1, $2);
-	}
-	| function_arglist_common_reparse REPARSE symbol_list_arg
-	{
-		$$ = check_scheme_arg (parser, @3, $3, $1, $2);
-	}
-	;
-
 function_arglist_optional:
-	function_arglist_keep %prec FUNCTION_ARGLIST
-	| function_arglist_backup BACKUP
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_optional
-	{
-		$$ = scm_cons ($1, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_optional
+	function_arglist_backup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
 	{
-		$$ = scm_cons ($1, $3);
+		$$ = scm_cons (loc_on_music (@4, $1), $3);
 	}
+	| function_arglist_skip_backup BACKUP
 	;
 
-function_arglist_closed_optional:
-	function_arglist_closed_keep %prec FUNCTION_ARGLIST
-	| function_arglist_backup BACKUP
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_closed_optional
-	{
-		$$ = scm_cons ($1, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_optional
+function_arglist_skip_backup:
+	function_arglist_backup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
 	{
-		$$ = scm_cons ($1, $3);
-	}
-	;
-
-embedded_scm_closed:
-	embedded_scm_bare
-	| scm_function_call_closed
-	;
-
-embedded_scm_arg_closed:
-	embedded_scm_bare_arg
-	| scm_function_call_closed
-	| closed_music
-	;
-
-scm_function_call_closed:
-	SCM_FUNCTION function_arglist_closed {
-		$$ = MAKE_SYNTAX ("music-function", @$,
-					 $1, $2);
-	} %prec FUNCTION_ARGLIST
-	;
-
-function_arglist_bare:
-	EXPECT_NO_MORE_ARGS {
-		$$ = SCM_EOL;
-	}
-	| EXPECT_PITCH function_arglist_optional pitch_also_in_chords {
-		$$ = scm_cons ($3, $2);
-	}
-	| EXPECT_DURATION function_arglist_closed_optional duration_length {
-		$$ = scm_cons ($3, $2);
-	}
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip DEFAULT {
-		$$ = scm_cons ($1, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_skip DEFAULT {
-		$$ = scm_cons ($1, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip DEFAULT {
-		$$ = scm_cons ($1, $3);
+		$$ = scm_cons (loc_on_music (@3, $1), $3);
 	}
 	;
 
@@ -2017,8 +2167,8 @@ re_rhythmed_music:
 	;
 
 context_change:
-	CHANGE STRING '=' STRING  {
-		$$ = MAKE_SYNTAX ("context-change", @$, scm_string_to_symbol ($2), $4);
+	CHANGE symbol '=' simple_string  {
+		$$ = MAKE_SYNTAX ("context-change", @$, $2, $4);
 	}
 	;
 
@@ -2264,10 +2414,10 @@ simple_revert_context:
 		    (scm_object_property (scm_car ($1),
 					  ly_symbol2scm ("is-grob?")))) {
 			$$ = ly_symbol2scm ("Bottom");
-			parser->lexer_->push_extra_token (SCM_IDENTIFIER, $1);
+			parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER, $1);
 		} else {
 			$$ = scm_car ($1);
-			parser->lexer_->push_extra_token (SCM_IDENTIFIER,
+			parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER,
 							  scm_cdr ($1));
 		}
 	}
@@ -2325,55 +2475,44 @@ symbol:
 
 scalar:
 	embedded_scm_arg
+	| pitch_or_music
 	| SCM_IDENTIFIER
 	| bare_number
-	| FRACTION
-	| lyric_element
-	;
-
-scalar_closed:
-	embedded_scm_arg_closed
-	| SCM_IDENTIFIER
-	| bare_number
-	| FRACTION
-	| lyric_element
+	// The following is a rather defensive variant of admitting
+	// negative numbers: the grammar would permit number_factor or
+	// even number_expression.  However, function arguments allow
+	// only this simple kind of negative number, so to have things
+	// like \tweak and \override behave reasonably similar, it
+	// makes sense to rule out things like -- which are rather an
+	// accent in function argument contexts.
+	| '-' bare_number
+	{
+		$$ = scm_difference ($2, SCM_UNDEFINED);
+	}
+	| string
 	;
 
-
 event_chord:
 	simple_element post_events {
 		// Let the rhythmic music iterator sort this mess out.
 		if (scm_is_pair ($2)) {
-		        $$ = make_music_from_simple (parser, @1, $1);
-			if (unsmob_music ($$))
-                                unsmob_music ($$)->set_property ("articulations",
-                                                                 scm_reverse_x ($2, SCM_EOL));
-                        else
-                                parser->parser_error (@1, _("music expected"));
+			unsmob_music ($$)->set_property ("articulations",
+							 scm_reverse_x ($2, SCM_EOL));
 		}
-	}
-	| simple_chord_elements post_events	{
-		SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
-
-		Input i;
-		/* why is this giving wrong start location? -ns
-		 * i = @$; */
-		i.set_location (@1, @2);
-		$$ = MAKE_SYNTAX ("event-chord", i, elts);
-	}
+	} %prec ':'
 	| CHORD_REPETITION optional_notemode_duration post_events {
 		Input i;
 		i.set_location (@1, @3);
 		$$ = MAKE_SYNTAX ("repetition-chord", i,
 				  $2, scm_reverse_x ($3, SCM_EOL));
-	}
+	} %prec ':'
 	| MULTI_MEASURE_REST optional_notemode_duration post_events {
 		Input i;
 		i.set_location (@1, @3);
 		$$ = MAKE_SYNTAX ("multi-measure-rest", i, $2,
 				  scm_reverse_x ($3, SCM_EOL));
-	}
-	| command_element
+	} %prec ':'
+	| tempo_event
 	| note_chord_element
 	;
 
@@ -2393,7 +2532,7 @@ note_chord_element:
 		m-> set_property ("elements", es);
 		m->set_spot (@$);
 		$$ = m->self_scm ();
-	}
+	} %prec ':'
 	;
 
 chord_body:
@@ -2469,38 +2608,13 @@ music_function_chord_body:
 	| MUSIC_IDENTIFIER
 	;
 
-// Event functions may only take closed arglists, otherwise it would
-// not be clear whether a following postevent should be associated
-// with the last argument of the event function or with the expression
-// for which the function call acts itself as event.
-
-music_function_call_closed:
-	MUSIC_FUNCTION function_arglist_closed {
-		$$ = MAKE_SYNTAX ("music-function", @$,
-					 $1, $2);
-	}
-	;
-
 event_function_event:
-	EVENT_FUNCTION function_arglist_closed {
+	EVENT_FUNCTION function_arglist {
 		$$ = MAKE_SYNTAX ("music-function", @$,
 					 $1, $2);
 	}
 	;
 
-command_element:
-	command_event {
-		$$ = $1;
-	}
-	;
-
-command_event:
-	tempo_event {
-		$$ = $1;
-	}
-	;
-
-
 post_events:
 	/* empty */ {
 		$$ = SCM_EOL;
@@ -2529,7 +2643,7 @@ post_event_nofinger:
 	direction_less_event {
 		$$ = $1;
 	}
-	| script_dir music_function_call_closed {
+	| script_dir music_function_call {
 		$$ = $2;
 		if (!unsmob_music ($2)->is_mus_type ("post-event")) {
 			parser->parser_error (@2, _ ("post-event expected"));
@@ -2611,11 +2725,21 @@ direction_reqd_event:
 	}
 	| script_abbreviation {
 		SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
-		Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
-		if (scm_is_string (s))
+		if (scm_is_string (s)) {
+			Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
 			a->set_property ("articulation-type", s);
-		else parser->parser_error (@1, _ ("expecting string as script definition"));
-		$$ = a->unprotect ();
+			$$ = a->unprotect ();
+		} else {
+			Music *original = unsmob_music (s);
+			if (original && original->is_mus_type ("post-event")) {
+				Music *a = original->clone ();
+				a->set_spot (parser->lexer_->override_input (@$));
+				$$ = a->unprotect ();
+			} else {
+				parser->parser_error (@1, _ ("expecting string or post-event as script definition"));
+				$$ = MY_MAKE_MUSIC ("PostEvents", @$)->unprotect ();
+			}
+		}
 	}
 	;
 
@@ -2679,12 +2803,14 @@ steno_tonic_pitch:
 
 pitch:
 	steno_pitch
-	| PITCH_IDENTIFIER
-	;
-
-pitch_also_in_chords:
-	pitch
-	| steno_tonic_pitch
+	| PITCH_IDENTIFIER quotes {
+                if (!scm_is_eq (SCM_INUM0, $2))
+                {
+                        Pitch p = *unsmob_pitch ($1);
+                        p = p.transposed (Pitch (scm_to_int ($2),0,0));
+                        $$ = p.smobbed_copy ();
+                }
+	}
 	;
 
 gen_text_def:
@@ -2699,7 +2825,7 @@ gen_text_def:
 			make_simple_markup ($1));
 		$$ = t->unprotect ();
 	}
-	| embedded_scm_closed
+	| embedded_scm
 	{
 		Music *m = unsmob_music ($1);
 		if (m && m->is_mus_type ("post-event"))
@@ -2760,7 +2886,7 @@ duration_length:
 maybe_notemode_duration:
 	{
 		$$ = SCM_UNDEFINED;
-	}
+	} %prec ':'
 	| multiplied_duration	{
 		$$ = $1;
 		parser->default_duration_ = *unsmob_duration ($$);
@@ -2778,14 +2904,12 @@ optional_notemode_duration:
 
 steno_duration:
 	UNSIGNED dots		{
-		int len = 0;
-                int n = scm_to_int ($1);
-		if (!is_duration (n))
-			parser->parser_error (@1, _f ("not a duration: %d", n));
-		else
-			len = intlog2 (n);
-
-		$$ = Duration (len, scm_to_int ($2)).smobbed_copy ();
+		$$ = make_duration ($1, scm_to_int ($2));
+		if (SCM_UNBNDP ($$))
+		{
+			parser->parser_error (@1, _ ("not a duration"));
+			$$ = Duration ().smobbed_copy ();
+		}
 	}
 	| DURATION_IDENTIFIER dots	{
 		Duration *d = unsmob_duration ($1);
@@ -2825,9 +2949,8 @@ tremolo_type:
 		$$ = SCM_INUM0;
 	}
 	| ':' UNSIGNED {
-                int n = scm_to_int ($2);
-		if (!is_duration (n))
-			parser->parser_error (@2, _f ("not a duration: %d", n));
+		if (SCM_UNBNDP (make_duration ($2)))
+			parser->parser_error (@2, _ ("not a duration"));
 		$$ = $2;
 	}
 	;
@@ -2940,15 +3063,16 @@ optional_rest:
 	| REST { $$ = SCM_BOOL_T; }
 	;
 
-simple_element:
-	pitch exclamations questions octave_check maybe_notemode_duration optional_rest {
+pitch_or_music:
+	pitch exclamations questions octave_check maybe_notemode_duration optional_rest post_events {
 		if (!parser->lexer_->is_note_state ())
 			parser->parser_error (@1, _ ("have to be in Note mode for notes"));
 		if (!SCM_UNBNDP ($2)
                     || !SCM_UNBNDP ($3)
                     || scm_is_number ($4)
                     || !SCM_UNBNDP ($5)
-                    || scm_is_true ($6))
+                    || scm_is_true ($6)
+		    || scm_is_pair ($7))
 		{
 			Music *n = 0;
 			if (scm_is_true ($6))
@@ -2973,11 +3097,31 @@ simple_element:
 				n->set_property ("cautionary", SCM_BOOL_T);
 			if (to_boolean ($2) || to_boolean ($3))
 				n->set_property ("force-accidental", SCM_BOOL_T);
-			
+			if (scm_is_pair ($7))
+				n->set_property ("articulations",
+						 scm_reverse_x ($7, SCM_EOL));
 			$$ = n->unprotect ();
 		}
-	}
-	| DRUM_PITCH optional_notemode_duration {
+	} %prec ':'
+	| simple_chord_elements post_events {
+		if (scm_is_pair ($2)) {
+			if (unsmob_pitch ($1))
+				$1 = make_chord_elements (@1,
+							  $1,
+							  parser->default_duration_.smobbed_copy (),
+							  SCM_EOL);
+
+			SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
+
+			$$ = MAKE_SYNTAX ("event-chord", @1, elts);
+		} else if (!unsmob_pitch ($1))
+			$$ = MAKE_SYNTAX ("event-chord", @1, $1);
+		// A mere pitch drops through.
+	} %prec ':'
+	;
+
+simple_element:
+	DRUM_PITCH optional_notemode_duration {
 		Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
 		n->set_property ("duration", $2);
 		n->set_property ("drum-type", $1);
@@ -2999,6 +3143,7 @@ simple_element:
 	}
 	;
 
+// Can return a single pitch rather than a list.
 simple_chord_elements:
 	new_chord {
                 if (!parser->lexer_->is_chord_state ())
@@ -3016,9 +3161,13 @@ simple_chord_elements:
 
 lyric_element:
 	full_markup {
+		if (!parser->lexer_->is_lyric_state ())
+			parser->parser_error (@1, _ ("markup outside of text script or \\lyricmode"));
 		$$ = $1;
 	}
 	| STRING {
+		if (!parser->lexer_->is_lyric_state ())
+			parser->parser_error (@1, _ ("unrecognized string, not in text script or \\lyricmode"));
 		$$ = $1;
 	}
 	| LYRIC_ELEMENT
@@ -3026,23 +3175,25 @@ lyric_element:
 
 lyric_element_music:
 	lyric_element optional_notemode_duration post_events {
-		if (!parser->lexer_->is_lyric_state ())
-			parser->parser_error (@1, _ ("have to be in Lyric mode for lyrics"));
 		$$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
 		if (scm_is_pair ($3))
 			unsmob_music ($$)->set_property
 				("articulations", scm_reverse_x ($3, SCM_EOL));
-	}
+	} %prec ':'
 	;
 
+// Can return a single pitch rather than a list.
 new_chord:
-	steno_tonic_pitch optional_notemode_duration   {
-		$$ = make_chord_elements (@$, $1, $2, SCM_EOL);
+	steno_tonic_pitch maybe_notemode_duration   {
+		if (SCM_UNBNDP ($2))
+			$$ = $1;
+		else
+			$$ = make_chord_elements (@$, $1, $2, SCM_EOL);
 	}
 	| steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
 		SCM its = scm_reverse_x ($4, SCM_EOL);
 		$$ = make_chord_elements (@$, $1, $2, scm_cons ($3, its));
-	}
+	} %prec ':'
 	;
 
 chord_items:
@@ -3101,10 +3252,10 @@ step_number:
 	;
 
 tempo_range:
-	UNSIGNED {
+	unsigned_number {
 		$$ = $1;
-	}
-	| UNSIGNED '-' UNSIGNED {
+	} %prec ':'
+	| unsigned_number '-' unsigned_number {
 		$$ = scm_cons ($1, $3);
 	}
 	;
@@ -3144,26 +3295,43 @@ number_factor:
 	| bare_number
 	;
 
+bare_number_common:
+	REAL
+	| NUMBER_IDENTIFIER
+	| REAL NUMBER_IDENTIFIER
+	{
+		$$ = scm_product ($1, $2);
+	}
+	;
 
 bare_number:
-	bare_number_closed
+	bare_number_common
+	| UNSIGNED
 	| UNSIGNED NUMBER_IDENTIFIER	{
 		$$ = scm_product ($1, $2);
 	}
-	| REAL NUMBER_IDENTIFIER	{
-		$$ = scm_product ($1, $2);
-	}
-	;
-
-bare_number_closed:
-	UNSIGNED
-	| REAL
-	| NUMBER_IDENTIFIER
 	;
 
 unsigned_number:
 	UNSIGNED
 	| NUMBER_IDENTIFIER
+	{
+		if (!scm_is_integer ($1)
+		    || scm_is_true (scm_negative_p ($1)))
+		{
+			parser->parser_error (@1, _("not an unsigned integer"));
+			$$ = SCM_INUM0;
+		}
+	}
+	| embedded_scm
+	{
+		if (!scm_is_integer ($1)
+		    || scm_is_true (scm_negative_p ($1)))
+		{
+			parser->parser_error (@1, _("not an unsigned integer"));
+			$$ = SCM_INUM0;
+		}
+	}
 	;
 
 exclamations:
@@ -3178,7 +3346,13 @@ exclamations:
 	;
 
 questions:
-	{ $$ = SCM_UNDEFINED; }
+// This precedence rule is rather weird.  It triggers when '!' is
+// encountered after a pitch, and is used for deciding whether to save
+// this instead for a figure modification.  This should not actually
+// occur in practice as pitches and figures are generated in different
+// modes.  Using a greedy (%right) precedence makes sure that we don't
+// get stuck in a wrong interpretation.
+	{ $$ = SCM_UNDEFINED; } %prec ':'
 	| questions '?'
         {
                 if (SCM_UNBNDP ($1))
@@ -3207,7 +3381,7 @@ full_markup:
 	;
 
 markup_top:
-	simple_markup_list {
+	markup_list {
 		$$ = scm_list_2 (ly_lily_module_constant ("line-markup"),  $1);
 	}
 	| markup_head_1_list simple_markup
@@ -3235,7 +3409,7 @@ markup_scm:
 	;
 			
 
-simple_markup_list:
+markup_list:
 	markup_composed_list {
 		$$ = $1;
 	}
@@ -3253,22 +3427,12 @@ markup_uncomposed_list:
 	{
 		$$ = $2;
 	}
-	;
-
-markup_list:
-	simple_markup_list
-	| markup_score
-	{
-		$$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $1));
-	}
-	;
-
-markup_score:
-	SCORE {
+	| SCORELINES {
 		SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
 		parser->lexer_->push_note_state (nn);
 	} '{' score_body '}' {
-		$$ = $4;
+		unsmob_score ($4)->origin ()->set_spot (@$);
+		$$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $4));
 		parser->lexer_->pop_state ();
 	}
 	;
@@ -3291,7 +3455,7 @@ markup_braced_list_body:
 	| markup_braced_list_body markup {
 		$$ = scm_cons ($2, $1);
 	}
-	| markup_braced_list_body simple_markup_list {
+	| markup_braced_list_body markup_list {
 		$$ = scm_reverse_x ($2, $1);
 	}
 	;
@@ -3306,7 +3470,7 @@ markup_command_basic_arguments:
 	EXPECT_MARKUP_LIST markup_command_list_arguments markup_list {
 	  $$ = scm_cons ($3, $2);
 	}
-	| EXPECT_SCM markup_command_list_arguments embedded_scm_closed {
+	| EXPECT_SCM markup_command_list_arguments embedded_scm {
 	  $$ = check_scheme_arg (parser, @3, $3, $2, $1);
 	}
 	| EXPECT_NO_MORE_ARGS {
@@ -3340,6 +3504,14 @@ simple_markup:
 	STRING {
 		$$ = make_simple_markup ($1);
 	}
+	| SCORE {
+		SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+		parser->lexer_->push_note_state (nn);
+	} '{' score_body '}' {
+		unsmob_score ($4)->origin ()->set_spot (@$);
+		$$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $4);
+		parser->lexer_->pop_state ();
+	}
 	| MARKUP_FUNCTION markup_command_basic_arguments {
 		$$ = scm_cons ($1, scm_reverse_x ($2, SCM_EOL));
 	}
@@ -3347,10 +3519,6 @@ simple_markup:
 	{
 		$$ = $2;
 	}
-	| markup_score
-	{
-		$$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $1);
-	}
 	;
 
 markup:
@@ -3432,6 +3600,9 @@ Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
 		*destination = p->self_scm ();
 		p->unprotect ();
 		return OUTPUT_DEF_IDENTIFIER;
+	} else if (unsmob_score (sid)) {
+		*destination = unsmob_score (sid)->clone ()->unprotect ();
+		return SCM_IDENTIFIER;
 	}
 
 	return -1;
@@ -3588,9 +3759,12 @@ make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
 					    parser->default_duration_.smobbed_copy ());
 	} else if (parser->lexer_->is_chord_state ()) {
 		if (unsmob_pitch (simple))
-			return make_chord_elements (loc, simple,
-						    parser->default_duration_.smobbed_copy (),
-						    SCM_EOL);
+			return MAKE_SYNTAX
+				("event-chord",
+				 loc,
+				 make_chord_elements (loc, simple,
+						      parser->default_duration_.smobbed_copy (),
+						      SCM_EOL));
 	}
 	return simple;
 }
@@ -3609,10 +3783,14 @@ make_simple_markup (SCM a)
 	return a;
 }
 
-bool
-is_duration (int t)
+SCM
+make_duration (SCM d, int dots)
 {
-  return t && t == 1 << intlog2 (t);
+	int t = scm_to_int (d);
+	if (t > 0 && (t & (t-1)) == 0)
+		return Duration (intlog2 (t), dots).smobbed_copy ();
+	else
+		return SCM_UNDEFINED;
 }
 
 SCM
@@ -3649,6 +3827,9 @@ yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser)
 
 	lex->lexval_ = s;
 	lex->lexloc_ = loc;
+	int tok = lex->pop_extra_token ();
+	if (tok >= 0)
+		return tok;
 	lex->prepare_for_next_token ();
 	return lex->yylex ();
 }