X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=79a4b1114f214c70cd8942e8bd6273e1e417a880;hb=4b18c6338f6ba1f899e8de1da4fa8883f7929c3c;hp=62c97b7fdf284280f6e4d3cd43f02cca38cbd115;hpb=6b592335270a7611578b2b801ddcc158781fd351;p=lilypond.git

diff --git a/lily/parser.yy b/lily/parser.yy
index 62c97b7fdf..79a4b1114f 100644
--- a/lily/parser.yy
+++ b/lily/parser.yy
@@ -62,7 +62,7 @@ deleting them.  Let's hope that a stack overflow doesn't trigger a move
 of the parse stack onto the heap. */
 
 %left PREC_BOT
-%nonassoc REPEAT
+%nonassoc REPEAT REPEAT_IDENTIFIER
 %nonassoc ALTERNATIVE
 
 /* The above precedences tackle the shift/reduce problem
@@ -80,40 +80,24 @@ 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
 
 
 
 
-%pure_parser
+%pure-parser
 %locations
 
 
@@ -157,7 +141,7 @@ 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);
 }
@@ -232,7 +216,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 +269,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"
@@ -309,16 +294,8 @@ int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
 %token DOUBLE_ANGLE_OPEN "<<"
 %token DOUBLE_ANGLE_CLOSE ">>"
 %token E_BACKSLASH "\\"
-%token E_ANGLE_CLOSE "\\>"
-%token E_CHAR "\\C[haracter]"
-%token E_CLOSE "\\)"
 %token E_EXCLAMATION "\\!"
-%token E_BRACKET_OPEN "\\["
-%token E_OPEN "\\("
-%token E_BRACKET_CLOSE "\\]"
-%token E_ANGLE_OPEN "\\<"
 %token E_PLUS "\\+"
-%token E_TILDE "\\~"
 %token EXTENDER "__"
 
 /*
@@ -329,7 +306,6 @@ If we give names, Bison complains.
 %token FIGURE_SPACE "_"
 %token HYPHEN "--"
 
-%token CHORDMODIFIERS
 %token MULTI_MEASURE_REST
 
 
@@ -338,8 +314,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?)"
@@ -352,13 +326,14 @@ If we give names, Bison complains.
 %token EMBEDDED_LILY "#{"
 
 %token BOOK_IDENTIFIER
-%token CHORDMODIFIER_PITCH
+%token CHORD_BODY_IDENTIFIER
 %token CHORD_MODIFIER
 %token CHORD_REPETITION
 %token CONTEXT_DEF_IDENTIFIER
 %token CONTEXT_MOD_IDENTIFIER
 %token DRUM_PITCH
 %token PITCH_IDENTIFIER
+%token PITCH_ARG
 %token DURATION_IDENTIFIER
 %token EVENT_IDENTIFIER
 %token EVENT_FUNCTION
@@ -374,6 +349,7 @@ If we give names, Bison complains.
 %token NUMBER_IDENTIFIER
 %token OUTPUT_DEF_IDENTIFIER
 %token REAL
+%token REPEAT_IDENTIFIER
 %token RESTNAME
 %token SCM_ARG
 %token SCM_FUNCTION
@@ -499,6 +475,7 @@ embedded_scm_bare_arg:
 	{
 		$$ = parser->lexer_->eval_scm_token ($1);
 	}
+	| FRACTION
 	| full_markup_list
 	| context_modification
 	| score_block
@@ -515,10 +492,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:
@@ -528,12 +514,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))
@@ -590,12 +616,8 @@ assignment:
 
 
 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);
@@ -618,7 +640,15 @@ identifier_init:
 			$$ = m->unprotect ();
 		}
 	}
-	| number_expression
+	;
+
+identifier_init_nonumber:
+	score_block
+	| book_block
+	| bookpart_block
+	| output_def
+	| context_def_spec_block
+	| music_assign
 	| FRACTION
 	| string
         | embedded_scm
@@ -630,12 +660,22 @@ context_def_spec_block:
 	CONTEXT '{' context_def_spec_body '}'
 		{
 		$$ = $3;
+		unsmob_context_def ($$)->origin ()->set_spot (@$);
 	}
 	;
 
 context_mod_arg:
 	embedded_scm
-	| composite_music
+	|
+	{
+		SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+		parser->lexer_->push_note_state (nn);
+	}
+	composite_music
+	{
+		parser->lexer_->pop_state ();
+		$$ = $2;
+	}
 	;
 
 context_mod_embedded:
@@ -649,6 +689,7 @@ context_mod_embedded:
 			$$ = $1;
 		else {
 			parser->parser_error (@1, _ ("not a context mod"));
+			$$ = Context_mod ().smobbed_copy ();
 		}
 	}
 	;
@@ -657,11 +698,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))
@@ -688,6 +727,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);
 	}
@@ -700,7 +740,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_);
@@ -709,7 +748,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 {
@@ -769,6 +807,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);
 	}
 	;
@@ -776,12 +815,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 {
@@ -944,16 +981,7 @@ output_def_head_with_mode_switch:
 
 music_or_context_def:
 	music_arg
-	{
-		parser->lexer_->pop_state ();
-	}
-	| CONTEXT
-	{
-		parser->lexer_->pop_state ();
-	} '{' context_def_spec_body '}'
-	{
-		$$ = $4;
-	}
+	| context_def_spec_block
 	;
 
 output_def_body:
@@ -980,6 +1008,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 {
@@ -999,12 +1028,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 ':'
 	;
 
 /*
@@ -1046,7 +1075,30 @@ music_embedded:
 			$$ = SCM_UNSPECIFIED;
 		}
 	}
-	| embedded_scm
+	| music_embedded_backup
+	{
+		$$ = $1;
+	}
+	| music_embedded_backup BACKUP lyric_element_music
+	{
+		$$ = $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:
+	embedded_scm
 	{
 		if (scm_is_eq ($1, SCM_UNSPECIFIED))
 			$$ = $1;
@@ -1057,9 +1109,12 @@ music_embedded:
 				$$ = SCM_UNSPECIFIED;
 			} else
 				$$ = $1;
-		} else {
+		} else if (parser->lexer_->is_lyric_state ()
+			   && Text_interface::is_markup ($1))
+			MYBACKUP (LYRIC_ELEMENT, $1, @1);
+		else {
 			@$.warning (_ ("Ignoring non-music expression"));
-			$$ = SCM_UNSPECIFIED;
+			$$ = $1;
 		}
 	}
 	;
@@ -1069,7 +1124,10 @@ music_arg:
 	{
 	        $$ = make_music_from_simple (parser, @1, $1);
                 if (!unsmob_music ($$))
+		{
                         parser->parser_error (@1, _ ("music expected"));
+			$$ = MAKE_SYNTAX ("void-music", @$);
+		}
 	}
 	| composite_music %prec COMPOSITE
 	;
@@ -1084,10 +1142,20 @@ repeated_music:
 	{
 		$$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, SCM_EOL);
 	}
+	| REPEAT_IDENTIFIER music
+	{
+		$$ = MAKE_SYNTAX ("repeat", @$, scm_car ($1), scm_cdr ($1),
+				  $2, SCM_EOL);
+	}
 	| REPEAT simple_string unsigned_number music ALTERNATIVE braced_music_list
 	{
 		$$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, $6);
 	}
+	| REPEAT_IDENTIFIER music ALTERNATIVE braced_music_list
+	{
+		$$ = MAKE_SYNTAX ("repeat", @$, scm_car ($1), scm_cdr ($1),
+				  $2, $4);
+	}
 	;
 
 sequential_music:
@@ -1115,7 +1183,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;
@@ -1128,8 +1200,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 {
@@ -1139,6 +1215,11 @@ context_modification:
 	}
         ;
 
+context_modification_arg:
+	embedded_scm_closed
+	| MUSIC_IDENTIFIER
+	;
+
 optional_context_mod:
         /**/ {
             $$ = SCM_EOL;
@@ -1194,71 +1275,72 @@ 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.
+ *
+ * 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.
+ *
+ * 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: a full argument list.  Optional arguments at the
- * end of the list can only be skipped by writing \default in their
- * place.
+ * Many of the basic nonterminals used for argument list scanning come
+ * in a "normal" and a "closed" flavor.  A closed expression is one
+ * that can be parsed without a lookahead token.  That makes it
+ * feasible for an optional argument that may need to be skipped:
+ * skipping can only be accomplished by pushing back the token into
+ * the lexer, and that only works when there is no lookahead token.
  *
- * function_arglist_backup: an argument list ending in an optional
- * argument that may be skipped depending on its predicate.
+ * 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_skip: an argument list _not_ ending in an optional
- * argument that is actually taken.
+ * 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.
  *
- * 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.
+ * 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
+	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 '-' UNSIGNED
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
 	{
 		SCM n = scm_difference ($5, SCM_UNDEFINED);
 		if (scm_is_true (scm_call_1 ($2, n)))
@@ -1271,13 +1353,13 @@ function_arglist_nonbackup_common:
 		}
 		
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' REAL
+	| 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_closed '-' NUMBER_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
 	{
 		$$ = check_scheme_arg (parser, @4,
 				       scm_difference ($5, SCM_UNDEFINED),
@@ -1287,27 +1369,28 @@ function_arglist_nonbackup_common:
 
 function_arglist_closed_nonbackup:
 	function_arglist_nonbackup_common
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg_closed
+	| function_arglist_closed_common
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg_closed
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number_closed
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_closed
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist SCM_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
 	{
 		$$ = check_scheme_arg (parser, @4,
 				       try_string_variants ($2, $4),
 				       $3, $2, $4);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist STRING
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
 	{
 		$$ = check_scheme_arg (parser, @4,
 				       try_string_variants ($2, $4),
 				       $3, $2, $4);
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist full_markup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
 	}
@@ -1353,14 +1436,29 @@ 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 embedded_scm_arg
 	{
-		$$ = check_scheme_arg (parser, @4, $4, $3, $2);
+		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_closed bare_number
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
 	{
 		$$ = check_scheme_arg (parser, @4, $4, $3, $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);
@@ -1376,7 +1474,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);
@@ -1393,7 +1491,7 @@ 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 STRING
 	{
 		$$ = $3;
 		SCM res = try_string_variants ($2, $4);
@@ -1410,7 +1508,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)))
@@ -1423,20 +1521,34 @@ 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.  It needs to be careful about avoiding lookahead only until
+// it has made a decision whether or not to accept the parsed entity.
+// At that point of time, music requiring lookahead to parse becomes
+// fine.
 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_closed
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
@@ -1446,7 +1558,32 @@ function_arglist_backup:
 			MYBACKUP (SCM_ARG, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep post_event_nofinger
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REPEAT simple_string unsigned_number
+	{
+		$4 = MAKE_SYNTAX ("repeat", @4, $5, $6,
+				  MY_MAKE_MUSIC ("Music", @4)->unprotect (),
+				  SCM_EOL);
+		if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			$$ = $3;
+			MYREPARSE (@4, $2, REPEAT_IDENTIFIER, scm_cons ($5, $6));
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (REPEAT_IDENTIFIER, scm_cons ($5, $6), @4);
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup chord_body
+	{
+		if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			$$ = $3;
+			MYREPARSE (@4, $2, CHORD_BODY_IDENTIFIER, $4);
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (CHORD_BODY_IDENTIFIER, $4, @4);
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
 	{
 		if (scm_is_true (scm_call_1 ($2, $4)))
 		{
@@ -1456,7 +1593,7 @@ function_arglist_backup:
 			MYBACKUP (EVENT_IDENTIFIER, $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);
@@ -1465,18 +1602,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)))
 		{
@@ -1487,7 +1631,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)))
 		{
@@ -1497,17 +1641,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))) {
@@ -1527,7 +1661,7 @@ function_arglist_backup:
 		}
 		
 	}
