/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1997--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1997--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
LilyPond is free software: you can redistribute it and/or modify
#define YYLLOC_DEFAULT(Current,Rhs,N) \
((Current).set_location ((Rhs)[1], (Rhs)[N]))
-#define YYPRINT(file, type, value) \
- do { \
- if (scm_is_eq (value, SCM_UNSPECIFIED)) \
- break; \
- char *p = scm_to_locale_string \
- (scm_simple_format (SCM_BOOL_F, \
- scm_from_locale_string ("~S"), \
- scm_list_1 (value))); \
- fputs (p, file); \
- free (p); \
- } while (0)
+#define YYPRINT(file, type, value) \
+ do { \
+ if (scm_is_eq (value, SCM_UNSPECIFIED)) \
+ break; \
+ SCM s = scm_call_2 (ly_lily_module_constant ("value->lily-string"), \
+ value, \
+ parser->self_scm ()); \
+ char *p = scm_to_locale_string (s); \
+ fputs (p, file); \
+ free (p); \
+ } while (0)
%}
of the parse stack onto the heap. */
%left PREC_BOT
-%nonassoc REPEAT REPEAT_IDENTIFIER
+%nonassoc REPEAT
%nonassoc ALTERNATIVE
/* The above precedences tackle the shift/reduce problem
%left ADDLYRICS
%right ':' UNSIGNED REAL E_UNSIGNED EVENT_IDENTIFIER EVENT_FUNCTION '^' '_'
- HYPHEN EXTENDER DURATION_IDENTIFIER
+ HYPHEN EXTENDER DURATION_IDENTIFIER '!'
/* The above are needed for collecting tremoli and other items (that
could otherwise be interpreted as belonging to the next function
parser->parser_error (*i, s);
}
+// The following are somewhat precarious constructs as they may change
+// the value of the lookahead token. That implies that the lookahead
+// token must not yet have made an impact on the state stack other
+// than causing the reduction of the current rule, or switching the
+// lookahead token while Bison is mulling it over will cause trouble.
+
#define MYBACKUP(Token, Value, Location) \
-do \
- if (yychar == YYEMPTY) \
- { \
+ do { \
+ if (yychar != YYEMPTY) \
+ parser->lexer_->push_extra_token \
+ (yylloc, yychar, yylval); \
if (Token) \
- parser->lexer_->push_extra_token (Token, Value); \
- parser->lexer_->push_extra_token (BACKUP); \
- } else { \
- parser->parser_error \
- (Location, _("Too much lookahead")); \
- } \
-while (0)
+ parser->lexer_->push_extra_token \
+ (Location, Token, Value); \
+ parser->lexer_->push_extra_token (Location, BACKUP); \
+ yychar = YYEMPTY; \
+ } while (0)
#define MYREPARSE(Location, Pred, Token, Value) \
-do \
- if (yychar == YYEMPTY) \
- { \
- parser->lexer_->push_extra_token (Token, Value); \
- parser->lexer_->push_extra_token (REPARSE, \
- Pred); \
- } else { \
- parser->parser_error \
- (Location, _("Too much lookahead")); \
- } \
-while (0)
+ do { \
+ if (yychar != YYEMPTY) \
+ parser->lexer_->push_extra_token \
+ (yylloc, yychar, yylval); \
+ parser->lexer_->push_extra_token \
+ (Location, Token, Value); \
+ parser->lexer_->push_extra_token \
+ (Location, REPARSE, Pred); \
+ yychar = YYEMPTY; \
+ } while (0)
%}
%token EMBEDDED_LILY "#{"
%token BOOK_IDENTIFIER
-%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 MUSIC_IDENTIFIER
%token NOTENAME_PITCH
%token NUMBER_IDENTIFIER
-%token OUTPUT_DEF_IDENTIFIER
%token REAL
-%token REPEAT_IDENTIFIER
%token RESTNAME
%token SCM_ARG
%token SCM_FUNCTION
SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler");
scm_call_2 (proc, parser->self_scm (), $1);
}
+ | BOOK_IDENTIFIER {
+ SCM proc = parser->lexer_->lookup_identifier
+ (unsmob_book($1)->paper_
+ ? "toplevel-book-handler"
+ : "toplevel-bookpart-handler");
+ scm_call_2 (proc, parser->self_scm (), $1);
+ }
| score_block {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
scm_call_2 (proc, parser->self_scm (), $1);
}
| SCM_TOKEN {
// Evaluate and ignore #xxx, as opposed to \xxx
- parser->lexer_->eval_scm_token ($1);
+ parser->lexer_->eval_scm_token ($1, @1);
}
| embedded_scm_active
{
{
SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
scm_call_2 (proc, parser->self_scm (), out);
+ } else if (unsmob_score ($1))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
+ scm_call_2 (proc, parser->self_scm (), $1);
} else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
parser->parser_error (@1, _("bad expression type"));
}
embedded_scm_bare:
SCM_TOKEN
{
- $$ = parser->lexer_->eval_scm_token ($1);
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
}
| SCM_IDENTIFIER
;
SCM_ARG
| SCM_TOKEN
{
- $$ = parser->lexer_->eval_scm_token ($1);
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
}
+ | FRACTION
| full_markup_list
| context_modification
| score_block
parser->lexer_->set_identifier (path, $4);
$$ = SCM_UNSPECIFIED;
}
+ | assignment_id '.' property_path '=' identifier_init {
+ SCM path = scm_cons (scm_string_to_symbol ($1), $3);
+ parser->lexer_->set_identifier (path, $5);
+ $$ = SCM_UNSPECIFIED;
+ }
;
| output_def
| context_def_spec_block
| music_assign
+ | pitch_or_music
| FRACTION
| string
| embedded_scm
context_def_spec_block:
CONTEXT '{' context_def_spec_body '}'
- {
+ {
$$ = $3;
- unsmob_context_def ($$)->origin ()->set_spot (@$);
+ Context_def *td = unsmob_context_def ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob_context_def ($$);
+ }
+ td->origin ()->set_spot (@$);
}
;
}
;
-context_mod_embedded:
- context_mod_arg
- {
- if (unsmob_music ($1)) {
- SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
- $1 = scm_call_2 (proc, parser->self_scm (), $1);
- }
- if (unsmob_context_mod ($1))
- $$ = $1;
- else {
- parser->parser_error (@1, _ ("not a context mod"));
- $$ = Context_mod ().smobbed_copy ();
- }
- }
- ;
-
context_def_spec_body:
/**/ {
- $$ = Context_def::make_scm ();
- }
- | CONTEXT_DEF_IDENTIFIER {
- $$ = $1;
+ $$ = SCM_UNSPECIFIED;
}
| context_def_spec_body context_mod {
- if (!SCM_UNBNDP ($2))
+ if (!SCM_UNBNDP ($2)) {
+ Context_def *td = unsmob_context_def ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob_context_def ($$);
+ }
unsmob_context_def ($$)->add_context_mod ($2);
+ }
}
| context_def_spec_body context_modification {
Context_def *td = unsmob_context_def ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob_context_def ($$);
+ }
SCM new_mods = unsmob_context_mod ($2)->get_mods ();
for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
td->add_context_mod (scm_car (m));
}
}
- | context_def_spec_body context_mod_embedded {
- Context_def *td = unsmob_context_def ($$);
- SCM new_mods = unsmob_context_mod ($2)->get_mods ();
- for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
- td->add_context_mod (scm_car (m));
- }
+ | context_def_spec_body context_mod_arg {
+ Context_def *td = unsmob_context_def ($1);
+ if (scm_is_eq ($2, SCM_UNSPECIFIED))
+ ;
+ else if (!td && unsmob_context_def ($2))
+ $$ = $2;
+ else {
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob_context_def ($$);
+ }
+ if (unsmob_music ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ }
+ if (Context_mod *cm = unsmob_context_mod ($2)) {
+ for (SCM m = cm->get_mods (); scm_is_pair (m); m = scm_cdr (m)) {
+ td->add_context_mod (scm_car (m));
+ }
+ } else
+ parser->parser_error (@2, _ ("not a context mod"));
+ }
}
;
}
| book_body SCM_TOKEN {
// Evaluate and ignore #xxx, as opposed to \xxx
- parser->lexer_->eval_scm_token ($2);
+ parser->lexer_->eval_scm_token ($2, @2);
}
| book_body embedded_scm_active
{
{
SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
scm_call_2 (proc, $1, out);
+ } else if (unsmob_score ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
+ scm_call_2 (proc, $1, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("bad expression type"));
}
}
| bookpart_body SCM_TOKEN {
// Evaluate and ignore #xxx, as opposed to \xxx
- parser->lexer_->eval_scm_token ($2);
+ parser->lexer_->eval_scm_token ($2, @2);
}
| bookpart_body embedded_scm_active
{
{
SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
scm_call_2 (proc, $1, out);
+ } else if (unsmob_score ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
+ scm_call_2 (proc, $1, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("bad expression type"));
}
score_block:
SCORE '{' score_body '}' {
+ unsmob_score ($3)->origin ()->set_spot (@$);
$$ = $3;
}
;
+score_headers:
+ /* empty */
+ {
+ $$ = SCM_EOL;
+ }
+ | score_headers
+ {
+ if (!scm_is_pair ($1)
+ || !ly_is_module (scm_car ($1)))
+ $1 = scm_cons (ly_make_module (false), $1);
+ parser->lexer_->add_scope (scm_car ($1));
+ } lilypond_header
+ {
+ $$ = $1;
+ }
+ | score_headers output_def
+ {
+ Output_def *od = unsmob_output_def ($2);
+ if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+ {
+ parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
+
+ }
+ else
+ {
+ if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+ scm_set_cdr_x ($1, scm_cons ($2, scm_cdr ($1)));
+ else
+ $$ = scm_cons ($2, $1);
+ }
+ }
+ ;
+
+
+
score_body:
- music {
+ score_headers music {
SCM scorify = ly_lily_module_constant ("scorify-music");
- $$ = scm_call_2 (scorify, $1, parser->self_scm ());
+ $$ = scm_call_2 (scorify, $2, parser->self_scm ());
- unsmob_score ($$)->origin ()->set_spot (@$);
+ if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+ {
+ unsmob_score ($$)->set_header (scm_car ($1));
+ $1 = scm_cdr ($1);
+ }
+ for (SCM p = scm_reverse_x ($1, SCM_EOL);
+ scm_is_pair (p); p = scm_cdr (p))
+ {
+ unsmob_score ($$)->
+ add_output_def (unsmob_output_def (scm_car (p)));
+ }
}
| embedded_scm_active {
- Score *score;
- if (unsmob_score ($1))
- score = new Score (*unsmob_score ($1));
- else {
- score = new Score;
+ if (!unsmob_score ($1))
+ {
+ $$ = (new Score)->unprotect ();
parser->parser_error (@1, _("score expected"));
}
- unsmob_score ($$)->origin ()->set_spot (@$);
- $$ = score->unprotect ();
}
| score_body
{
output_def:
output_def_body '}' {
- $$ = $1;
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
parser->lexer_->remove_scope ();
parser->lexer_->pop_state ();
// is still time to escape from notes mode.
music_or_context_def:
- music_arg
+ music_assign
| context_def_spec_block
;
output_def_body:
output_def_head_with_mode_switch '{' {
- $$ = $1;
- unsmob_output_def ($$)->input_origin_.set_spot (@$);
- }
- | output_def_head_with_mode_switch '{' OUTPUT_DEF_IDENTIFIER {
- Output_def *o = unsmob_output_def ($3);
- o->input_origin_.set_spot (@$);
- $$ = o->self_scm ();
- parser->lexer_->remove_scope ();
- parser->lexer_->add_scope (o->scope_);
+ unsmob_output_def ($1)->input_origin_.set_spot (@$);
+ // This is a stupid trick to mark the beginning of the
+ // body for deciding whether to allow
+ // embedded_scm_active to have an output definition
+ $$ = scm_list_1 ($1);
}
| output_def_body assignment {
-
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
}
- | output_def_body embedded_scm {
-
+ | output_def_body embedded_scm_active
+ {
+ // We don't switch into note mode for Scheme functions
+ // here. Does not seem warranted/required in output
+ // definitions.
+ if (scm_is_pair ($1))
+ {
+ Output_def *o = unsmob_output_def ($2);
+ if (o) {
+ o->input_origin_.set_spot (@$);
+ $1 = o->self_scm ();
+ parser->lexer_->remove_scope ();
+ parser->lexer_->add_scope (o->scope_);
+ $2 = SCM_UNSPECIFIED;
+ } else
+ $1 = scm_car ($1);
+ }
+ if (unsmob_context_def ($2))
+ assign_context_def (unsmob_output_def ($1), $2);
+ // Seems unlikely, but let's be complete:
+ else if (unsmob_music ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier
+ ("output-def-music-handler");
+ scm_call_3 (proc, parser->self_scm (),
+ $1, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ $$ = $1;
+ }
+ | output_def_body SCM_TOKEN {
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
}
| output_def_body
{
+ if (scm_is_pair ($1))
+ $1 = scm_car ($1);
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} music_or_context_def
scm_call_3 (proc, parser->self_scm (),
$1, $3);
}
+ $$ = $1;
}
| output_def_body error {
}
;
-music: music_arg
+music: music_assign
| lyric_element_music
+ | pitch_or_music
+ {
+ $$ = make_music_from_simple (parser, @1, $1);
+ if (!unsmob_music ($$))
+ {
+ parser->parser_error (@1, _ ("music expected"));
+ $$ = MAKE_SYNTAX ("void-music", @$);
+ }
+ }
;
music_embedded:
}
;
-music_arg:
- simple_music
- {
- $$ = make_music_from_simple (parser, @1, $1);
- if (!unsmob_music ($$))
- {
- parser->parser_error (@1, _ ("music expected"));
- $$ = MAKE_SYNTAX ("void-music", @$);
- }
- }
- | composite_music %prec COMPOSITE
- ;
-
+// music_assign does not need to contain lyrics: there are no
+// assignments in lyricmode.
music_assign:
simple_music
| composite_music %prec COMPOSITE
{
$$ = 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_arg:
- embedded_scm_closed
+ embedded_scm
| MUSIC_IDENTIFIER
;
if (md)
unsmob_context_mod ($1)->add_context_mods (md->get_mods ());
}
- | context_mod_list context_mod_embedded {
- unsmob_context_mod ($1)->add_context_mods
- (unsmob_context_mod ($2)->get_mods ());
+ | context_mod_list context_mod_arg {
+ if (scm_is_eq ($2, SCM_UNSPECIFIED))
+ ;
+ else 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))
+ unsmob_context_mod ($$)->add_context_mods
+ (unsmob_context_mod ($2)->get_mods ());
+ else {
+ parser->parser_error (@2, _ ("not a context mod"));
+ }
}
;
| music_bare
;
-/* Music that can be parsed without lookahead */
-closed_music:
- music_bare
- | complex_music_prefix closed_music
- {
- $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
- }
- | music_function_call_closed
- ;
-
music_bare:
mode_changed_music
| MUSIC_IDENTIFIER
* 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.
- *
* 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
*
*/
-function_arglist_nonbackup_common:
- EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup FRACTION
- {
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
- {
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
- {
- SCM n = scm_difference ($5, SCM_UNDEFINED);
- if (scm_is_true (scm_call_1 ($2, n)))
- $$ = scm_cons (n, $3);
- else {
- Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
- t->set_property ("digit", $5);
- $$ = check_scheme_arg (parser, @4, t->unprotect (),
- $3, $2, n);
- }
-
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
- {
- $$ = check_scheme_arg (parser, @4,
- scm_difference ($5, SCM_UNDEFINED),
- $3, $2);
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
- {
- $$ = check_scheme_arg (parser, @4,
- scm_difference ($5, SCM_UNDEFINED),
- $3, $2);
- }
- ;
-
-function_arglist_closed_nonbackup:
- function_arglist_nonbackup_common
- | 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_nonbackup bare_number_closed
- {
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
- }
- | 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_nonbackup STRING
- {
- $$ = check_scheme_arg (parser, @4,
- try_string_variants ($2, $4),
- $3, $2, $4);
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
- {
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
- }
- ;
-
symbol_list_arg:
SYMBOL_LIST
| SYMBOL_LIST '.' symbol_list_rev
function_arglist_nonbackup:
- function_arglist_nonbackup_common
- | function_arglist_common
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
+ {
+ $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
+ {
+ SCM n = scm_difference ($5, SCM_UNDEFINED);
+ if (scm_is_true (scm_call_1 ($2, n)))
+ $$ = scm_cons (n, $3);
+ else {
+ Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
+ t->set_property ("digit", $5);
+ $$ = check_scheme_arg (parser, @4, t->unprotect (),
+ $3, $2, n);
+ }
+
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
+ {
+ $$ = check_scheme_arg (parser, @4,
+ scm_difference ($5, SCM_UNDEFINED),
+ $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
+ {
+ $$ = check_scheme_arg (parser, @4,
+ scm_difference ($5, SCM_UNDEFINED),
+ $3, $2);
+ }
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg
{
if (scm_is_true (scm_call_1 ($2, $4)))
{
$$ = check_scheme_arg (parser, @4, $4, $3, $2);
}
+ | function_arglist_nonbackup_reparse REPARSE pitch_or_music
+ {
+ if (scm_is_true (scm_call_1 ($2, $3)))
+ $$ = scm_cons ($3, $1);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $1, $2);
+ }
| function_arglist_nonbackup_reparse REPARSE duration_length
{
$$ = check_scheme_arg (parser, @3, $3, $1, $2);
else
MYREPARSE (@4, $2, SCM_ARG, $4);
}
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup pitch
+ {
+ $$ = $3;
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup steno_tonic_pitch
+ {
+ $$ = $3;
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
{
$$ = $3;
;
+// function_arglist_backup can't occur at the end of an argument
+// list.
function_arglist_backup:
- function_arglist_backup_common
- | function_arglist_common
- ;
-
-function_arglist_backup_common:
- EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg_closed
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg
{
if (scm_is_true (scm_call_1 ($2, $4)))
- {
$$ = scm_cons ($4, $3);
- } else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (SCM_ARG, $4, @4);
+ else {
+ $$ = make_music_from_simple (parser, @4, $4);
+ if (scm_is_true (scm_call_1 ($2, $$)))
+ $$ = scm_cons ($$, $3);
+ else
+ {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ MYBACKUP (SCM_ARG, $4, @4);
+ }
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REPEAT simple_string unsigned_number
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
{
- $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));
+ $$ = scm_cons ($4, $3);
} else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (REPEAT_IDENTIFIER, scm_cons ($5, $6), @4);
+ MYBACKUP (EVENT_IDENTIFIER, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup chord_body
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup pitch
{
- if (scm_is_true (scm_call_1 ($2, $4)))
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
{
$$ = $3;
- MYREPARSE (@4, $2, CHORD_BODY_IDENTIFIER, $4);
- } else {
+ MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+ } else if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (CHORD_BODY_IDENTIFIER, $4, @4);
+ MYBACKUP (PITCH_IDENTIFIER, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup steno_tonic_pitch
{
- if (scm_is_true (scm_call_1 ($2, $4)))
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
{
+ $$ = $3;
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+ } else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
- } else {
+ else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (EVENT_IDENTIFIER, $4, @4);
+ MYBACKUP (TONICNAME_PITCH, $4, @4);
}
}
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup full_markup
MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup 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_backup '-' UNSIGNED
{
SCM n = scm_difference ($5, SCM_UNDEFINED);
else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
MYBACKUP (UNSIGNED, $5, @5);
- parser->lexer_->push_extra_token ('-');
+ parser->lexer_->push_extra_token (@4, '-');
}
}
MYBACKUP (NUMBER_IDENTIFIER, n, @5);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup PITCH_IDENTIFIER
- {
- if (scm_is_true (scm_call_1 ($2, $4)))
- {
- $$ = scm_cons ($4, $3);
- } else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (PITCH_IDENTIFIER, $4, @4);
- }
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NOTENAME_PITCH
- {
- 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_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)))
MYBACKUP (STRING, $4, @4);
}
}
- | function_arglist_backup REPARSE music_assign
+ | function_arglist_backup REPARSE pitch_or_music
{
if (scm_is_true (scm_call_1 ($2, $3)))
$$ = scm_cons ($3, $1);
$$ = check_scheme_arg (parser, @3,
$3, $2, $1);
}
- | EXPECT_SCM function_arglist_optional FRACTION
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
- }
| EXPECT_SCM function_arglist_optional post_event_nofinger
{
$$ = check_scheme_arg (parser, @3,
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
}
+ | function_arglist_common_reparse REPARSE pitch_or_music
+ {
+ if (scm_is_true (scm_call_1 ($2, $3)))
+ $$ = scm_cons ($3, $1);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $1, $2);
+ }
| function_arglist_common_reparse REPARSE bare_number_common
{
$$ = check_scheme_arg (parser, @3,
// know the predicate to be false.
MYREPARSE (@3, $1, SCM_ARG, $3);
}
+ | EXPECT_SCM function_arglist_optional pitch
+ {
+ $$ = $2;
+ if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple
+ (parser, @3, $3))))
+ MYREPARSE (@3, $1, PITCH_IDENTIFIER, $3);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3);
+ }
+ | EXPECT_SCM function_arglist_optional steno_tonic_pitch
+ {
+ $$ = $2;
+ if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple
+ (parser, @3, $3))))
+ MYREPARSE (@3, $1, TONICNAME_PITCH, $3);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3);
+ }
| EXPECT_SCM function_arglist_optional STRING
{
$$ = $2;
}
;
-function_arglist_closed:
- 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:
- 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_optional bare_number_common_closed
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
- }
- | EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
- {
- $$ = check_scheme_arg (parser, @3,
- scm_difference ($4, SCM_UNDEFINED),
- $2, $1);
- }
- | EXPECT_SCM function_arglist_optional post_event_nofinger
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
- }
- | EXPECT_SCM function_arglist_optional FRACTION
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
- }
- | function_arglist_common_reparse REPARSE SCM_ARG
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $1, $2);
- }
- | function_arglist_common_reparse REPARSE bare_number_common_closed
- {
- $$ = check_scheme_arg (parser, @3,
- $3, $1, $2);
- }
- | function_arglist_common_reparse REPARSE symbol_list_arg
- {
- $$ = check_scheme_arg (parser, @3, $3, $1, $2);
- }
- ;
-
function_arglist_optional:
function_arglist_backup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
}
;
-embedded_scm_closed:
- embedded_scm_bare
- | scm_function_call_closed
- ;
-
-embedded_scm_arg_closed:
- embedded_scm_bare_arg
- | scm_function_call_closed
- | closed_music
- ;
-
-scm_function_call_closed:
- SCM_FUNCTION function_arglist_closed {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
- }
- ;
-
music_function_call:
MUSIC_FUNCTION function_arglist {
$$ = MAKE_SYNTAX ("music-function", @$,
}
;
+// We must not have lookahead tokens parsed in lyric mode. In order
+// to save confusion, we take almost the same set as permitted with
+// \lyricmode and/or \lyrics. However, music identifiers are also
+// allowed, and they obviously do not require switching into lyrics
+// mode for parsing.
+
+lyric_mode_music:
+ {
+ parser->lexer_->push_lyric_state ();
+ } grouped_music_list
+ {
+ parser->lexer_->pop_state ();
+ $$ = $2;
+ }
+ | MUSIC_IDENTIFIER
+ ;
+
complex_music:
music_function_call
| repeated_music { $$ = $1; }
;
new_lyrics:
- ADDLYRICS { parser->lexer_->push_lyric_state (); }
- /*cont */
- composite_music {
- /* Can also use music at the expensive of two S/Rs similar to
- \repeat \alternative */
- parser->lexer_->pop_state ();
-
- $$ = scm_cons ($3, SCM_EOL);
+ ADDLYRICS lyric_mode_music {
+ $$ = scm_list_1 ($2);
}
- | new_lyrics ADDLYRICS {
- parser->lexer_->push_lyric_state ();
- } composite_music {
- parser->lexer_->pop_state ();
- $$ = scm_cons ($4, $1);
+ | new_lyrics ADDLYRICS lyric_mode_music {
+ $$ = scm_cons ($3, $1);
}
;
composite_music new_lyrics {
$$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL));
} %prec COMPOSITE
- | LYRICSTO simple_string {
- parser->lexer_->push_lyric_state ();
- } music {
- parser->lexer_->pop_state ();
- $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, $4);
+ | LYRICSTO simple_string lyric_mode_music {
+ $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, $3);
}
;
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);
}
;
(scm_object_property (scm_car ($1),
ly_symbol2scm ("is-grob?")))) {
$$ = ly_symbol2scm ("Bottom");
- parser->lexer_->push_extra_token (SCM_IDENTIFIER, $1);
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER, $1);
} else {
$$ = scm_car ($1);
- parser->lexer_->push_extra_token (SCM_IDENTIFIER,
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER,
scm_cdr ($1));
}
}
scalar:
embedded_scm_arg
+ | pitch_or_music
| SCM_IDENTIFIER
| bare_number
// The following is a rather defensive variant of admitting
{
$$ = scm_difference ($2, SCM_UNDEFINED);
}
- | FRACTION
- | STRING
- | full_markup
+ | string
;
event_chord:
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
if (scm_is_pair ($2)) {
- $$ = make_music_from_simple (parser, @1, $1);
- if (unsmob_music ($$))
- unsmob_music ($$)->set_property ("articulations",
- scm_reverse_x ($2, SCM_EOL));
- else
- {
- parser->parser_error (@1, _("music expected"));
- $$ = MAKE_SYNTAX ("void-music", @1);
- }
+ unsmob_music ($$)->set_property ("articulations",
+ scm_reverse_x ($2, SCM_EOL));
}
} %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);
- } %prec ':'
| CHORD_REPETITION 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
+ | tempo_event
| note_chord_element
;
{
$$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
}
- | CHORD_BODY_IDENTIFIER
;
chord_body_elements:
music_function_chord_body:
music_function_call
| MUSIC_IDENTIFIER
- ;
-
-// Event functions may only take closed arglists, otherwise it would
-// not be clear whether a following postevent should be associated
-// with the last argument of the event function or with the expression
-// for which the function call acts itself as event.
-
-music_function_call_closed:
- MUSIC_FUNCTION function_arglist_closed {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
- }
+ | embedded_scm
;
event_function_event:
- EVENT_FUNCTION function_arglist_closed {
+ EVENT_FUNCTION function_arglist {
$$ = MAKE_SYNTAX ("music-function", @$,
$1, $2);
}
;
-command_element:
- command_event {
- $$ = $1;
- }
- ;
-
-command_event:
- tempo_event {
- $$ = $1;
- }
- ;
-
-
post_events:
/* empty */ {
$$ = SCM_EOL;
direction_less_event {
$$ = $1;
}
- | script_dir music_function_call_closed {
+ | script_dir music_function_call {
$$ = $2;
if (!unsmob_music ($2)->is_mus_type ("post-event")) {
parser->parser_error (@2, _ ("post-event expected"));
}
| script_abbreviation {
SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
- Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
- if (scm_is_string (s))
+ if (scm_is_string (s)) {
+ Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
a->set_property ("articulation-type", s);
- else parser->parser_error (@1, _ ("expecting string as script definition"));
- $$ = a->unprotect ();
+ $$ = a->unprotect ();
+ } else {
+ Music *original = unsmob_music (s);
+ if (original && original->is_mus_type ("post-event")) {
+ Music *a = original->clone ();
+ a->set_spot (parser->lexer_->override_input (@$));
+ $$ = a->unprotect ();
+ } else {
+ parser->parser_error (@1, _ ("expecting string or post-event as script definition"));
+ $$ = MY_MAKE_MUSIC ("PostEvents", @$)->unprotect ();
+ }
+ }
}
;
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 ();
+ }
+ }
;
gen_text_def:
make_simple_markup ($1));
$$ = t->unprotect ();
}
- | embedded_scm_closed
+ | embedded_scm
{
Music *m = unsmob_music ($1);
if (m && m->is_mus_type ("post-event"))
tremolo_type:
':' {
- $$ = SCM_INUM0;
+ $$ = scm_from_int (parser->default_tremolo_type_);
}
| ':' UNSIGNED {
- if (SCM_UNBNDP (make_duration ($2)))
+ if (SCM_UNBNDP (make_duration ($2))) {
parser->parser_error (@2, _ ("not a duration"));
- $$ = $2;
+ $$ = scm_from_int (parser->default_tremolo_type_);
+ } else {
+ $$ = $2;
+ parser->default_tremolo_type_ = scm_to_int ($2);
+ }
}
;
| REST { $$ = SCM_BOOL_T; }
;
-simple_element:
- pitch exclamations questions octave_check maybe_notemode_duration optional_rest {
+pitch_or_music:
+ pitch exclamations questions octave_check maybe_notemode_duration optional_rest post_events {
if (!parser->lexer_->is_note_state ())
parser->parser_error (@1, _ ("have to be in Note mode for notes"));
if (!SCM_UNBNDP ($2)
|| !SCM_UNBNDP ($3)
|| scm_is_number ($4)
|| !SCM_UNBNDP ($5)
- || scm_is_true ($6))
+ || scm_is_true ($6)
+ || scm_is_pair ($7))
{
Music *n = 0;
if (scm_is_true ($6))
n->set_property ("cautionary", SCM_BOOL_T);
if (to_boolean ($2) || to_boolean ($3))
n->set_property ("force-accidental", SCM_BOOL_T);
-
+ if (scm_is_pair ($7))
+ n->set_property ("articulations",
+ scm_reverse_x ($7, SCM_EOL));
$$ = n->unprotect ();
}
- }
- | DRUM_PITCH optional_notemode_duration {
+ } %prec ':'
+ | simple_chord_elements post_events {
+ if (scm_is_pair ($2)) {
+ if (unsmob_pitch ($1))
+ $1 = make_chord_elements (@1,
+ $1,
+ parser->default_duration_.smobbed_copy (),
+ SCM_EOL);
+
+ SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
+
+ $$ = MAKE_SYNTAX ("event-chord", @1, elts);
+ } else if (!unsmob_pitch ($1))
+ $$ = MAKE_SYNTAX ("event-chord", @1, $1);
+ // A mere pitch drops through.
+ } %prec ':'
+ ;
+
+simple_element:
+ DRUM_PITCH optional_notemode_duration {
Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
n->set_property ("duration", $2);
n->set_property ("drum-type", $1);
}
;
+// Can return a single pitch rather than a list.
simple_chord_elements:
new_chord {
if (!parser->lexer_->is_chord_state ())
} %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);
;
tempo_range:
- UNSIGNED {
+ unsigned_number {
$$ = $1;
- }
- | UNSIGNED '-' UNSIGNED {
+ } %prec ':'
+ | unsigned_number '-' unsigned_number {
$$ = scm_cons ($1, $3);
}
;
;
bare_number_common:
- bare_number_common_closed
+ REAL
+ | NUMBER_IDENTIFIER
| REAL NUMBER_IDENTIFIER
{
$$ = scm_product ($1, $2);
}
;
-bare_number_common_closed:
- REAL
- | NUMBER_IDENTIFIER
- ;
-
bare_number:
bare_number_common
| UNSIGNED
}
;
-bare_number_closed:
- UNSIGNED
- | 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:
;
questions:
- { $$ = SCM_UNDEFINED; }
+// This precedence rule is rather weird. It triggers when '!' is
+// encountered after a pitch, and is used for deciding whether to save
+// this instead for a figure modification. This should not actually
+// occur in practice as pitches and figures are generated in different
+// modes. Using a greedy (%right) precedence makes sure that we don't
+// get stuck in a wrong interpretation.
+ { $$ = SCM_UNDEFINED; } %prec ':'
| questions '?'
{
if (SCM_UNBNDP ($1))
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} '{' score_body '}' {
+ Score *sc = unsmob_score ($4);
+ sc->origin ()->set_spot (@$);
+ if (sc->defs_.empty ()) {
+ Output_def *od = get_layout (parser);
+ sc->add_output_def (od);
+ od->unprotect ();
+ }
$$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $4));
parser->lexer_->pop_state ();
}
EXPECT_MARKUP_LIST markup_command_list_arguments markup_list {
$$ = scm_cons ($3, $2);
}
- | EXPECT_SCM markup_command_list_arguments embedded_scm_closed {
+ | EXPECT_SCM markup_command_list_arguments embedded_scm {
$$ = check_scheme_arg (parser, @3, $3, $2, $1);
}
| EXPECT_NO_MORE_ARGS {
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} '{' score_body '}' {
+ Score *sc = unsmob_score ($4);
+ sc->origin ()->set_spot (@$);
+ if (sc->defs_.empty ()) {
+ Output_def *od = get_layout (parser);
+ sc->add_output_def (od);
+ od->unprotect ();
+ }
$$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $4);
parser->lexer_->pop_state ();
}
} else if (scm_is_number (sid)) {
*destination = sid;
return NUMBER_IDENTIFIER;
- } else if (unsmob_context_def (sid)) {
- Context_def *def= unsmob_context_def (sid)->clone ();
-
- *destination = def->self_scm ();
- def->unprotect ();
-
- return CONTEXT_DEF_IDENTIFIER;
+ } else if (unsmob_context_def (sid))
+ {
+ *destination = unsmob_context_def (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
} else if (unsmob_context_mod (sid)) {
*destination = unsmob_context_mod (sid)->smobbed_copy ();
-
return CONTEXT_MOD_IDENTIFIER;
} else if (Music *mus = unsmob_music (sid)) {
mus = mus->clone ();
*destination = unsmob_duration (sid)->smobbed_copy ();
return DURATION_IDENTIFIER;
} else if (unsmob_output_def (sid)) {
- Output_def *p = unsmob_output_def (sid);
- p = p->clone ();
-
- *destination = p->self_scm ();
- p->unprotect ();
- return OUTPUT_DEF_IDENTIFIER;
+ *destination = unsmob_output_def (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (unsmob_score (sid)) {
+ *destination = unsmob_score (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
}
return -1;
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;
}
lex->lexval_ = s;
lex->lexloc_ = loc;
+ int tok = lex->pop_extra_token ();
+ if (tok >= 0)
+ return tok;
lex->prepare_for_next_token ();
return lex->yylex ();
}