-/* -*- mode: c++; c-file-style: "linux" -*- */
+/* -*- mode: c++; c-file-style: "linux"; indent-tabs-mode: t -*- */
/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1997--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1997--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
LilyPond is free software: you can redistribute it and/or modify
* inconsistent state of indentation.
*/
-%code requires {
+%{
#define yyerror Lily_parser::parser_error
#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)
-}
+%}
%parse-param {Lily_parser *parser}
%parse-param {SCM *retval}
%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.
- */
-
-%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 ':'
+%right ':' UNSIGNED REAL E_UNSIGNED EVENT_IDENTIFIER EVENT_FUNCTION '^' '_'
+ HYPHEN EXTENDER 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);
}
+// 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)
%}
%{
-#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 (), parser->lexer_->override_input (location).smobbed_copy (), ##__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 (), parser->lexer_->override_input (location).smobbed_copy (), 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 ();
static Music *make_music_with_input (SCM name, Input where);
SCM check_scheme_arg (Lily_parser *parser, Input loc,
- SCM arg, SCM args, SCM pred);
+ SCM arg, SCM args, SCM pred, SCM disp = SCM_UNDEFINED);
+SCM make_music_from_simple (Lily_parser *parser, Input loc, SCM pitch);
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);
-bool is_regular_identifier (SCM id);
+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);
-void set_music_properties (Music *p, SCM a);
%}
%token REST "\\rest"
%token REVERT "\\revert"
%token SCORE "\\score"
+%token SCORELINES "\\score-lines"
%token SEQUENTIAL "\\sequential"
%token SET "\\set"
%token SIMULTANEOUS "\\simultaneous"
%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 LYRIC_MARKUP
%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_MODIFIER
%token CHORD_REPETITION
-%token CONTEXT_DEF_IDENTIFIER
%token CONTEXT_MOD_IDENTIFIER
%token DRUM_PITCH
%token PITCH_IDENTIFIER
%token EVENT_IDENTIFIER
%token EVENT_FUNCTION
%token FRACTION
-%token LYRICS_STRING
%token LYRIC_ELEMENT
-%token LYRIC_MARKUP_IDENTIFIER
%token MARKUP_FUNCTION
%token MARKUP_LIST_FUNCTION
%token MARKUP_IDENTIFIER
%token MUSIC_IDENTIFIER
%token NOTENAME_PITCH
%token NUMBER_IDENTIFIER
-%token OUTPUT_DEF_IDENTIFIER
%token REAL
%token RESTNAME
+%token SCM_ARG
%token SCM_FUNCTION
%token SCM_IDENTIFIER
%token SCM_TOKEN
-%token SCORE_IDENTIFIER
%token STRING
-%token STRING_IDENTIFIER
+%token SYMBOL_LIST
%token TONICNAME_PITCH
%left '-' '+'
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
+ (Book::unsmob($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 proc = parser->lexer_->lookup_identifier ("toplevel-text-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, @1);
+ }
+ | embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($1))
+ out = scm_list_1 ($1);
+ else if (Text_interface::is_markup_list ($1))
+ out = $1;
+ if (scm_is_pair (out))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
+ scm_call_2 (proc, parser->self_scm (), out);
+ } else if (Score::is_smob ($1))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
+ scm_call_2 (proc, parser->self_scm (), $1);
+ } else if (Output_def * od = Output_def::unsmob ($1)) {
+ SCM id = SCM_EOL;
+
+ if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultpaper");
+ else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultmidi");
+ else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultlayout");
+
+ parser->lexer_->set_identifier (id, $1);
+ } else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
+ parser->parser_error (@1, _("bad expression type"));
+ }
| output_def {
SCM id = SCM_EOL;
- Output_def * od = unsmob_output_def ($1);
+ Output_def * od = Output_def::unsmob ($1);
if (od->c_variable ("is-paper") == SCM_BOOL_T)
id = ly_symbol2scm ("$defaultpaper");
embedded_scm_bare:
SCM_TOKEN
{
- $$ = parser->lexer_->eval_scm_token ($1);
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
}
| SCM_IDENTIFIER
;
+embedded_scm_active:
+ SCM_IDENTIFIER
+ | scm_function_call
+ ;
+
embedded_scm_bare_arg:
- embedded_scm_bare
- | STRING
- | STRING_IDENTIFIER
- | full_markup
+ SCM_ARG
+ | SCM_TOKEN
+ {
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
+ }
+ | FRACTION
| full_markup_list
| context_modification
| score_block
| 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_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 = Music::unsmob ($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))
+ if (Music::is_smob ($2))
$3 = scm_cons ($2, $3);
- if (unsmob_music ($1))
+ if (Music::is_smob ($1))
$3 = scm_cons ($1, $3);
$$ = MAKE_SYNTAX ("sequential-music", @$, $3);
}
/* empty */ { $$ = SCM_UNSPECIFIED; }
| lilypond_header_body assignment {
+ }
+ | lilypond_header_body embedded_scm {
+
}
;
*/
assignment_id:
STRING { $$ = $1; }
- | LYRICS_STRING { $$ = $1; }
;
assignment:
parser->lexer_->set_identifier (path, $4);
$$ = SCM_UNSPECIFIED;
}
- | embedded_scm { $$ = SCM_UNSPECIFIED; }
+ | assignment_id '.' property_path '=' identifier_init {
+ SCM path = scm_cons (scm_string_to_symbol ($1), $3);
+ parser->lexer_->set_identifier (path, $5);
+ $$ = SCM_UNSPECIFIED;
+ }
;
identifier_init:
+ identifier_init_nonumber
+ | number_expression
+ | post_event_nofinger post_events
+ {
+ $$ = scm_reverse_x ($2, SCM_EOL);
+ if (Music *m = Music::unsmob ($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 ();
+ }
+ }
+ ;
+
+identifier_init_nonumber:
score_block
| book_block
| bookpart_block
| output_def
| context_def_spec_block
| music_assign
- | post_event_nofinger
- | number_expression
+ | pitch_or_music
| FRACTION
| string
| embedded_scm
- | full_markup
| full_markup_list
| context_modification
;
context_def_spec_block:
CONTEXT '{' context_def_spec_body '}'
- {
+ {
$$ = $3;
+ Context_def *td = Context_def::unsmob ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = Context_def::unsmob ($$);
+ }
+ td->origin ()->set_spot (@$);
}
;
context_mod_arg:
embedded_scm
- | composite_music
- ;
-
-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"));
- }
+ SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+ parser->lexer_->push_note_state (nn);
+ }
+ composite_music
+ {
+ parser->lexer_->pop_state ();
+ $$ = $2;
}
;
context_def_spec_body:
/**/ {
- $$ = Context_def::make_scm ();
- unsmob_context_def ($$)->origin ()->set_spot (@$);
- }
- | CONTEXT_DEF_IDENTIFIER {
- $$ = $1;
- unsmob_context_def ($$)->origin ()->set_spot (@$);
+ $$ = SCM_UNSPECIFIED;
}
| context_def_spec_body context_mod {
- unsmob_context_def ($$)->add_context_mod ($2);
+ if (!SCM_UNBNDP ($2)) {
+ Context_def *td = Context_def::unsmob ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = Context_def::unsmob ($$);
+ }
+ Context_def::unsmob ($$)->add_context_mod ($2);
+ }
}
| context_def_spec_body context_modification {
- Context_def *td = unsmob_context_def ($$);
- SCM new_mods = unsmob_context_mod ($2)->get_mods ();
+ Context_def *td = Context_def::unsmob ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = Context_def::unsmob ($$);
+ }
+ SCM new_mods = Context_mod::unsmob ($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 = Context_def::unsmob ($1);
+ if (scm_is_eq ($2, SCM_UNSPECIFIED))
+ ;
+ else if (!td && Context_def::unsmob ($2))
+ $$ = $2;
+ else {
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = Context_def::unsmob ($$);
+ }
+ if (Music::is_smob ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ }
+ if (Context_mod *cm = Context_mod::unsmob ($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_block:
BOOK '{' book_body '}' {
$$ = $3;
+ Book::unsmob ($$)->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_ = dynamic_cast<Output_def*> (Output_def::unsmob (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
book->paper_->unprotect ();
push_paper (parser, book->paper_);
book->header_ = get_header (parser);
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 {
- unsmob_book ($1)->paper_ = unsmob_output_def ($2);
- set_paper (parser, unsmob_output_def ($2));
+ Book::unsmob ($1)->paper_ = Output_def::unsmob ($2);
+ set_paper (parser, Output_def::unsmob ($2));
}
| book_body bookpart_block {
SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler");
SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
scm_call_2 (proc, $1, $2);
}
+ | book_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | book_body embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($2))
+ out = scm_list_1 ($2);
+ else if (Text_interface::is_markup_list ($2))
+ out = $2;
+ if (scm_is_pair (out))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
+ scm_call_2 (proc, $1, out);
+ } else if (Score::is_smob ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
+ scm_call_2 (proc, $1, $2);
+ } else if (Output_def *od = Output_def::unsmob ($2)) {
+ SCM id = SCM_EOL;
+
+ if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultpaper");
+ else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultmidi");
+ else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultlayout");
+
+ parser->lexer_->set_identifier (id, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ }
| book_body
{
- parser->lexer_->add_scope (unsmob_book ($1)->header_);
+ parser->lexer_->add_scope (Book::unsmob ($1)->header_);
} lilypond_header
- | book_body embedded_scm { }
| book_body error {
- Book *book = unsmob_book ($1);
+ Book *book = Book::unsmob ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
book->bookparts_ = SCM_EOL;
bookpart_block:
BOOKPART '{' bookpart_body '}' {
$$ = $3;
+ Book::unsmob ($$)->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 {
- unsmob_book ($$)->paper_ = unsmob_output_def ($2);
+ Book::unsmob ($$)->paper_ = Output_def::unsmob ($2);
}
| bookpart_body score_block {
SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
scm_call_2 (proc, $1, $2);
}
+ | bookpart_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | bookpart_body embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($2))
+ out = scm_list_1 ($2);
+ else if (Text_interface::is_markup_list ($2))
+ out = $2;
+ if (scm_is_pair (out))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
+ scm_call_2 (proc, $1, out);
+ } else if (Score::is_smob ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
+ scm_call_2 (proc, $1, $2);
+ } else if (Output_def *od = Output_def::unsmob ($2)) {
+ SCM id = SCM_EOL;
+
+ if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultpaper");
+ else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultmidi");
+ else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ id = ly_symbol2scm ("$defaultlayout");
+
+ parser->lexer_->set_identifier (id, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ }
| bookpart_body
{
- Book *book = unsmob_book ($1);
+ Book *book = Book::unsmob ($1);
if (!ly_is_module (book->header_))
book->header_ = ly_make_module (false);
parser->lexer_->add_scope (book->header_);
} lilypond_header
- | bookpart_body embedded_scm { }
| bookpart_body error {
- Book *book = unsmob_book ($1);
+ Book *book = Book::unsmob ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
}
score_block:
SCORE '{' score_body '}' {
+ Score::unsmob ($3)->origin ()->set_spot (@$);
$$ = $3;
}
;
score_body:
- music {
- SCM scorify = ly_lily_module_constant ("scorify-music");
- $$ = scm_call_2 (scorify, $1, parser->self_scm ());
-
- unsmob_score ($$)->origin ()->set_spot (@$);
+ score_items {
+ if (!Score::is_smob ($1)) {
+ parser->parser_error (@1, _("Missing music in \\score"));
+ $$ = (new Score)->unprotect ();
+ if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+ {
+ Score::unsmob ($$)->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))
+ {
+ Score::unsmob ($$)->
+ add_output_def (Output_def::unsmob (scm_car (p)));
+ }
+ }
}
- | SCORE_IDENTIFIER {
- unsmob_score ($$)->origin ()->set_spot (@$);
+ | score_body error {
+ Score::unsmob ($$)->error_found_ = true;
}
- | score_body
- {
- Score *score = unsmob_score ($1);
- if (!ly_is_module (score->get_header ()))
- score->set_header (ly_make_module (false));
- parser->lexer_->add_scope (score->get_header ());
- } lilypond_header
- | score_body 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"));
+ ;
+
+score_item:
+ embedded_scm
+ | music
+ | output_def
+ ;
+score_items:
+ /* empty */
+ {
+ $$ = SCM_EOL;
+ }
+ | score_items score_item
+ {
+ Output_def *od = Output_def::unsmob ($2);
+ if (od) {
+ if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+ {
+ parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
+ od = 0;
+ $2 = SCM_UNSPECIFIED;
+ }
+ } else if (!Score::is_smob ($$)) {
+ if (Music::is_smob ($2)) {
+ SCM scorify = ly_lily_module_constant ("scorify-music");
+ $2 = scm_call_2 (scorify, $2, parser->self_scm ());
+ }
+ if (Score::is_smob ($2))
+ {
+ $$ = $2;
+ $2 = SCM_UNSPECIFIED;
+ }
}
- else
- {
- unsmob_score ($1)->add_output_def (od);
+ Score *score = Score::unsmob ($$);
+ if (score && scm_is_pair ($1)) {
+ if (ly_is_module (scm_car ($1)))
+ {
+ 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))
+ {
+ score->add_output_def (Output_def::unsmob (scm_car (p)));
+ }
}
+ if (od) {
+ if (score)
+ score->add_output_def (od);
+ else if (scm_is_pair ($$) && ly_is_module (scm_car ($$)))
+ scm_set_cdr_x ($$, scm_cons ($2, scm_cdr ($$)));
+ else
+ $$ = scm_cons ($2, $$);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("Spurious expression in \\score"));
}
- | score_body error {
- unsmob_score ($$)->error_found_ = true;
+ | score_items
+ {
+ if (Score *score = Score::unsmob ($1)) {
+ if (!ly_is_module (score->get_header ()))
+ score->set_header (ly_make_module (false));
+ parser->lexer_->add_scope (score->get_header ());
+ } else {
+ 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;
}
;
paper_block:
output_def {
- Output_def *od = unsmob_output_def ($1);
+ Output_def *od = Output_def::unsmob ($1);
if (od->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T)
{
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
- {
- parser->lexer_->pop_state ();
- }
- | CONTEXT
- {
- parser->lexer_->pop_state ();
- } '{' context_def_spec_body '}'
- {
- $$ = $4;
- }
+ 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_);
+ Output_def::unsmob ($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_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 = Output_def::unsmob ($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 (Context_def::is_smob ($2))
+ assign_context_def (Output_def::unsmob ($1), $2);
+ // Seems unlikely, but let's be complete:
+ else if (Music::is_smob ($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
{
- if (unsmob_context_def ($3))
- assign_context_def (unsmob_output_def ($1), $3);
+ parser->lexer_->pop_state ();
+ if (Context_def::is_smob ($3))
+ assign_context_def (Output_def::unsmob ($1), $3);
else {
SCM proc = parser->lexer_->lookup_identifier
scm_call_3 (proc, parser->self_scm (),
$1, $3);
}
+ $$ = $1;
}
| output_def_body error {
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 ':'
;
/*
$$ = SCM_EOL;
}
| music_list music_embedded {
- if (unsmob_music ($2))
+ if (Music::is_smob ($2))
$$ = scm_cons ($2, $1);
}
| music_list error {
}
;
-music: music_arg
+music: music_assign
| lyric_element_music
+ | pitch_as_music
+ ;
+
+pitch_as_music:
+ pitch_or_music
+ {
+ $$ = make_music_from_simple (parser, @1, $1);
+ if (!Music::is_smob ($$))
+ {
+ parser->parser_error (@1, _ ("music expected"));
+ $$ = MAKE_SYNTAX ("void-music", @$);
+ }
+ }
;
music_embedded:
music
- | embedded_scm
{
- if (unsmob_music ($1)
- || scm_is_eq ($1, SCM_UNSPECIFIED))
- $$ = $1;
- else
- {
- @$.warning (_ ("Ignoring non-music expression"));
+ if (Music::unsmob ($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;
+ }
+ | multiplied_duration post_events
+ {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
+
+ parser->default_duration_ = *Duration::unsmob ($1);
+ n->set_property ("duration", $1);
+
+ if (scm_is_pair ($2))
+ n->set_property ("articulations",
+ scm_reverse_x ($2, SCM_EOL));
+ $$ = n->unprotect ();
+ }
;
-music_arg:
- simple_music
+music_embedded_backup:
+ embedded_scm
{
- if (unsmob_pitch ($1)) {
- Music *n = MY_MAKE_MUSIC ("NoteEvent", @1);
- n->set_property ("pitch", $1);
- n->set_property ("duration",
- parser->default_duration_.smobbed_copy ());
- $$ = n->unprotect ();
+ if (scm_is_eq ($1, SCM_UNSPECIFIED))
+ $$ = $1;
+ else if (Music *m = Music::unsmob ($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"));
+ $$ = $1;
}
}
- | 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
- | lyric_element_music
;
repeated_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_context_mod ($2))
+ if (Music::is_smob ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ }
+ if (Context_mod::is_smob ($2))
$$ = $2;
else {
parser->parser_error (@2, _ ("not a context mod"));
}
;
+context_modification_arg:
+ embedded_scm
+ | MUSIC_IDENTIFIER
+ ;
+
optional_context_mod:
/**/ {
$$ = SCM_EOL;
$$ = Context_mod ().smobbed_copy ();
}
| context_mod_list context_mod {
- unsmob_context_mod ($1)->add_context_mod ($2);
+ if (!SCM_UNBNDP ($2))
+ Context_mod::unsmob ($1)->add_context_mod ($2);
}
| context_mod_list CONTEXT_MOD_IDENTIFIER {
- Context_mod *md = unsmob_context_mod ($2);
+ Context_mod *md = Context_mod::unsmob ($2);
if (md)
- unsmob_context_mod ($1)->add_context_mods (md->get_mods ());
+ Context_mod::unsmob ($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 (Music::is_smob ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ }
+ if (Context_mod::is_smob ($2))
+ Context_mod::unsmob ($$)->add_context_mods
+ (Context_mod::unsmob ($2)->get_mods ());
+ else {
+ parser->parser_error (@2, _ ("not a context mod"));
+ }
}
;
-composite_music:
- complex_music
+context_prefix:
+ CONTEXT symbol optional_id optional_context_mod {
+ Context_mod *ctxmod = Context_mod::unsmob ($4);
+ SCM mods = SCM_EOL;
+ if (ctxmod)
+ mods = ctxmod->get_mods ();
+ $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F);
+ }
+ | NEWCONTEXT symbol optional_id optional_context_mod {
+ Context_mod *ctxmod = Context_mod::unsmob ($4);
+ SCM mods = SCM_EOL;
+ if (ctxmod)
+ mods = ctxmod->get_mods ();
+ $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_T);
+ }
+ ;
+
+new_lyrics:
+ ADDLYRICS lyric_mode_music {
+ $$ = scm_list_1 ($2);
+ }
+ | new_lyrics ADDLYRICS lyric_mode_music {
+ $$ = scm_cons ($3, $1);
+ }
+ ;
+
+/* basic_music is basically the same as composite_music but with
+ * context-prefixed music and lyricized music explicitly removed. The
+ * reason is that in a sequence
+ *
+ * \new Staff \new Voice { ... } \addlyrics { ... } \addlyrics { ... }
+ *
+ * we need to group both \addlyrics together (as they go with the same
+ * voice) but then combine them with \new Voice { ... }, meaning that
+ * combining \new Voice { ... } needs higher priority than
+ * { ... } \addlyrics, and *not* have \new Staff \new Voice { ... }
+ * combine before combining \new Voice { ... } \addlyrics: only one
+ * layer of context-prefixed music should assemble before \addlyrics
+ * is integrated. Total mess, and we sort this mess out with explicit
+ * rules preferring a single context-prefix.
+ */
+
+basic_music:
+ music_function_call
+ | repeated_music
| music_bare
+ | LYRICSTO simple_string lyric_mode_music {
+ $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, SCM_EOL, $3);
+ }
+ | LYRICSTO symbol '=' simple_string lyric_mode_music
+ {
+ $$ = MAKE_SYNTAX ("lyric_combine", @$, $3, $2, $4);
+ }
+ ;
+
+contextable_music:
+ basic_music
+ | pitch_as_music
+ | event_chord
;
-/* Music that can be parsed without lookahead */
-closed_music:
- music_bare
- | complex_music_prefix closed_music
+contexted_basic_music:
+ context_prefix contextable_music new_lyrics
+ {
+ Input i;
+ i.set_location (@1, @2);
+ $$ = FINISH_MAKE_SYNTAX ($1, i, $2);
+ $$ = MAKE_SYNTAX ("add-lyrics", @$, $$, scm_reverse_x ($3, SCM_EOL));
+ } %prec COMPOSITE
+ | context_prefix contextable_music
+ {
+ $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
+ } %prec COMPOSITE
+ | context_prefix contexted_basic_music
{
$$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
}
;
+composite_music:
+ basic_music %prec COMPOSITE
+ | contexted_basic_music
+ | basic_music new_lyrics
+ {
+ $$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL));
+ } %prec COMPOSITE
+ ;
+
music_bare:
mode_changed_music
| MUSIC_IDENTIFIER
| 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 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.
+ *
+ * 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.
+ *
+ * If optional arguments are at the end of the argument list, they are
+ * instead scanned using function_arglist_nonbackup: here the only
+ * manner to enter into skipping of optional arguments is the use of
+ * \default.
+ *
+ * The argument list of a normal function call is parsed using
+ * function_arglist. The part of an argument list before a mandatory
+ * argument is parsed using function_arglist_optional.
+ *
+ * The difference is that leading optional arguments are scanned using
+ * function_arglist_nonbackup and function_arglist_backup,
+ * respectively.
+ *
+ * Most other details are obvious in the rules themselves.
+ *
+ */
-function_arglist_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
+symbol_list_arg:
+ SYMBOL_LIST
+ | SYMBOL_LIST '.' symbol_list_rev
{
- $$ = scm_cons ($1, $3);
- } %prec FUNCTION_ARGLIST
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip
+ $$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
+ }
+ ;
+
+symbol_list_rev:
+ symbol_list_part
+ | symbol_list_rev '.' symbol_list_part
{
- $$ = scm_cons ($1, $3);
- } %prec FUNCTION_ARGLIST
+ $$ = scm_append_x (scm_list_2 ($3, $1));
+ }
;
+// symbol_list_part delivers elements in reverse copy.
-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_closed FRACTION
+symbol_list_part:
+ symbol_list_element
{
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ SCM sym_l_p = ly_lily_module_constant ("symbol-list?");
+ $$ = try_string_variants (sym_l_p, $1);
+ if (SCM_UNBNDP ($$)) {
+ parser->parser_error (@1, _("not a symbol"));
+ $$ = SCM_EOL;
+ } else
+ $$ = scm_reverse ($$);
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed post_event_nofinger
+ ;
+
+
+symbol_list_element:
+ STRING
+ | embedded_scm_bare
+ ;
+
+
+function_arglist_nonbackup:
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
{
$$ = check_scheme_arg (parser, @4, $4, $3, $2);
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' 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)))
else {
Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5);
t->set_property ("digit", $5);
- $$ = t->unprotect ();
- if (scm_is_true (scm_call_1 ($2, $$)))
- $$ = scm_cons ($$, $3);
- else
- $$ = check_scheme_arg (parser, @4, n, $3, $2);
+ $$ = check_scheme_arg (parser, @4, t->unprotect (),
+ $3, $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),
$3, $2);
}
- ;
-
-function_arglist_closed_nonbackup:
- function_arglist_nonbackup_common
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg_closed
+ | 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_closed
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
{
$$ = 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_nonbackup_reparse REPARSE pitch_or_music
{
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ 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);
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number
+ | function_arglist_nonbackup_reparse REPARSE duration_length
{
- $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ $$ = 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 REPARSE lyric_element_music
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE symbol_list_arg
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
}
;
-function_arglist_keep:
- function_arglist_common
- | function_arglist_backup
+function_arglist_nonbackup_reparse:
+ EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
+ {
+ $$ = $3;
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ 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;
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $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_closed_keep:
- function_arglist_closed_common
- | function_arglist_backup
- ;
+// function_arglist_backup can't occur at the end of an argument
+// list.
function_arglist_backup:
- EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep embedded_scm_arg_closed
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg
{
if (scm_is_true (scm_call_1 ($2, $4)))
- {
$$ = scm_cons ($4, $3);
- } else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (SCM_IDENTIFIER, $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_closed_keep post_event_nofinger
+ | 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 lyric_element
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup pitch
{
- // There is no point interpreting a lyrics string as
- // an event, since we don't allow music possibly
- // followed by durations or postevent into closed
- // music, and we only accept closed music in optional
- // arguments at the moment. If this changes, more
- // complex schemes might become interesting here as
- // well: see how we do this at the mandatory argument
- // point.
- if (scm_is_true (scm_call_1 ($2, $4)))
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ {
+ $$ = $3;
+ MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+ } else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (LYRICS_STRING, $4, @4);
+ MYBACKUP (PITCH_IDENTIFIER, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep UNSIGNED
+ | 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, UNSIGNED, $4);
- } else {
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $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 (UNSIGNED, $4, @4);
+ MYBACKUP (TONICNAME_PITCH, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep REAL
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup full_markup
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ MYBACKUP (SCM_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup UNSIGNED
{
if (scm_is_true (scm_call_1 ($2, $4)))
{
- $$ = $3;
MYREPARSE (@4, $2, REAL, $4);
+ $$ = $3;
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (REAL, $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 NUMBER_IDENTIFIER
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REAL
{
if (scm_is_true (scm_call_1 ($2, $4)))
{
- $$ = scm_cons ($4, $3);
+ $$ = $3;
+ MYREPARSE (@4, $2, REAL, $4);
} else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
- MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
+ MYBACKUP (REAL, $4, @4);
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep FRACTION
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NUMBER_IDENTIFIER
{
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);
+ MYBACKUP (NUMBER_IDENTIFIER, $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))) {
else {
$$ = scm_cons (loc_on_music (@3, $1), $3);
MYBACKUP (UNSIGNED, $5, @5);
- parser->lexer_->push_extra_token ('-');
+ parser->lexer_->push_extra_token (@4, '-');
}
}
-
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' REAL
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' REAL
{
SCM n = scm_difference ($5, SCM_UNDEFINED);
if (scm_is_true (scm_call_1 ($2, n))) {
MYREPARSE (@5, $2, REAL, n);
$$ = $3;
} else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
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))) {
$$ = scm_cons (n, $3);
} else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
MYBACKUP (NUMBER_IDENTIFIER, n, @5);
}
}
- | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_keep pitch_also_in_chords
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
{
- $$ = scm_cons ($4, $3);
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+ $$ = $3;
+ } else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ MYBACKUP (DURATION_IDENTIFIER, $4, @4);
+ }
}
- | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_keep duration_length
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup SCM_IDENTIFIER
{
- $$ = scm_cons ($4, $3);
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res)) {
+ $$ = $3;
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ }
+ else
+ $$ = scm_cons (res, $3);
+ else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ MYBACKUP (SCM_IDENTIFIER, $4, @4);
+ }
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup BACKUP
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup STRING
{
- $$ = scm_cons ($1, $3);
- MYBACKUP(0, SCM_UNDEFINED, @3);
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res)) {
+ $$ = $3;
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ }
+ else
+ $$ = scm_cons (res, $3);
+ else {
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
+ MYBACKUP (STRING, $4, @4);
+ }
}
- | function_arglist_backup REPARSE embedded_scm_arg_closed
+ | function_arglist_backup 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_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_backup REPARSE symbol_list_arg
+ {
+ $$ = 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);
}
- | EXPECT_SCM function_arglist_closed_optional FRACTION
+ | EXPECT_SCM function_arglist_optional post_event_nofinger
{
$$ = check_scheme_arg (parser, @3,
$3, $2, $1);
}
- | EXPECT_SCM function_arglist_closed_optional post_event_nofinger
+ | EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ $$ = check_scheme_arg (parser, @4, n, $2, $1);
}
- | function_arglist_common_minus
- | function_arglist_common_lyric
- ;
-
-function_arglist_common_lyric:
- EXPECT_SCM function_arglist_optional lyric_element
+ | function_arglist_common_reparse REPARSE SCM_ARG
{
- // We check how the predicate thinks about a lyrics
- // event or about a markup. If it accepts neither, we
- // backup the original token. Otherwise we commit to
- // taking the token. Depending on what the predicate
- // is willing to accept, we interpret as a string, as
- // a lyric event, or ambiguously (meaning that if
- // something looking like a duration or post event
- // follows, we take the event, otherwise the string).
- SCM lyric_event = MAKE_SYNTAX ("lyric-event", @3, $3,
- parser->default_duration_.smobbed_copy ());
- if (scm_is_true (scm_call_1 ($1, $3)))
- if (scm_is_true (scm_call_1 ($1, lyric_event)))
- {
- $$ = $2;
- MYREPARSE (@3, $1, LYRICS_STRING, $3);
- } else {
- $$ = scm_cons ($3, $2);
- }
- else if (scm_is_true (scm_call_1 ($1, lyric_event)))
- {
- $$ = $2;
- MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
- } else {
- // This is going to flag a syntax error, we
- // know the predicate to be false.
- check_scheme_arg (parser, @3,
- $3, $2, $1);
- }
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | function_arglist_common_lyric REPARSE lyric_element_arg
+ | function_arglist_common_reparse REPARSE lyric_element_music
{
- // This should never be false
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
}
- ;
-
-function_arglist_common_minus:
- EXPECT_SCM function_arglist_closed_optional '-' UNSIGNED
+ | function_arglist_common_reparse REPARSE pitch_or_music
{
- SCM n = scm_difference ($4, SCM_UNDEFINED);
- if (scm_is_true (scm_call_1 ($1, n))) {
- $$ = $2;
- MYREPARSE (@4, $1, REAL, n);
- } else {
- Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4);
- t->set_property ("digit", $4);
- $$ = t->unprotect ();
- if (scm_is_true (scm_call_1 ($1, $$)))
- $$ = scm_cons ($$, $2);
- else
- $$ = check_scheme_arg (parser, @3, n, $2, $1);
- }
-
+ 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);
}
- | EXPECT_SCM function_arglist_closed_optional '-' REAL
+ | function_arglist_common_reparse REPARSE bare_number_common
{
- $$ = $2;
- SCM n = scm_difference ($4, SCM_UNDEFINED);
- MYREPARSE (@4, $1, REAL, n);
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER
+ | function_arglist_common_reparse REPARSE duration_length
{
- 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_minus REPARSE bare_number
+ | function_arglist_common_reparse REPARSE symbol_list_arg
{
$$ = check_scheme_arg (parser, @3, $3, $1, $2);
}
;
-function_arglist_closed:
- function_arglist_closed_common
- | function_arglist_closed_nonbackup
- ;
-
-function_arglist_closed_common:
- function_arglist_bare
- | EXPECT_SCM function_arglist_optional embedded_scm_arg_closed
+function_arglist_common_reparse:
+ EXPECT_SCM function_arglist_optional SCM_IDENTIFIER
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ $$ = $2;
+ SCM res = try_string_variants ($1, $3);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@3, $1, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
+ else
+ // This is going to flag a syntax error, we
+ // know the predicate to be false.
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | EXPECT_SCM function_arglist_closed_optional bare_number
+ | EXPECT_SCM function_arglist_optional pitch
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ $$ = $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_closed_optional '-' UNSIGNED
+ | EXPECT_SCM function_arglist_optional steno_tonic_pitch
{
- SCM n = scm_difference ($4, SCM_UNDEFINED);
- if (scm_is_true (scm_call_1 ($1, n))) {
- $$ = scm_cons (n, $2);
- } else {
- Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4);
- t->set_property ("digit", $4);
- $$ = t->unprotect ();
- if (scm_is_true (scm_call_1 ($1, $$)))
- $$ = scm_cons ($$, $2);
+ $$ = $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;
+ SCM res = try_string_variants ($1, $3);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@3, $1, SYMBOL_LIST, res);
else
- $$ = check_scheme_arg (parser, @3, n, $2, $1);
- }
-
+ MYREPARSE (@3, $1, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
+ else
+ // This is going to flag a syntax error, we
+ // know the predicate to be false.
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | EXPECT_SCM function_arglist_closed_optional '-' REAL
+ | EXPECT_SCM function_arglist_optional full_markup
{
- $$ = check_scheme_arg (parser, @3,
- scm_difference ($4, SCM_UNDEFINED),
- $2, $1);
+ $$ = $2;
+ if (scm_is_true (scm_call_1 ($1, $3)))
+ MYREPARSE (@3, $1, SCM_ARG, $3);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
+ else
+ // This is going to flag a syntax error, we
+ // know the predicate to be false.
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER
+ | EXPECT_SCM function_arglist_optional UNSIGNED
{
- $$ = check_scheme_arg (parser, @3,
- scm_difference ($4, SCM_UNDEFINED),
- $2, $1);
+ $$ = $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_closed_optional post_event_nofinger
+ | EXPECT_SCM function_arglist_optional DURATION_IDENTIFIER
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ $$ = $2;
+ MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
}
- | EXPECT_SCM function_arglist_closed_optional FRACTION
+ | EXPECT_SCM function_arglist_optional '-' UNSIGNED
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ $$ = $2;
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ if (scm_is_true (scm_call_1 ($1, n)))
+ MYREPARSE (@4, $1, REAL, n);
+ else {
+ Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4);
+ t->set_property ("digit", $4);
+ SCM m = t->unprotect ();
+ if (scm_is_true (scm_call_1 ($1, m)))
+ MYREPARSE (@4, $1, SCM_ARG, m);
+ else
+ MYREPARSE (@4, $1, SCM_ARG, $4);
+ }
}
- | EXPECT_SCM function_arglist_optional lyric_element
+ | EXPECT_SCM function_arglist_optional '-' REAL
{
- $$ = check_scheme_arg (parser, @3,
- $3, $2, $1);
+ $$ = $2;
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ MYREPARSE (@4, $1, REAL, n);
}
;
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);
- }
- ;
-
-embedded_scm_closed:
- embedded_scm_bare
- | scm_function_call_closed
- ;
-
-embedded_scm_arg_closed:
- embedded_scm_bare_arg
- | scm_function_call_closed
- | closed_music
- ;
-
-scm_function_call_closed:
- SCM_FUNCTION function_arglist_closed {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
- } %prec FUNCTION_ARGLIST
- ;
-
-function_arglist_bare:
- EXPECT_NO_MORE_ARGS {
- $$ = SCM_EOL;
- }
- | EXPECT_PITCH function_arglist_optional pitch_also_in_chords {
- $$ = scm_cons ($3, $2);
- }
- | EXPECT_DURATION function_arglist_closed_optional duration_length {
- $$ = scm_cons ($3, $2);
- }
- | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip DEFAULT {
- $$ = scm_cons ($1, $3);
- }
- | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_skip DEFAULT {
- $$ = scm_cons ($1, $3);
- }
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip DEFAULT {
- $$ = scm_cons ($1, $3);
+ $$ = scm_cons (loc_on_music (@3, $1), $3);
}
;
}
;
-complex_music:
- music_function_call
- | repeated_music { $$ = $1; }
- | re_rhythmed_music { $$ = $1; }
- | complex_music_prefix music
- {
- $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
- }
- ;
+// 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.
-complex_music_prefix:
- CONTEXT simple_string 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 {
- 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_T);
+lyric_mode_music:
+ {
+ parser->lexer_->push_lyric_state ();
+ } grouped_music_list
+ {
+ parser->lexer_->pop_state ();
+ $$ = $2;
}
+ | MUSIC_IDENTIFIER
;
mode_changed_music:
parser->lexer_->pop_state ();
}
| mode_changing_head_with_context optional_context_mod grouped_music_list {
- Context_mod *ctxmod = unsmob_context_mod ($2);
+ Context_mod *ctxmod = Context_mod::unsmob ($2);
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
}
;
-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);
- }
- | new_lyrics ADDLYRICS {
- parser->lexer_->push_lyric_state ();
- } composite_music {
- parser->lexer_->pop_state ();
- $$ = scm_cons ($4, $1);
+context_change:
+ CHANGE symbol '=' simple_string {
+ $$ = MAKE_SYNTAX ("context-change", @$, $2, $4);
}
;
-re_rhythmed_music:
- 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);
- }
- ;
-context_change:
- CHANGE STRING '=' STRING {
- $$ = MAKE_SYNTAX ("context-change", @$, scm_string_to_symbol ($2), $4);
+property_path:
+ symbol_list_rev {
+ $$ = scm_reverse_x ($1, SCM_EOL);
+ }
+ | symbol_list_rev property_path {
+ $$ = scm_reverse_x ($1, $2);
}
;
-
-property_path_revved:
- embedded_scm_closed {
- $$ = scm_cons ($1, SCM_EOL);
+property_operation:
+ symbol '=' scalar {
+ $$ = scm_list_3 (ly_symbol2scm ("assign"), $1, $3);
}
- | property_path_revved embedded_scm_closed {
- $$ = scm_cons ($2, $1);
+ | UNSET symbol {
+ $$ = scm_list_2 (ly_symbol2scm ("unset"), $2);
+ }
+ | OVERRIDE property_path '=' scalar {
+ if (scm_ilength ($2) < 2) {
+ parser->parser_error (@2, _("bad grob property path"));
+ $$ = SCM_UNDEFINED;
+ } else {
+ $$ = scm_cons (ly_symbol2scm ("push"),
+ scm_cons2 (scm_car ($2),
+ $4,
+ scm_cdr ($2)));
+ }
+ }
+ | REVERT revert_arg {
+ $$ = scm_cons (ly_symbol2scm ("pop"), $2);
+ }
+ ;
+
+// This is all quite awkward for the sake of substantial backward
+// compatibility while at the same time allowing a more "natural" form
+// of specification not separating grob specification from grob
+// property path. The purpose of this definition of revert_arg is to
+// allow the symbol list which specifies grob and property to revert
+// to be optionally be split into two parts after the grob (which in
+// this case is just the first element of the list). symbol_list_part
+// is only one path component, but it can be parsed without lookahead,
+// so we can follow it with a synthetic BACKUP token when needed. If
+// the first symbol_list_part already contains multiple elements (only
+// possible if a Scheme expression provides them), we just parse for
+// additional elements introduced by '.', which is what the
+// SYMBOL_LIST backup in connection with the immediately following
+// rule using symbol_list_arg does.
+//
+// As long as we don't have our coffers filled with both grob and at
+// least one grob property specification, the rest of the required
+// symbol list chain may be provided either with or without a leading
+// dot. This is for both allowing the traditional
+// \revert Accidental #'color
+// as well as well as the "naive" form
+// \revert Accidental.color
+
+revert_arg:
+ revert_arg_backup BACKUP symbol_list_arg
+ {
+ $$ = $3;
}
;
-property_path:
- property_path_revved {
- $$ = scm_reverse_x ($1, SCM_EOL);
+revert_arg_backup:
+ revert_arg_part
+ {
+ if (scm_is_null ($1)
+ || scm_is_null (scm_cdr ($1)))
+ MYBACKUP (SCM_ARG, $1, @1);
+ else
+ MYBACKUP (SYMBOL_LIST, scm_reverse_x ($1, SCM_EOL), @1);
}
;
-property_operation:
- STRING '=' scalar {
- $$ = scm_list_3 (ly_symbol2scm ("assign"),
- scm_string_to_symbol ($1), $3);
- }
- | UNSET simple_string {
- $$ = scm_list_2 (ly_symbol2scm ("unset"),
- scm_string_to_symbol ($2));
- }
- | OVERRIDE simple_string property_path '=' scalar {
- $$ = scm_append (scm_list_2 (scm_list_3 (ly_symbol2scm ("push"),
- scm_string_to_symbol ($2), $5),
- $3));
+// revert_arg_part delivers results in reverse
+revert_arg_part:
+ symbol_list_part
+ | revert_arg_backup BACKUP SCM_ARG '.' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($5, $3));
}
- | REVERT simple_string embedded_scm {
- $$ = scm_list_3 (ly_symbol2scm ("pop"),
- scm_string_to_symbol ($2), $3);
+ | revert_arg_backup BACKUP SCM_ARG symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($4, $3));
}
;
}
;
-context_prop_spec:
- simple_string {
- if (!is_regular_identifier ($1))
+// If defined, at least two members.
+grob_prop_spec:
+ symbol_list_rev
+ {
+ SCM l = scm_reverse_x ($1, SCM_EOL);
+ if (scm_is_pair (l)
+ && to_boolean
+ (scm_object_property (scm_car (l),
+ ly_symbol2scm ("is-grob?"))))
+ l = scm_cons (ly_symbol2scm ("Bottom"), l);
+ if (scm_is_null (l) || scm_is_null (scm_cdr (l))) {
+ parser->parser_error (@1, _ ("bad grob property path"));
+ l = SCM_UNDEFINED;
+ }
+ $$ = l;
+ }
+ ;
+
+// If defined, at least three members
+grob_prop_path:
+ grob_prop_spec
+ {
+ if (!SCM_UNBNDP ($1) && scm_is_null (scm_cddr ($1)))
{
- @$.error (_("Grob name should be alphanumeric"));
+ parser->parser_error (@1, _ ("bad grob property path"));
+ $$ = SCM_UNDEFINED;
+ }
+ }
+ | grob_prop_spec property_path
+ {
+ if (!SCM_UNBNDP ($1)) {
+ $$ = scm_append_x (scm_list_2 ($1, $2));
+ if (scm_is_null (scm_cddr ($$))) {
+ parser->parser_error (@$, _ ("bad grob property path"));
+ $$ = SCM_UNDEFINED;
+ }
}
- $$ = scm_list_2 (ly_symbol2scm ("Bottom"),
- scm_string_to_symbol ($1));
}
- | simple_string '.' simple_string {
- $$ = scm_list_2 (scm_string_to_symbol ($1),
- scm_string_to_symbol ($3));
+ ;
+
+// Exactly two elements or undefined
+context_prop_spec:
+ symbol_list_rev
+ {
+ SCM l = scm_reverse_x ($1, SCM_EOL);
+ switch (scm_ilength (l)) {
+ case 1:
+ l = scm_cons (ly_symbol2scm ("Bottom"), l);
+ case 2:
+ break;
+ default:
+ parser->parser_error (@1, _ ("bad context property path"));
+ l = SCM_UNDEFINED;
+ }
+ $$ = l;
}
;
simple_music_property_def:
- OVERRIDE context_prop_spec property_path '=' scalar {
- $$ = scm_append (scm_list_2 (scm_list_n (scm_car ($2),
- ly_symbol2scm ("OverrideProperty"),
- scm_cadr ($2),
- $5, SCM_UNDEFINED),
- $3));
- }
- | REVERT context_prop_spec embedded_scm {
- $$ = scm_list_4 (scm_car ($2),
- ly_symbol2scm ("RevertProperty"),
- scm_cadr ($2),
- $3);
+ OVERRIDE grob_prop_path '=' scalar {
+ if (SCM_UNBNDP ($2))
+ $$ = SCM_UNDEFINED;
+ else {
+ $$ = scm_list_5 (scm_car ($2),
+ ly_symbol2scm ("OverrideProperty"),
+ scm_cadr ($2),
+ $4,
+ scm_cddr ($2));
+ }
+ }
+ | REVERT simple_revert_context revert_arg {
+ $$ = scm_list_4 ($2,
+ ly_symbol2scm ("RevertProperty"),
+ scm_car ($3),
+ scm_cdr ($3));
}
| SET context_prop_spec '=' scalar {
- $$ = scm_list_4 (scm_car ($2),
- ly_symbol2scm ("PropertySet"),
- scm_cadr ($2),
- $4);
+ if (SCM_UNBNDP ($2))
+ $$ = SCM_UNDEFINED;
+ else
+ $$ = scm_list_4 (scm_car ($2),
+ ly_symbol2scm ("PropertySet"),
+ scm_cadr ($2),
+ $4);
}
| UNSET context_prop_spec {
- $$ = scm_list_3 (scm_car ($2),
- ly_symbol2scm ("PropertyUnset"),
- scm_cadr ($2));
+ if (SCM_UNBNDP ($2))
+ $$ = SCM_UNDEFINED;
+ else
+ $$ = scm_list_3 (scm_car ($2),
+ ly_symbol2scm ("PropertyUnset"),
+ scm_cadr ($2));
+ }
+ ;
+
+
+// This is all quite awkward for the sake of substantial backward
+// compatibility while at the same time allowing a more "natural" form
+// of specification not separating grob specification from grob
+// property path. The purpose of this definition of
+// simple_revert_context is to allow the symbol list which specifies
+// grob and property to revert to be optionally be split into two
+// parts after the grob (which may be preceded by a context
+// specification, a case which we distinguish by checking whether the
+// first symbol is a valid grob symbol instead).
+//
+// See revert_arg above for the main work horse of this arrangement.
+// simple_revert_context just caters for the context and delegates the
+// rest of the job to revert_arg.
+
+simple_revert_context:
+ symbol_list_part
+ {
+ $1 = scm_reverse_x ($1, SCM_EOL);
+ if (scm_is_null ($1)
+ || to_boolean
+ (scm_object_property (scm_car ($1),
+ ly_symbol2scm ("is-grob?")))) {
+ $$ = ly_symbol2scm ("Bottom");
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER, $1);
+ } else {
+ $$ = scm_car ($1);
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER,
+ scm_cdr ($1));
+ }
}
;
music_property_def:
simple_music_property_def {
- $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons2 (parser->self_scm (), make_input (@$), $1));
+ if (SCM_UNBNDP ($1))
+ $$ = MAKE_SYNTAX ("void-music", @1);
+ else
+ $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons2 (parser->self_scm (), @$.smobbed_copy (), $1));
}
;
STRING {
$$ = $1;
}
- | STRING_IDENTIFIER {
- $$ = $1;
- }
- | string '+' string {
- $$ = scm_string_append (scm_list_2 ($1, $3));
- }
+ | full_markup
;
simple_string: STRING {
$$ = $1;
}
- | LYRICS_STRING {
- $$ = $1;
+ | embedded_scm_bare
+ {
+ if (scm_is_string ($1)) {
+ $$ = $1;
+ } else {
+ parser->parser_error (@1, (_ ("simple string expected")));
+ $$ = scm_string (SCM_EOL);
+ }
}
- | STRING_IDENTIFIER {
- $$ = $1;
+ ;
+
+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:
embedded_scm_arg
+ | pitch_or_music
+ | SCM_IDENTIFIER
| bare_number
- | FRACTION
- | lyric_element
- ;
-
-scalar_closed:
- embedded_scm_arg_closed
- | bare_number
- | FRACTION
- | lyric_element
+ // The following is a rather defensive variant of admitting
+ // negative numbers: the grammar would permit number_factor or
+ // even number_expression. However, function arguments allow
+ // only this simple kind of negative number, so to have things
+ // like \tweak and \override behave reasonably similar, it
+ // makes sense to rule out things like -- which are rather an
+ // accent in function argument contexts.
+ | '-' bare_number
+ {
+ $$ = scm_difference ($2, SCM_UNDEFINED);
+ }
+ | string
;
-
event_chord:
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
if (scm_is_pair ($2)) {
- if (unsmob_pitch ($1)) {
- Music *n = MY_MAKE_MUSIC ("NoteEvent", @1);
- n->set_property ("pitch", $1);
- n->set_property ("duration",
- parser->default_duration_.smobbed_copy ());
- $$ = n->unprotect ();
- }
- unsmob_music ($$)->set_property ("articulations",
+ Music::unsmob ($$)->set_property ("articulations",
scm_reverse_x ($2, SCM_EOL));
}
- }
- | simple_chord_elements post_events {
- SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
-
- Input i;
- /* why is this giving wrong start location? -ns
- * i = @$; */
- i.set_location (@1, @2);
- $$ = MAKE_SYNTAX ("event-chord", i, elts);
- }
+ } %prec ':'
| CHORD_REPETITION optional_notemode_duration post_events {
Input i;
i.set_location (@1, @3);
$$ = MAKE_SYNTAX ("repetition-chord", i,
$2, scm_reverse_x ($3, SCM_EOL));
- }
+ } %prec ':'
| MULTI_MEASURE_REST optional_notemode_duration post_events {
Input i;
i.set_location (@1, @3);
$$ = MAKE_SYNTAX ("multi-measure-rest", i, $2,
scm_reverse_x ($3, SCM_EOL));
- }
- | command_element
+ } %prec ':'
+ | tempo_event
| note_chord_element
;
note_chord_element:
chord_body optional_notemode_duration post_events
{
- Music *m = unsmob_music ($1);
- SCM dur = unsmob_duration ($2)->smobbed_copy ();
+ Music *m = Music::unsmob ($1);
+ SCM dur = Duration::unsmob ($2)->smobbed_copy ();
SCM es = m->get_property ("elements");
SCM postevs = scm_reverse_x ($3, SCM_EOL);
for (SCM s = es; scm_is_pair (s); s = scm_cdr (s))
- unsmob_music (scm_car (s))->set_property ("duration", dur);
+ Music::unsmob (scm_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
m-> set_property ("elements", es);
m->set_spot (@$);
$$ = m->self_scm ();
- }
+ } %prec ':'
;
chord_body:
{
$$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
}
+ | FIGURE_OPEN figure_list FIGURE_CLOSE
+ {
+ $$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
+ }
;
chord_body_elements:
;
chord_body_element:
- pitch exclamations questions octave_check post_events
+ pitch_or_tonic_pitch exclamations questions octave_check post_events
{
bool q = to_boolean ($3);
bool ex = to_boolean ($2);
}
| music_function_chord_body
{
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
while (m && m->is_mus_type ("music-wrapper-music")) {
$$ = m->get_property ("element");
- m = unsmob_music ($$);
+ m = Music::unsmob ($$);
}
if (!(m && m->is_mus_type ("rhythmic-event"))) {
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_event:
- 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;
- }
- | 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 {
- $$ = $1;
- }
- ;
-
-
post_events:
/* empty */ {
$$ = SCM_EOL;
}
| post_events post_event {
- unsmob_music ($2)->set_spot (@2);
- $$ = scm_cons ($2, $$);
+ $$ = $1;
+ if (Music *m = Music::unsmob ($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, $$);
+ }
+ }
}
;
direction_less_event {
$$ = $1;
}
- | script_dir music_function_event {
+ | script_dir music_function_call {
$$ = $2;
- if (!SCM_UNBNDP ($1))
+ if (!Music::unsmob ($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);
+ Music::unsmob ($$)->set_property ("direction", $1);
}
}
| HYPHEN {
| script_dir direction_reqd_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = unsmob_music ($2);
+ Music *m = Music::unsmob ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| script_dir direction_less_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = unsmob_music ($2);
+ Music *m = Music::unsmob ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| '^' fingering
{
$$ = $2;
- unsmob_music ($$)->set_property ("direction", scm_from_int (UP));
+ Music::unsmob ($$)->set_property ("direction", scm_from_int (UP));
}
| '_' fingering
{
$$ = $2;
- unsmob_music ($$)->set_property ("direction", scm_from_int (DOWN));
- }
+ Music::unsmob ($$)->set_property ("direction", scm_from_int (DOWN));
+ }
;
post_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;
}
a->set_property ("tremolo-type", $1);
$$ = a->unprotect ();
}
- | event_function_event
+ | event_function_event
;
direction_reqd_event:
}
| script_abbreviation {
SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
- Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
- if (scm_is_string (s))
+ if (scm_is_string (s)) {
+ Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
a->set_property ("articulation-type", s);
- else parser->parser_error (@1, _ ("expecting string as script definition"));
- $$ = a->unprotect ();
+ $$ = a->unprotect ();
+ } else {
+ Music *original = Music::unsmob (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 ();
+ }
+ }
}
;
NOTENAME_PITCH quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *unsmob_pitch ($1);
- p = p.transposed (Pitch (scm_to_int ($2),0,0));
+ Pitch p = *Pitch::unsmob ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
}
TONICNAME_PITCH quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *unsmob_pitch ($1);
- p = p.transposed (Pitch (scm_to_int ($2),0,0));
+ Pitch p = *Pitch::unsmob ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
}
pitch:
steno_pitch
- | PITCH_IDENTIFIER
+ | PITCH_IDENTIFIER quotes {
+ if (!scm_is_eq (SCM_INUM0, $2))
+ {
+ Pitch p = *Pitch::unsmob ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
+ $$ = p.smobbed_copy ();
+ }
+ }
;
-pitch_also_in_chords:
+pitch_or_tonic_pitch:
pitch
| steno_tonic_pitch
;
t->set_property ("text", $1);
$$ = t->unprotect ();
}
- | simple_string {
+ | STRING {
Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
t->set_property ("text",
make_simple_markup ($1));
$$ = t->unprotect ();
}
+ | embedded_scm
+ {
+ Music *m = Music::unsmob ($1);
+ if (m && m->is_mus_type ("post-event"))
+ $$ = $1;
+ else if (Text_interface::is_markup ($1)) {
+ Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
+ t->set_property ("text", $1);
+ $$ = t->unprotect ();
+ } else
+ parser->parser_error (@1, _ ("not an articulation"));
+ }
;
fingering:
| '-' {
$$ = 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 ($$);
+ parser->default_duration_ = *Duration::unsmob ($$);
}
;
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);
+ Duration *d = Duration::unsmob ($1);
Duration k (d->duration_log (),
d->dot_count () + scm_to_int ($2));
k = k.compressed (d->factor ());
$$ = $1;
}
| multiplied_duration '*' UNSIGNED {
- $$ = unsmob_duration ($$)->compressed (scm_to_int ($3)).smobbed_copy ();
+ $$ = Duration::unsmob ($$)->compressed (scm_to_int ($3)).smobbed_copy ();
}
| multiplied_duration '*' FRACTION {
Rational m (scm_to_int (scm_car ($3)), scm_to_int (scm_cdr ($3)));
- $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
+ $$ = Duration::unsmob ($$)->compressed (m).smobbed_copy ();
}
;
tremolo_type:
':' {
- $$ = SCM_INUM0;
+ $$ = scm_from_int (parser->default_tremolo_type_);
}
| ':' UNSIGNED {
- int n = scm_to_int ($2);
- if (!is_duration (n))
- parser->parser_error (@2, _f ("not a duration: %d", n));
- $$ = $2;
+ if (SCM_UNBNDP (make_duration ($2))) {
+ parser->parser_error (@2, _ ("not a duration"));
+ $$ = scm_from_int (parser->default_tremolo_type_);
+ } else {
+ $$ = $2;
+ parser->default_tremolo_type_ = scm_to_int ($2);
+ }
}
;
UNSIGNED { $$ = $1; }
| STRING { $$ = $1; }
| full_markup { $$ = $1; }
+ | embedded_scm_bare
+ {
+ // as an integer, it needs to be non-negative, and otherwise
+ // it needs to be suitable as a markup.
+ if (scm_is_integer ($1)
+ ? scm_is_true (scm_negative_p ($1))
+ : !Text_interface::is_markup ($1))
+ {
+ parser->parser_error (@1, _ ("bass number expected"));
+ $$ = SCM_INUM0;
+ }
+ }
;
figured_bass_alteration:
}
| bass_figure ']' {
$$ = $1;
- unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
+ Music::unsmob ($1)->set_property ("bracket-stop", SCM_BOOL_T);
}
| bass_figure figured_bass_alteration {
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
if (scm_to_double ($2)) {
SCM salter = m->get_property ("alteration");
SCM alter = scm_is_number (salter) ? salter : scm_from_int (0);
}
}
| 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);
- }
+ Music *m = Music::unsmob ($1);
+ 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");
}
;
}
| '[' bass_figure {
$$ = $2;
- unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
+ Music::unsmob ($$)->set_property ("bracket-start", SCM_BOOL_T);
}
;
}
;
-figure_spec:
- FIGURE_OPEN figure_list FIGURE_CLOSE {
- $$ = scm_reverse_x ($2, SCM_EOL);
- }
- ;
-
-
optional_rest:
/**/ { $$ = SCM_BOOL_F; }
| 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 = MY_MAKE_MUSIC ("RestEvent", @$);
else
n = MY_MAKE_MUSIC ("NoteEvent", @$);
-
+
n->set_property ("pitch", $1);
if (SCM_UNBNDP ($5))
n->set_property ("duration",
parser->default_duration_.smobbed_copy ());
else
n->set_property ("duration", $5);
-
+
if (scm_is_number ($4))
{
int q = scm_to_int ($4);
n->set_property ("absolute-octave", scm_from_int (q-1));
}
-
+
if (to_boolean ($3))
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 ':'
+ | new_chord post_events {
+ if (!parser->lexer_->is_chord_state ())
+ parser->parser_error (@1, _ ("have to be in Chord mode for chords"));
+ if (scm_is_pair ($2)) {
+ if (Pitch::is_smob ($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 (!Pitch::is_smob ($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);
}
;
-simple_chord_elements:
- new_chord {
- if (!parser->lexer_->is_chord_state ())
- parser->parser_error (@1, _ ("have to be in Chord mode for chords"));
- $$ = $1;
- }
- | figure_spec optional_notemode_duration {
- for (SCM s = $1; scm_is_pair (s); s = scm_cdr (s))
- {
- unsmob_music (scm_car (s))->set_property ("duration", $2);
- }
- $$ = $1;
- }
- ;
-
lyric_element:
- lyric_markup {
+ full_markup {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _ ("markup outside of text script or \\lyricmode"));
$$ = $1;
}
- | LYRICS_STRING {
+ | STRING {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _ ("unrecognized string, not in text script or \\lyricmode"));
$$ = $1;
}
+ | LYRIC_ELEMENT
;
-lyric_element_arg:
- lyric_element
- | lyric_element multiplied_duration post_events {
- $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
- if (scm_is_pair ($3))
- unsmob_music ($$)->set_property
- ("articulations", scm_reverse_x ($3, SCM_EOL));
- }
- | lyric_element post_event post_events {
- $$ = MAKE_SYNTAX ("lyric-event", @$, $1,
- parser->default_duration_.smobbed_copy ());
- unsmob_music ($$)->set_property
- ("articulations", scm_cons ($2, scm_reverse_x ($3, SCM_EOL)));
- }
- | LYRIC_ELEMENT optional_notemode_duration post_events {
- $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
- if (scm_is_pair ($3))
- unsmob_music ($$)->set_property
- ("articulations", scm_reverse_x ($3, SCM_EOL));
- }
- ;
-
-
lyric_element_music:
lyric_element optional_notemode_duration post_events {
$$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
if (scm_is_pair ($3))
- unsmob_music ($$)->set_property
+ Music::unsmob ($$)->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:
;
tempo_range:
- UNSIGNED {
+ unsigned_number {
$$ = $1;
- }
- | UNSIGNED '~' UNSIGNED {
+ } %prec ':'
+ | unsigned_number '-' unsigned_number {
$$ = scm_cons ($1, $3);
}
;
| bare_number
;
+bare_number_common:
+ REAL
+ | NUMBER_IDENTIFIER
+ | REAL NUMBER_IDENTIFIER
+ {
+ $$ = scm_product ($1, $2);
+ }
+ ;
bare_number:
- bare_number_closed
+ bare_number_common
+ | UNSIGNED
| UNSIGNED NUMBER_IDENTIFIER {
$$ = scm_product ($1, $2);
}
- | REAL NUMBER_IDENTIFIER {
- $$ = scm_product ($1, $2);
- }
- ;
-
-bare_number_closed:
- UNSIGNED
- | REAL
- | NUMBER_IDENTIFIER
;
unsigned_number:
UNSIGNED
| NUMBER_IDENTIFIER
+ {
+ if (!scm_is_integer ($1)
+ || scm_is_true (scm_negative_p ($1)))
+ {
+ parser->parser_error (@1, _("not an unsigned integer"));
+ $$ = SCM_INUM0;
+ }
+ }
+ | embedded_scm
+ {
+ if (!scm_is_integer ($1)
+ || scm_is_true (scm_negative_p ($1)))
+ {
+ parser->parser_error (@1, _("not an unsigned integer"));
+ $$ = SCM_INUM0;
+ }
+ }
;
exclamations:
;
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))
}
;
-/*
-This should be done more dynamically if possible.
-*/
-
-lyric_markup:
- LYRIC_MARKUP_IDENTIFIER {
- $$ = $1;
- }
- | LYRIC_MARKUP
- { parser->lexer_->push_markup_state (); }
- markup_top {
- $$ = $3;
- parser->lexer_->pop_state ();
- }
- ;
-
full_markup_list:
- MARKUPLIST_IDENTIFIER {
- $$ = $1;
- }
- | MARKUPLIST
+ MARKUPLIST
{ parser->lexer_->push_markup_state (); }
markup_list {
$$ = $3;
;
full_markup:
- MARKUP_IDENTIFIER {
- $$ = $1;
- }
- | MARKUP
+ MARKUP
{ parser->lexer_->push_markup_state (); }
markup_top {
$$ = $3;
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;
}
} BACKUP
;
-
+
markup_list:
- MARKUPLIST_IDENTIFIER {
+ markup_composed_list {
$$ = $1;
}
- | markup_composed_list {
- $$ = $1;
- }
- | markup_braced_list {
+ | markup_uncomposed_list
+ ;
+
+markup_uncomposed_list:
+ markup_braced_list {
$$ = $1;
}
| markup_command_list {
{
$$ = $2;
}
+ | SCORELINES {
+ SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
+ parser->lexer_->push_note_state (nn);
+ } '{' score_body '}' {
+ Score *sc = Score::unsmob ($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 ();
+ }
;
markup_composed_list:
- markup_head_1_list markup_braced_list {
- $$ = scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, $2);
-
+ markup_head_1_list markup_uncomposed_list {
+ $$ = MAKE_SYNTAX ("composed-markup-list",
+ @2, $1, $2);
}
;
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 {
STRING {
$$ = make_simple_markup ($1);
}
- | MARKUP_IDENTIFIER {
- $$ = $1;
- }
- | LYRIC_MARKUP_IDENTIFIER {
- $$ = $1;
- }
- | STRING_IDENTIFIER {
- $$ = $1;
- }
| SCORE {
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} '{' score_body '}' {
+ Score *sc = Score::unsmob ($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 ();
}
;
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;
int
Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
{
- if (scm_is_string (sid)) {
- *destination = sid;
- return STRING_IDENTIFIER;
- } else if (unsmob_book (sid)) {
- Book *book = unsmob_book (sid)->clone ();
+ if (Book::is_smob (sid)) {
+ Book *book = Book::unsmob (sid)->clone ();
*destination = book->self_scm ();
book->unprotect ();
} 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_mod (sid)) {
- *destination = unsmob_context_mod (sid)->smobbed_copy ();
-
+ } else if (Context_def::is_smob (sid))
+ {
+ *destination = Context_def::unsmob (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (Context_mod::is_smob (sid)) {
+ *destination = Context_mod::unsmob (sid)->smobbed_copy ();
return CONTEXT_MOD_IDENTIFIER;
- } else if (unsmob_score (sid)) {
- Score *score = new Score (*unsmob_score (sid));
- *destination = score->self_scm ();
-
- score->unprotect ();
- return SCORE_IDENTIFIER;
- } else if (Music *mus = unsmob_music (sid)) {
+ } else if (Music *mus = Music::unsmob (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;
- } else if (unsmob_pitch (sid)) {
- *destination = unsmob_pitch (sid)->smobbed_copy ();
+ } else if (Pitch::is_smob (sid)) {
+ *destination = Pitch::unsmob (sid)->smobbed_copy ();
return PITCH_IDENTIFIER;
- } else if (unsmob_duration (sid)) {
- *destination = unsmob_duration (sid)->smobbed_copy ();
+ } else if (Duration::is_smob (sid)) {
+ *destination = Duration::unsmob (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;
- } else if (Text_interface::is_markup (sid)) {
- *destination = sid;
- if (is_lyric_state ())
- return LYRIC_MARKUP_IDENTIFIER;
- return MARKUP_IDENTIFIER;
- } else if (Text_interface::is_markup_list (sid)) {
- *destination = sid;
- return MARKUPLIST_IDENTIFIER;
+ } else if (Output_def::is_smob (sid)) {
+ *destination = Output_def::unsmob (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (Score::is_smob (sid)) {
+ *destination = Score::unsmob (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
}
return -1;
return scm_from_locale_string (s);
}
+// check_scheme_arg checks one argument with a given predicate for use
+// in an argument list and throws a syntax error if it is unusable.
+// The argument is prepended to the argument list in any case. After
+// throwing a syntax error, the argument list is terminated with #f as
+// its last cdr in order to mark it as uncallable while not losing
+// track of its total length.
+//
+// There are a few special considerations: if optional argument disp
+// is given (otherwise it defaults to SCM_UNDEFINED), it will be used
+// instead of arg in a prospective error message. This is useful if
+// arg is not the actual argument but rather a transformation of it.
+//
+// If arg itself is SCM_UNDEFINED, the predicate is considered false
+// and an error message using disp is produced unconditionally.
+
SCM check_scheme_arg (Lily_parser *parser, Input loc,
- SCM arg, SCM args, SCM pred)
+ SCM arg, SCM args, SCM pred, SCM disp)
{
- args = scm_cons (arg, args);
- if (scm_is_true (scm_call_1 (pred, arg)))
- return args;
+ if (SCM_UNBNDP (arg))
+ args = scm_cons (disp, args);
+ else {
+ args = scm_cons (arg, args);
+ if (scm_is_true (scm_call_1 (pred, arg)))
+ return args;
+ }
scm_set_cdr_x (scm_last_pair (args), SCM_EOL);
- MAKE_SYNTAX ("argument-error", loc, scm_length (args), pred, arg);
+ MAKE_SYNTAX ("argument-error", loc, scm_length (args), pred,
+ SCM_UNBNDP (disp) ? arg : disp);
scm_set_cdr_x (scm_last_pair (args), SCM_BOOL_F);
return args;
}
SCM loc_on_music (Input loc, SCM arg)
{
- if (Music *m = unsmob_music (arg))
+ if (Music *m = Music::unsmob (arg))
{
m = m->clone ();
m->set_spot (loc);
return arg;
}
+SCM
+try_string_variants (SCM pred, SCM str)
+{
+ // a matching predicate is always ok
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+ // a symbol may be interpreted as a list of symbols if it helps
+ if (scm_is_symbol (str)) {
+ str = scm_list_1 (str);
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+ return SCM_UNDEFINED;
+ }
+
+ // If this cannot be a string representation of a symbol list,
+ // we are through.
+
+ if (!is_regular_identifier (str, true))
+ return SCM_UNDEFINED;
+
+ str = scm_string_split (str, SCM_MAKE_CHAR ('.'));
+ for (SCM p = str; scm_is_pair (p); p = scm_cdr (p))
+ scm_set_car_x (p, scm_string_to_symbol (scm_car (p)));
+
+ // Let's attempt the symbol list interpretation first.
+
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+
+ // If there is just one symbol in the list, we might interpret
+ // it as a single symbol
+
+ if (scm_is_null (scm_cdr (str)))
+ {
+ str = scm_car (str);
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+ }
+
+ return SCM_UNDEFINED;
+}
+
bool
-is_regular_identifier (SCM id)
+is_regular_identifier (SCM id, bool multiple)
{
+ if (!scm_is_string (id))
+ return false;
+
string str = ly_scm2string (id);
- char const *s = str.c_str ();
- bool v = true;
-#if 0
- isalpha (*s);
- s++;
-#endif
- while (*s && v)
- {
- v = v && isalnum (*s);
- s++;
- }
- return v;
+ bool middle = false;
+
+ for (string::iterator it=str.begin(); it != str.end (); it++)
+ {
+ int c = *it & 0xff;
+ if ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || c > 0x7f)
+ middle = true;
+ else if (middle && (c == '-' || c == '_' || (multiple && c == '.')))
+ middle = false;
+ else
+ return false;
+ }
+ return middle;
+}
+
+SCM
+make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
+{
+ if (Music::is_smob (simple))
+ return simple;
+ if (parser->lexer_->is_note_state ()) {
+ if (scm_is_symbol (simple)) {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", parser->default_duration_.smobbed_copy ());
+ n->set_property ("drum-type", simple);
+ return n->unprotect ();
+ }
+ if (Pitch::is_smob (simple)) {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", parser->default_duration_.smobbed_copy ());
+ n->set_property ("pitch", simple);
+ return n->unprotect ();
+ }
+ return simple;
+ } else if (parser->lexer_->is_lyric_state ()) {
+ if (Text_interface::is_markup (simple))
+ return MAKE_SYNTAX ("lyric-event", loc, simple,
+ parser->default_duration_.smobbed_copy ());
+ } else if (parser->lexer_->is_chord_state ()) {
+ if (Pitch::is_smob (simple))
+ return MAKE_SYNTAX
+ ("event-chord",
+ loc,
+ make_chord_elements (loc, simple,
+ parser->default_duration_.smobbed_copy (),
+ SCM_EOL));
+ }
+ return simple;
}
Music *
return a;
}
-bool
-is_duration (int t)
-{
- return t && t == 1 << intlog2 (t);
-}
-
-void
-set_music_properties (Music *p, SCM a)
+SCM
+make_duration (SCM d, int dots)
{
- for (SCM k = a; scm_is_pair (k); k = scm_cdr (k))
- p->set_property (scm_caar (k), scm_cdar (k));
+ 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
make_chord_step (SCM step_scm, Rational alter)
{
SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list);
for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
{
- unsmob_music (scm_car (s))->set_spot (loc);
+ Music::unsmob (scm_car (s))->set_spot (loc);
}
return res;
}
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 ();
}
projects / lilypond.git / blobdiff