-	| 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))) {
@@ -1538,7 +1672,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))) {
@@ -1548,15 +1682,66 @@ function_arglist_backup:
 			MYBACKUP (NUMBER_IDENTIFIER, n, @5);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_PITCH function_arglist_keep pitch_also_in_chords
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup PITCH_IDENTIFIER
 	{
-		$$ = scm_cons ($4, $3);
+		SCM m = make_music_from_simple (parser, @4, $4);
+		if (unsmob_music (m) && scm_is_true (scm_call_1 ($2, m)))
+		{
+			MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+			$$ = $3;
+		} else if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			MYREPARSE (@4, $2, PITCH_ARG, $4);
+			$$ = $3;
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (PITCH_IDENTIFIER, $4, @4);
+		}
 	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_keep duration_length
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NOTENAME_PITCH
 	{
-		$$ = scm_cons ($4, $3);
+		SCM m = make_music_from_simple (parser, @4, $4);
+		if (unsmob_music (m) && scm_is_true (scm_call_1 ($2, m)))
+		{
+			MYREPARSE (@4, $2, NOTENAME_PITCH, $4);
+			$$ = $3;
+		} else if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			MYREPARSE (@4, $2, PITCH_ARG, $4);
+			$$ = $3;
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (NOTENAME_PITCH, $4, @4);
+		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep SCM_IDENTIFIER
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup TONICNAME_PITCH
+	{
+		SCM m = make_music_from_simple (parser, @4, $4);
+		if (unsmob_music (m) && scm_is_true (scm_call_1 ($2, m)))
+		{
+			MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+			$$ = $3;
+		} else if (scm_is_true (scm_call_1 ($2, $4)))
+		{
+			MYREPARSE (@4, $2, PITCH_ARG, $4);
+			$$ = $3;
+		} else {
+			$$ = scm_cons (loc_on_music (@3, $1), $3);
+			MYBACKUP (TONICNAME_PITCH, $4, @4);
+		}
+	}
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
+	{
+		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_backup SCM_IDENTIFIER
 	{
 		SCM res = try_string_variants ($2, $4);
 		if (!SCM_UNBNDP (res))
@@ -1571,7 +1756,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))
@@ -1586,12 +1771,27 @@ function_arglist_backup:
 			MYBACKUP (STRING, $4, @4);
 		}
 	}
