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
%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
#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);
}
%{
-#define MY_MAKE_MUSIC(x, spot) make_music_with_input (ly_symbol2scm (x), spot)
+#define MY_MAKE_MUSIC(x, spot) \
+ make_music_with_input (ly_symbol2scm (x), \
+ parser->lexer_->override_input (spot))
/* ES TODO:
- Don't use lily module, create a new module instead.
#define LOWLEVEL_MAKE_SYNTAX(proc, args) \
scm_apply_0 (proc, args)
/* Syntactic Sugar. */
-#define MAKE_SYNTAX(name, location, ...) \
- LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_input (location) , ##__VA_ARGS__, SCM_UNDEFINED))
+#define MAKE_SYNTAX(name, location, ...) \
+ LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_input (parser->lexer_->override_input (location)), ##__VA_ARGS__, SCM_UNDEFINED))
#define START_MAKE_SYNTAX(name, ...) \
scm_list_n (ly_lily_module_constant (name) , ##__VA_ARGS__, SCM_UNDEFINED)
#define FINISH_MAKE_SYNTAX(start, location, ...) \
- LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons2 (parser->self_scm (), make_input (location), scm_append_x (scm_list_2 (scm_cdr (start), scm_list_n (__VA_ARGS__, SCM_UNDEFINED)))))
+ LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons2 (parser->self_scm (), make_input (parser->lexer_->override_input (location)), scm_append_x (scm_list_2 (scm_cdr (start), scm_list_n (__VA_ARGS__, SCM_UNDEFINED)))))
SCM get_next_unique_context_id ();
SCM get_next_unique_lyrics_context_id ();
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);
%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 "__"
/*
%token FIGURE_SPACE "_"
%token HYPHEN "--"
-%token CHORDMODIFIERS
%token MULTI_MEASURE_REST
/* 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?)"
%token EMBEDDED_LILY "#{"
%token BOOK_IDENTIFIER
-%token CHORDMODIFIER_PITCH
+%token CHORD_BODY_IDENTIFIER
%token CHORD_MODIFIER
%token CHORD_REPETITION
%token CONTEXT_DEF_IDENTIFIER
%token NUMBER_IDENTIFIER
%token OUTPUT_DEF_IDENTIFIER
%token REAL
+%token REPEAT_IDENTIFIER
%token RESTNAME
%token SCM_ARG
%token SCM_FUNCTION
| 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:
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
| output_def
| context_def_spec_block
| music_assign
- | post_event_nofinger
+ | post_event_nofinger 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 ();
+ }
+ }
| number_expression
| FRACTION
| string
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:
$$ = $1;
else {
parser->parser_error (@1, _ ("not a context mod"));
+ $$ = Context_mod ().smobbed_copy ();
}
}
;
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))
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);
}
{
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_);
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 {
bookpart_block:
BOOKPART '{' bookpart_body '}' {
$$ = $3;
+ unsmob_book ($$)->origin ()->set_spot (@$);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
}
;
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 {
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:
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 {
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 ':'
;
/*
music_embedded:
music
- | embedded_scm
{
- if (unsmob_music ($1)
- || scm_is_eq ($1, SCM_UNSPECIFIED))
+ if (unsmob_music ($1)->is_mus_type ("post-event")) {
+ parser->parser_error (@1, _ ("unexpected post-event"));
+ $$ = SCM_UNSPECIFIED;
+ }
+ }
+ | music_embedded_backup
+ {
+ $$ = $1;
+ }
+ | music_embedded_backup BACKUP lyric_element_music
+ {
+ $$ = $3;
+ }
+ ;
+
+music_embedded_backup:
+ embedded_scm
+ {
+ if (scm_is_eq ($1, SCM_UNSPECIFIED))
$$ = $1;
- else
- {
+ else if (Music *m = unsmob_music ($1)) {
+ if (m->is_mus_type ("post-event")) {
+ parser->parser_error
+ (@1, _ ("unexpected post-event"));
+ $$ = SCM_UNSPECIFIED;
+ } else
+ $$ = $1;
+ } 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;
}
}
;
{
$$ = make_music_from_simple (parser, @1, $1);
if (!unsmob_music ($$))
+ {
parser->parser_error (@1, _ ("music expected"));
+ $$ = MAKE_SYNTAX ("void-music", @$);
+ }
}
| composite_music %prec COMPOSITE
;
{
$$ = 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:
;
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;
{
$$ = $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 {
}
;
+context_modification_arg:
+ embedded_scm_closed
+ | MUSIC_IDENTIFIER
+ ;
+
optional_context_mod:
/**/ {
$$ = SCM_EOL;
| 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.
+ *
+ * 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: a full argument list. Optional arguments at the
- * end of the list can only be skipped by writing \default in their
- * place.
+ * 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_backup: an argument list ending in an optional
- * argument that may be skipped depending on its predicate.
+ * 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_skip: an argument list _not_ ending in an optional
- * argument that is actually taken.
+ * 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.
*
- * 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 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
+ EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup 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)))
}
}
- | 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),
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);
}
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);
;
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);
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);
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)))
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:
+ function_arglist_backup_common
+ | function_arglist_common
;
-function_arglist_backup:
- EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep embedded_scm_arg_closed
+function_arglist_backup_common:
+ EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg_closed
{
if (scm_is_true (scm_call_1 ($2, $4)))
{
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)))
{
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);
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)))
{
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)))
{
MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep FRACTION
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup FRACTION
{
if (scm_is_true (scm_call_1 ($2, $4)))
{
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))) {
}
}
- | 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))) {
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))) {
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);
+ 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_DURATION function_arglist_closed_keep duration_length
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NOTENAME_PITCH
{
- $$ = scm_cons ($4, $3);
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ MYREPARSE (@4, $2, NOTENAME_PITCH, $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
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $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))
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))
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_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);
;
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_skip_nonbackup:
+ function_arglist_nonbackup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
+ {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ }
;
function_arglist_common:
- function_arglist_bare
+ 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_closed_optional bare_number
+ | EXPECT_SCM function_arglist_optional bare_number_common
{
$$ = check_scheme_arg (parser, @3,
$3, $2, $1);
$$ = 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);
$$ = 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);
// 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);
}
}
- | EXPECT_SCM function_arglist_closed_optional '-' REAL
+ | EXPECT_SCM function_arglist_optional '-' REAL
{
$$ = $2;
SCM n = scm_difference ($4, SCM_UNDEFINED);
;
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
+ | EXPECT_SCM function_arglist_optional post_event_nofinger
{
$$ = check_scheme_arg (parser, @3,
$3, $2, $1);
$$ = 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);
;
function_arglist_optional:
- function_arglist_keep %prec FUNCTION_ARGLIST
- | function_arglist_backup BACKUP
- | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_optional
+ function_arglist_backup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
{
- $$ = scm_cons ($1, $3);
- }
- | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_optional
- {
- $$ = 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);
}
;
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);
}
;
;
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)
;
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) {
// \revert Accidental.color
revert_arg:
+ revert_arg_backup BACKUP symbol_list_arg
+ {
+ $$ = $3;
+ }
+ ;
+
+revert_arg_backup:
revert_arg_part
{
if (scm_is_null ($1)
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));
}
$$ = $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 {
}
;
-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
+ // 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);
+ }
| FRACTION
- | lyric_element
+ | STRING
+ | full_markup
;
-
event_chord:
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
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));
* 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));
- }
+ } %prec ':'
| command_element
| note_chord_element
;
m-> set_property ("elements", es);
m->set_spot (@$);
$$ = m->self_scm ();
- }
+ } %prec ':'
;
chord_body:
{
$$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
}
+ | CHORD_BODY_IDENTIFIER
;
chord_body_elements:
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;
}
;
$$ = SCM_EOL;
}
| post_events post_event {
- unsmob_music ($2)->set_spot (@2);
- $$ = scm_cons ($2, $$);
+ $$ = $1;
+ if (Music *m = unsmob_music ($2))
+ {
+ if (m->is_mus_type ("post-event-wrapper"))
+ {
+ for (SCM p = m->get_property ("elements");
+ scm_is_pair (p);
+ p = scm_cdr (p))
+ {
+ $$ = scm_cons (scm_car (p), $$);
+ }
+ } else {
+ m->set_spot (@2);
+ $$ = scm_cons ($2, $$);
+ }
+ }
}
;
}
| script_dir music_function_call_closed {
$$ = $2;
- if (!SCM_UNBNDP ($1))
+ if (!unsmob_music ($2)->is_mus_type ("post-event")) {
+ parser->parser_error (@2, _ ("post-event expected"));
+ $$ = SCM_UNSPECIFIED;
+ } else if (!SCM_UNBNDP ($1))
{
unsmob_music ($$)->set_property ("direction", $1);
}
}
;
-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;
}
| PITCH_IDENTIFIER
;
-pitch_also_in_chords:
- pitch
- | steno_tonic_pitch
- ;
-
gen_text_def:
full_markup {
Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
| '-' {
$$ = scm_from_locale_string ("Dash");
}
- | '|' {
- $$ = scm_from_locale_string ("Bar");
+ | '!' {
+ $$ = scm_from_locale_string ("Bang");
}
| ANGLE_CLOSE {
$$ = scm_from_locale_string ("Larger");
maybe_notemode_duration:
{
$$ = SCM_UNDEFINED;
- }
+ } %prec ':'
| multiplied_duration {
$$ = $1;
parser->default_duration_ = *unsmob_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);
$$ = 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;
}
;
}
| 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");
}
;
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
if (scm_is_pair ($3))
unsmob_music ($$)->set_property
("articulations", scm_reverse_x ($3, SCM_EOL));
- }
+ } %prec ':'
;
new_chord:
| 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:
UNSIGNED {
$$ = $1;
}
- | UNSIGNED '~' UNSIGNED {
+ | UNSIGNED '-' UNSIGNED {
$$ = scm_cons ($1, $3);
}
;
| 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:
;
markup_top:
- markup_list {
+ simple_markup_list {
$$ = scm_list_2 (ly_lily_module_constant ("line-markup"), $1);
}
- | markup_head_1_list simple_markup {
- $$ = scm_car (scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, scm_list_1 ($2)));
+ | markup_head_1_list simple_markup
+ {
+ $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
+ @2, $1, scm_list_1 ($2)));
}
| simple_markup {
$$ = $1;
;
-markup_list:
+simple_markup_list:
markup_composed_list {
$$ = $1;
}
- | markup_braced_list {
+ | markup_uncomposed_list
+ ;
+
+markup_uncomposed_list:
+ markup_braced_list {
$$ = $1;
}
| markup_command_list {
}
;
-markup_composed_list:
- markup_head_1_list markup_braced_list {
- $$ = scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, $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 {
+ SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+ parser->lexer_->push_note_state (nn);
+ } '{' score_body '}' {
+ $$ = $4;
+ parser->lexer_->pop_state ();
+ }
+ ;
+
+markup_composed_list:
+ markup_head_1_list markup_uncomposed_list {
+ $$ = MAKE_SYNTAX ("composed-markup-list",
+ @2, $1, $2);
}
;
| markup_braced_list_body markup {
$$ = scm_cons ($2, $1);
}
- | markup_braced_list_body markup_list {
+ | markup_braced_list_body simple_markup_list {
$$ = scm_reverse_x ($2, $1);
}
;
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));
}
{
$$ = $2;
}
+ | markup_score
+ {
+ $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $1);
+ }
;
markup:
- markup_head_1_list simple_markup {
- SCM mapper = ly_lily_module_constant ("map-markup-command-list");
- $$ = scm_car (scm_call_2 (mapper, $1, scm_list_1 ($2)));
+ markup_head_1_list simple_markup
+ {
+ $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
+ @2, $1, scm_list_1 ($2)));
}
| simple_markup {
$$ = $1;
} else if (Music *mus = unsmob_music (sid)) {
mus = mus->clone ();
*destination = mus->self_scm ();
- unsmob_music (*destination)->
- set_property ("origin", make_input (last_input_));
-
bool is_event = mus->is_mus_type ("post-event");
mus->unprotect ();
return is_event ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
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
projects / lilypond.git / blobdiff