-	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup BACKUP
+	| function_arglist_backup REPARSE music_assign
 	{
-		$$ = 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
+	| function_arglist_backup REPARSE pitch_arg
+	{
+		$$ = check_scheme_arg (parser, @3,
+				       $3, $1, $2);
+	}		
+	| function_arglist_backup REPARSE bare_number_common
+	{
+		$$ = check_scheme_arg (parser, @3,
+				       $3, $1, $2);
+	}
+	| function_arglist_backup REPARSE duration_length
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
@@ -1603,33 +1803,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);
 	}
-	| EXPECT_SCM function_arglist_closed_optional bare_number
+	;
+
+function_arglist_common:
+	EXPECT_NO_MORE_ARGS {
+		$$ = SCM_EOL;
+	}
+	| 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);
@@ -1644,7 +1857,12 @@ function_arglist_common:
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
 	}
-	| function_arglist_common_reparse REPARSE bare_number
+	| 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);
@@ -1706,7 +1924,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);
@@ -1723,7 +1959,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);
@@ -1732,34 +1968,34 @@ function_arglist_common_reparse:
 	;
 
 function_arglist_closed:
-	function_arglist_closed_common
-	| function_arglist_closed_nonbackup
+	function_arglist_closed_nonbackup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
+	{
+		$$ = scm_cons (loc_on_music (@4, $1), $3);
+	}
 	;
 
 function_arglist_closed_common:
-	function_arglist_bare
+	EXPECT_NO_MORE_ARGS {
+		$$ = SCM_EOL;
+	}
 	| 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
+	| EXPECT_SCM function_arglist_optional bare_number_common_closed
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $2, $1);
 	}
-	| EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER
+	| EXPECT_SCM function_arglist_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
+	| EXPECT_SCM function_arglist_optional post_event_nofinger
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $2, $1);
@@ -1769,7 +2005,7 @@ function_arglist_closed_common:
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
 	}
-	| function_arglist_common_reparse REPARSE bare_number
+	| function_arglist_common_reparse REPARSE bare_number_common_closed
 	{
 		$$ = check_scheme_arg (parser, @3,
 				       $3, $1, $2);
@@ -1781,28 +2017,19 @@ function_arglist_closed_common:
 	;
 
 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
+function_arglist_skip_backup:
+	function_arglist_backup
+	| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
 	{
-		$$ = scm_cons ($1, $3);
-	}
-	| EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_optional
-	{
-		$$ = scm_cons ($1, $3);
+		$$ = scm_cons (loc_on_music (@3, $1), $3);
 	}
 	;
 
@@ -1821,27 +2048,6 @@ 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);
 	}
 	;
 
@@ -1871,14 +2077,14 @@ complex_music:
 	;
 
 complex_music_prefix:
-	CONTEXT simple_string optional_id optional_context_mod {
+	CONTEXT symbol optional_id optional_context_mod {
                 Context_mod *ctxmod = unsmob_context_mod ($4);
                 SCM mods = SCM_EOL;
                 if (ctxmod)
                         mods = ctxmod->get_mods ();
 		$$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F);
 	}
-	| NEWCONTEXT simple_string optional_id optional_context_mod {
+	| NEWCONTEXT symbol optional_id optional_context_mod {
                 Context_mod *ctxmod = unsmob_context_mod ($4);
                 SCM mods = SCM_EOL;
                 if (ctxmod)
@@ -2002,8 +2208,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);
 	}
 	;
 
@@ -2018,13 +2224,11 @@ property_path:
 	;
 
 property_operation:
-	STRING '=' scalar {
-		$$ = scm_list_3 (ly_symbol2scm ("assign"),
-			scm_string_to_symbol ($1), $3);
+	symbol '=' scalar {
+		$$ = scm_list_3 (ly_symbol2scm ("assign"), $1, $3);
 	}
-	| UNSET simple_string {
-		$$ = scm_list_2 (ly_symbol2scm ("unset"),
-			scm_string_to_symbol ($2));
+	| UNSET symbol {
+		$$ = scm_list_2 (ly_symbol2scm ("unset"), $2);
 	}
 	| OVERRIDE property_path '=' scalar {
 		if (scm_ilength ($2) < 2) {
@@ -2066,6 +2270,13 @@ property_operation:
 // \revert Accidental.color
 
 revert_arg:
+	revert_arg_backup BACKUP symbol_list_arg
+	{
+		$$ = $3;
+	}
+	;
+
+revert_arg_backup:
 	revert_arg_part
 	{
 		if (scm_is_null ($1)
@@ -2074,20 +2285,16 @@ revert_arg:
 		else
 			MYBACKUP (SYMBOL_LIST, scm_reverse_x ($1, SCM_EOL), @1);
 	}
-	| revert_arg BACKUP symbol_list_arg
-	{
-		$$ = $3;
-	}
 	;
 
 // revert_arg_part delivers results in reverse
 revert_arg_part:
 	symbol_list_part
-	| revert_arg BACKUP SCM_ARG '.' symbol_list_part
+	| revert_arg_backup BACKUP SCM_ARG '.' symbol_list_part
 	{
 		$$ = scm_append_x (scm_list_2 ($5, $3));
 	}
-	| revert_arg BACKUP SCM_ARG symbol_list_part
+	| revert_arg_backup BACKUP SCM_ARG symbol_list_part
 	{
 		$$ = scm_append_x (scm_list_2 ($4, $3));
 	}		
@@ -2271,17 +2478,6 @@ string:
 		$$ = $1;
 	}
 	| full_markup
-	| string '+' string {
-		if (!scm_is_string ($1)) {
-			parser->parser_error (@1, (_ ("simple string expected")));
-			$1 = scm_string (SCM_EOL);
-		}
-		if (!scm_is_string ($3)) {
-			parser->parser_error (@3, (_ ("simple string expected")));
-			$3 = scm_string (SCM_EOL);
-		}
-		$$ = scm_string_append (scm_list_2 ($1, $3));
-	}
 	;
 
 simple_string: STRING {
@@ -2298,23 +2494,45 @@ simple_string: STRING {
 	}
 	;
 
-scalar:
-	embedded_scm_arg
-	| SCM_IDENTIFIER
-	| bare_number
-	| FRACTION
-	| lyric_element
+symbol:
+	STRING {
+		$$ = scm_string_to_symbol ($1);
+	}
+	| embedded_scm_bare
+	{
+		// This is a bit of overkill but makes the same
+		// routine responsible for all symbol interpretations.
+		$$ = try_string_variants (ly_lily_module_constant ("symbol?"),
+					  $1);
+		if (SCM_UNBNDP ($$))
+		{
+			parser->parser_error (@1, (_ ("symbol expected")));
+			// Generate a unique symbol in case it is used
+			// for an assignment or similar
+			$$ = scm_make_symbol (ly_string2scm ("undefined"));
+		}
+	}
 	;
 
-scalar_closed:
-	embedded_scm_arg_closed
+scalar:
+	embedded_scm_arg
 	| 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
+	| full_markup
 	;
 
-
 event_chord:
 	simple_element post_events {
 		// Let the rhythmic music iterator sort this mess out.
@@ -2324,30 +2542,39 @@ event_chord:
                                 unsmob_music ($$)->set_property ("articulations",
                                                                  scm_reverse_x ($2, SCM_EOL));
                         else
+			{
                                 parser->parser_error (@1, _("music expected"));
+				$$ = MAKE_SYNTAX ("void-music", @1);
+			}
 		}
-	}
+	} %prec ':'
 	| 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);
-	}
+		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 ':'
 	| 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));
-	}
+	} %prec ':'
 	| command_element
 	| note_chord_element
 	;
@@ -2368,7 +2595,7 @@ note_chord_element:
 		m-> set_property ("elements", es);
 		m->set_spot (@$);
 		$$ = m->self_scm ();
-	}
+	} %prec ':'
 	;
 
 chord_body:
@@ -2376,6 +2603,7 @@ chord_body:
 	{
 		$$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
 	}
+	| CHORD_BODY_IDENTIFIER
 	;
 
 chord_body_elements:
@@ -2467,40 +2695,10 @@ command_element:
 	command_event {
 		$$ = $1;
 	}
-	| E_BRACKET_OPEN {
-		Music *m = MY_MAKE_MUSIC ("LigatureEvent", @$);
-		m->set_property ("span-direction", scm_from_int (START));
-		$$ = m->unprotect();
-	}
-	| E_BRACKET_CLOSE {
-		Music *m = MY_MAKE_MUSIC ("LigatureEvent", @$);
-		m->set_property ("span-direction", scm_from_int (STOP));
-		$$ = m->unprotect ();
-	}
-	| E_BACKSLASH {
-		$$ = MAKE_SYNTAX ("voice-separator", @$);
-	}
-	| '|'      {
-		SCM pipe = parser->lexer_->lookup_identifier ("pipeSymbol");
-
-		Music *m = unsmob_music (pipe);
-		if (m)
-		{
-			m = m->clone ();
-			m->set_spot (@$);
-			$$ = m->unprotect ();
-		}
-		else
-			$$ = MAKE_SYNTAX ("bar-check", @$);
-
-	}
 	;
 
 command_event:
-	E_TILDE {
-		$$ = MY_MAKE_MUSIC ("PesOrFlexaEvent", @$)->unprotect ();
-	}
-	| tempo_event {
+	tempo_event {
 		$$ = $1;
 	}
 	;
@@ -2597,55 +2795,8 @@ string_number_event:
 	}
 	;
 
-direction_less_char:
-	'['  {
-		$$ = ly_symbol2scm ("bracketOpenSymbol");
-	}
-	| ']'  {
-		$$ = ly_symbol2scm ("bracketCloseSymbol");
-	}
-	| '~'  {
-		$$ = ly_symbol2scm ("tildeSymbol");
-	}
-	| '('  {
-		$$ = ly_symbol2scm ("parenthesisOpenSymbol");
-	}
-	| ')'  {
-		$$ = ly_symbol2scm ("parenthesisCloseSymbol");
-	}
-	| E_EXCLAMATION  {
-		$$ = ly_symbol2scm ("escapedExclamationSymbol");
-	}
-	| E_OPEN  {
-		$$ = ly_symbol2scm ("escapedParenthesisOpenSymbol");
-	}
-	| E_CLOSE  {
-		$$ = ly_symbol2scm ("escapedParenthesisCloseSymbol");
-	}
-	| E_ANGLE_CLOSE  {
-		$$ = ly_symbol2scm ("escapedBiggerSymbol");
-	}
-	| E_ANGLE_OPEN  {
-		$$ = ly_symbol2scm ("escapedSmallerSymbol");
-	}
-	;
-
 direction_less_event:
-	direction_less_char {
-		SCM predefd = parser->lexer_->lookup_identifier_symbol ($1);
-		Music *m = 0;
-		if (unsmob_music (predefd))
-		{
-			m = unsmob_music (predefd)->clone ();
-			m->set_spot (@$);
-		}
-		else
-		{
-			m = MY_MAKE_MUSIC ("Music", @$);
-		}
-		$$ = m->unprotect ();
-	}
-	| string_number_event
+	string_number_event
 	| EVENT_IDENTIFIER	{
 		$$ = $1;
 	}
@@ -2663,11 +2814,18 @@ 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 if (ly_prob_type_p (s, ly_symbol2scm ("ArticulationEvent"))) {
+			$$ = s;
+			if (Music *original = unsmob_music (s)) {
+				Music *a = original->clone ();
+				a->set_spot (parser->lexer_->override_input (@$));
+				$$ = a->unprotect ();
+			}
+		} else parser->parser_error (@1, _ ("expecting string or ArticulationEvent as script definition"));
 	}
 	;
 
@@ -2731,12 +2889,25 @@ steno_tonic_pitch:
 
 pitch:
 	steno_pitch
-	| PITCH_IDENTIFIER
+	| 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 ();
+                }
+	}
 	;
 
-pitch_also_in_chords:
-	pitch
-	| steno_tonic_pitch
+pitch_arg:
+	PITCH_ARG 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:
@@ -2783,8 +2954,8 @@ script_abbreviation:
 	| '-' 		{
 		$$ = scm_from_locale_string ("Dash");
 	}
- 	| '|'		{
-		$$ = scm_from_locale_string ("Bar");
+ 	| '!'		{
+		$$ = scm_from_locale_string ("Bang");
 	}
 	| ANGLE_CLOSE	{
 		$$ = scm_from_locale_string ("Larger");
@@ -2812,7 +2983,7 @@ duration_length:
 maybe_notemode_duration:
 	{
 		$$ = SCM_UNDEFINED;
-	}
+	} %prec ':'
 	| multiplied_duration	{
 		$$ = $1;
 		parser->default_duration_ = *unsmob_duration ($$);
@@ -2830,14 +3001,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);
@@ -2877,9 +3046,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;
 	}
 	;
@@ -2941,38 +3109,23 @@ bass_figure:
 	}
 	| bass_figure figured_bass_modification  {
 		Music *m = unsmob_music ($1);
-		if ($2 == ly_symbol2scm ("plus"))
-			{
-			m->set_property ("augmented", SCM_BOOL_T);
-			}
-		else if ($2 == ly_symbol2scm ("slash"))
-			{
-			m->set_property ("diminished", SCM_BOOL_T);
-			}
-		else if ($2 == ly_symbol2scm ("exclamation"))
-			{
-			m->set_property ("no-continuation", SCM_BOOL_T);
-			}
-		else if ($2 == ly_symbol2scm ("backslash"))
-			{
-			m->set_property ("augmented-slash", SCM_BOOL_T);
-			}
+		m->set_property ($2, SCM_BOOL_T);
 	}
 	;
 
 
 figured_bass_modification:
 	E_PLUS		{
-		$$ = ly_symbol2scm ("plus");
+		$$ = ly_symbol2scm ("augmented");
 	}
 	| E_EXCLAMATION {
-		$$ = ly_symbol2scm ("exclamation");
+		$$ = ly_symbol2scm ("no-continuation");
 	}
 	| '/'		{
-		$$ = ly_symbol2scm ("slash");
+		$$ = ly_symbol2scm ("diminished");
 	}
 	| E_BACKSLASH {
-		$$ = ly_symbol2scm ("backslash");
+		$$ = ly_symbol2scm ("augmented-slash");
 	}
 	;
 
@@ -3066,6 +3219,7 @@ simple_element:
 	}
 	;
 
+// Can return a single pitch rather than a list.
 simple_chord_elements:
 	new_chord {
                 if (!parser->lexer_->is_chord_state ())
@@ -3083,9 +3237,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
@@ -3093,23 +3251,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:
@@ -3168,10 +3328,10 @@ step_number:
 	;
 
 tempo_range:
-	UNSIGNED {
+	unsigned_number {
 		$$ = $1;
-	}
-	| UNSIGNED '~' UNSIGNED {
+	} %prec ':'
+	| unsigned_number '-' unsigned_number {
 		$$ = scm_cons ($1, $3);
 	}
 	;
@@ -3211,26 +3371,52 @@ number_factor:
 	| bare_number
 	;
 
+bare_number_common:
+	bare_number_common_closed
+	| REAL NUMBER_IDENTIFIER
+	{
+		$$ = scm_product ($1, $2);
+	}
+	;
+
+bare_number_common_closed:
+	REAL
+	| NUMBER_IDENTIFIER
+	;
 
 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
+	| bare_number_common_closed
 	;
 
 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:
@@ -3274,7 +3460,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
@@ -3302,7 +3488,7 @@ markup_scm:
 	;
 			
 
-simple_markup_list:
+markup_list:
 	markup_composed_list {
 		$$ = $1;
 	}
@@ -3320,22 +3506,11 @@ 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;
+		$$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $4));
 		parser->lexer_->pop_state ();
 	}
 	;
@@ -3358,7 +3533,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);
 	}
 	;
@@ -3407,6 +3582,13 @@ simple_markup:
 	STRING {
 		$$ = make_simple_markup ($1);
 	}
+	| SCORE {
+		SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+		parser->lexer_->push_note_state (nn);
+	} '{' score_body '}' {
+		$$ = 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));
 	}
@@ -3414,10 +3596,6 @@ simple_markup:
 	{
 		$$ = $2;
 	}
-	| markup_score
-	{
-		$$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $1);
-	}
 	;
 
 markup:
@@ -3655,9 +3833,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;
 }
@@ -3676,10 +3857,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