/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1997--2014 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
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 ()); \
+ SCM s = Display::value_to_lily_string (value); \
char *p = scm_to_locale_string (s); \
fputs (p, file); \
free (p); \
using namespace std;
#include "book.hh"
+#include "context.hh"
#include "context-def.hh"
#include "context-mod.hh"
#include "dimensions.hh"
#include "lily-guile.hh"
#include "lily-lexer.hh"
#include "lily-parser.hh"
+#include "ly-module.hh"
#include "main.hh"
#include "misc.hh"
#include "music.hh"
#include "score.hh"
#include "text-interface.hh"
#include "warn.hh"
+#include "lily-imports.hh"
void
Lily_parser::parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s)
parser->lexer_->override_input (spot))
/* ES TODO:
-- Don't use lily module, create a new module instead.
- delay application of the function
*/
-#define LOWLEVEL_MAKE_SYNTAX(proc, args) \
- scm_apply_0 (proc, args)
+
+#define LOWLEVEL_MAKE_SYNTAX(location, proc, ...) \
+ with_location \
+ (parser->lexer_->override_input (location).smobbed_copy (), \
+ proc, \
+ ##__VA_ARGS__)
+
/* Syntactic Sugar. */
#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))
+ LOWLEVEL_MAKE_SYNTAX (location, Syntax::name, ##__VA_ARGS__)
+
#define START_MAKE_SYNTAX(name, ...) \
- scm_list_n (ly_lily_module_constant (name) , ##__VA_ARGS__, SCM_UNDEFINED)
+ scm_list_n (Syntax::name, ##__VA_ARGS__, SCM_UNDEFINED)
+
#define FINISH_MAKE_SYNTAX(start, location, ...) \
- 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)))))
+ LOWLEVEL_MAKE_SYNTAX \
+ (location, \
+ Guile_user::apply, \
+ scm_car (start), \
+ scm_append_x \
+ (scm_list_2 (scm_cdr (start), \
+ scm_list_n (__VA_ARGS__, SCM_UNDEFINED))))
SCM get_next_unique_context_id ();
SCM get_next_unique_lyrics_context_id ();
SCM check_scheme_arg (Lily_parser *parser, Input loc,
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 loc_on_copy (Lily_parser *parser, 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);
-SCM make_duration (SCM t, int dots = 0);
+SCM make_duration (SCM t, int dots = 0, SCM factor = SCM_UNDEFINED);
bool is_regular_identifier (SCM id, bool multiple=false);
+SCM make_reverse_key_list (SCM keys);
+SCM try_word_variants (SCM pred, SCM str);
SCM try_string_variants (SCM pred, SCM str);
int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
%token DESCRIPTION "\\description"
%token DRUMMODE "\\drummode"
%token DRUMS "\\drums"
+%token ETC "\\etc"
%token FIGUREMODE "\\figuremode"
%token FIGURES "\\figures"
%token HEADER "\\header"
%token BOOK_IDENTIFIER
%token CHORD_MODIFIER
%token CHORD_REPETITION
-%token CONTEXT_MOD_IDENTIFIER
%token DRUM_PITCH
-%token PITCH_IDENTIFIER
+ /* Artificial token for durations in argument lists */
+%token DURATION_ARG
%token DURATION_IDENTIFIER
%token EVENT_IDENTIFIER
%token EVENT_FUNCTION
%token FRACTION
+%token LOOKUP_IDENTIFIER
%token LYRIC_ELEMENT
%token MARKUP_FUNCTION
%token MARKUP_LIST_FUNCTION
%token MUSIC_IDENTIFIER
%token NOTENAME_PITCH
%token NUMBER_IDENTIFIER
+%token PITCH_IDENTIFIER
%token REAL
%token RESTNAME
%token SCM_ARG
%token STRING
%token SYMBOL_LIST
%token TONICNAME_PITCH
+%token WORD
%left '-' '+'
start_symbol:
lilypond
| EMBEDDED_LILY {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} embedded_lilypond {
parser->lexer_->pop_state ();
*retval = $3;
toplevel_expression:
- {
- parser->lexer_->add_scope (get_header (parser));
- } lilypond_header {
- parser->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $2);
+ header_block {
+ parser->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $1);
}
| book_block {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-book-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| bookpart_block {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| BOOK_IDENTIFIER {
SCM proc = parser->lexer_->lookup_identifier
- (Book::unsmob($1)->paper_
+ (unsmob<Book>($1)->paper_
? "toplevel-book-handler"
: "toplevel-bookpart-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| score_block {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| composite_music {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-music-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| full_markup {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
- scm_call_2 (proc, parser->self_scm (), scm_list_1 ($1));
+ scm_call_1 (proc, scm_list_1 ($1));
}
| full_markup_list {
SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
+ scm_call_1 (proc, $1);
}
| SCM_TOKEN {
// Evaluate and ignore #xxx, as opposed to \xxx
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::unsmob ($1))
+ scm_call_1 (proc, out);
+ } else if (unsmob<Score> ($1))
{
SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
- scm_call_2 (proc, parser->self_scm (), $1);
- } else if (Output_def * od = Output_def::unsmob ($1)) {
+ scm_call_1 (proc, $1);
+ } else if (Output_def * od = unsmob<Output_def> ($1)) {
SCM id = SCM_EOL;
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $1);
+ } else if (ly_is_module ($1))
+ {
+ SCM module = get_header (parser);
+ ly_module_copy (module, $1);
+ parser->lexer_->set_identifier
+ (ly_symbol2scm ("$defaultheader"), module);
} else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
parser->parser_error (@1, _("bad expression type"));
}
| output_def {
SCM id = SCM_EOL;
- Output_def * od = Output_def::unsmob ($1);
+ Output_def * od = unsmob<Output_def> ($1);
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $1);
}
;
+lookup:
+ LOOKUP_IDENTIFIER
+ | LOOKUP_IDENTIFIER '.' symbol_list_rev
+ {
+ $$ = loc_on_copy (parser, @$,
+ nested_property ($1, scm_reverse_x ($3, SCM_EOL)));
+ }
+ ;
+
embedded_scm_bare:
SCM_TOKEN
{
embedded_scm_active:
SCM_IDENTIFIER
| scm_function_call
+ | lookup
;
embedded_scm_bare_arg:
$$ = parser->lexer_->eval_scm_token ($1, @1);
}
| FRACTION
+ | partial_markup
| full_markup_list
| context_modification
+ | header_block
| score_block
| context_def_spec_block
| book_block
| bookpart_block
| output_def
+ | lookup
;
/* The generic version may end in music, or not */
embedded_scm:
embedded_scm_bare
| scm_function_call
+ | lookup
;
/* embedded_scm_arg is _not_ casting pitches to music by default, this
scm_function_call:
SCM_FUNCTION function_arglist {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
// 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", @$);
+ $$ = MAKE_SYNTAX (void_music, @$);
}
| identifier_init_nonumber
| embedded_lilypond_number
| post_event post_events
{
$$ = scm_reverse_x ($2, SCM_EOL);
- if (Music *m = Music::unsmob ($1))
+ if (Music *m = unsmob<Music> ($1))
{
if (m->is_mus_type ("post-event-wrapper"))
$$ = scm_append
| multiplied_duration
| music_embedded music_embedded music_list {
$3 = scm_reverse_x ($3, SCM_EOL);
- if (Music::unsmob ($2))
+ if (unsmob<Music> ($2))
$3 = scm_cons ($2, $3);
- if (Music::unsmob ($1))
+ if (unsmob<Music> ($1))
$3 = scm_cons ($1, $3);
- $$ = MAKE_SYNTAX ("sequential-music", @$, $3);
+ $$ = MAKE_SYNTAX (sequential_music, @$, $3);
}
| error {
parser->error_level_ = 1;
| lilypond_header_body assignment {
}
- | lilypond_header_body embedded_scm {
-
+ | lilypond_header_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | lilypond_header_body embedded_scm_active {
+ if (ly_is_module ($2))
+ ly_module_copy (scm_current_module (), $2);
+ else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
}
;
}
;
+header_block:
+ {
+ parser->lexer_->add_scope (get_header (parser));
+ } lilypond_header {
+ $$ = $2;
+ }
+ ;
+
/*
DECLARATIONS
*/
assignment_id:
- STRING { $$ = $1; }
+ STRING
+ | WORD
;
assignment:
parser->lexer_->set_identifier ($1, $3);
$$ = SCM_UNSPECIFIED;
}
- | assignment_id property_path '=' identifier_init {
- SCM path = scm_cons (scm_string_to_symbol ($1), $2);
- parser->lexer_->set_identifier (path, $4);
+ | assignment_id '.' property_path '=' identifier_init {
+ SCM path = scm_cons (scm_string_to_symbol ($1), $3);
+ parser->lexer_->set_identifier (path, $5);
$$ = SCM_UNSPECIFIED;
}
- | assignment_id '.' property_path '=' identifier_init {
+ | 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
+ | symbol_list_part_bare '.' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
+ | symbol_list_part_bare ',' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
| post_event_nofinger post_events
{
$$ = scm_reverse_x ($2, SCM_EOL);
- if (Music *m = Music::unsmob ($1))
+ if (Music *m = unsmob<Music> ($1))
{
if (m->is_mus_type ("post-event-wrapper"))
$$ = scm_append
;
identifier_init_nonumber:
- score_block
+ header_block
+ | score_block
| book_block
| bookpart_block
| output_def
| pitch_or_music
| FRACTION
| string
- | embedded_scm
+ | embedded_scm
+ | partial_markup
| full_markup_list
| context_modification
+ | partial_function ETC
+ {
+ $$ = MAKE_SYNTAX (partial_music_function, @$,
+ scm_reverse_x ($1, SCM_EOL));
+ }
+ ;
+
+// Partial functions
+partial_function:
+ MUSIC_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
+ }
+ | EVENT_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
+ }
+ | SCM_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
+ }
+ | OVERRIDE grob_prop_path '='
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_override_function,
+ scm_cdr ($2), scm_car ($2)),
+ SCM_EOL);
+ }
+ | SET context_prop_spec '='
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_set_function,
+ scm_cadr ($2), scm_car ($2)),
+ SCM_EOL);
+ }
+ | MUSIC_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
+ }
+ | EVENT_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
+ }
+ | SCM_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
+ }
+ | OVERRIDE grob_prop_path '=' partial_function
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_override_function,
+ scm_cdr ($2), scm_car ($2)),
+ $4);
+ }
+ | SET context_prop_spec '=' partial_function
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_set_function,
+ scm_cadr ($2), scm_car ($2)),
+ $4);
+ }
+ | MUSIC_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
+ }
+ | EVENT_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
+ }
+ | SCM_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
+ }
;
context_def_spec_block:
CONTEXT '{' context_def_spec_body '}'
{
$$ = $3;
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
td->origin ()->set_spot (@$);
}
embedded_scm
|
{
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
}
composite_music
{
}
| context_def_spec_body context_mod {
if (!SCM_UNBNDP ($2)) {
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- Context_def::unsmob ($$)->add_context_mod ($2);
+ unsmob<Context_def> ($$)->add_context_mod ($2);
}
}
| context_def_spec_body context_modification {
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- SCM new_mods = Context_mod::unsmob ($2)->get_mods ();
+ 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);
+ Context_def *td = unsmob<Context_def> ($1);
if (scm_is_eq ($2, SCM_UNSPECIFIED))
;
- else if (!td && Context_def::unsmob ($2))
+ else if (!td && unsmob<Context_def> ($2))
$$ = $2;
else {
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- if (Music::unsmob ($2)) {
+ if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
- $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ $2 = scm_call_1 (proc, $2);
}
- if (Context_mod *cm = Context_mod::unsmob ($2)) {
+ if (Context_mod *cm = unsmob<Context_mod> ($2)) {
for (SCM m = cm->get_mods (); scm_is_pair (m); m = scm_cdr (m)) {
td->add_context_mod (scm_car (m));
}
book_block:
BOOK '{' book_body '}' {
$$ = $3;
- Book::unsmob ($$)->origin ()->set_spot (@$);
+ unsmob<Book> ($$)->origin ()->set_spot (@$);
pop_paper (parser);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F);
}
{
Book *book = new Book;
init_papers (parser);
- book->paper_ = dynamic_cast<Output_def*> (Output_def::unsmob (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
+ book->paper_ = dynamic_cast<Output_def*> (unsmob<Output_def> (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"), $1);
}
| book_body paper_block {
- Book::unsmob ($1)->paper_ = Output_def::unsmob ($2);
- set_paper (parser, Output_def::unsmob ($2));
+ unsmob<Book> ($1)->paper_ = unsmob<Output_def> ($2);
+ set_paper (parser, unsmob<Output_def> ($2));
}
| book_body bookpart_block {
SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler");
}
| book_body composite_music {
SCM proc = parser->lexer_->lookup_identifier ("book-music-handler");
- scm_call_3 (proc, parser->self_scm (), $1, $2);
+ scm_call_2 (proc, $1, $2);
}
| book_body full_markup {
SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
{
SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
scm_call_2 (proc, $1, out);
- } else if (Score::unsmob ($2))
+ } else if (unsmob<Score> ($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 (Output_def *od = unsmob<Output_def> ($2)) {
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper")))) {
+ unsmob<Book> ($1)->paper_ = od;
+ set_paper (parser, od);
+ } else {
+ parser->parser_error (@2, _ ("need \\paper for paper block"));
+ }
+ } else if (ly_is_module ($2))
+ {
+ ly_module_copy (unsmob<Book> ($1)->header_, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("bad expression type"));
}
| book_body
{
- parser->lexer_->add_scope (Book::unsmob ($1)->header_);
+ parser->lexer_->add_scope (unsmob<Book> ($1)->header_);
} lilypond_header
| book_body error {
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
book->bookparts_ = SCM_EOL;
bookpart_block:
BOOKPART '{' bookpart_body '}' {
$$ = $3;
- Book::unsmob ($$)->origin ()->set_spot (@$);
+ unsmob<Book> ($$)->origin ()->set_spot (@$);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
}
;
parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1);
}
| bookpart_body paper_block {
- Book::unsmob ($$)->paper_ = Output_def::unsmob ($2);
+ unsmob<Book> ($$)->paper_ = unsmob<Output_def> ($2);
}
| bookpart_body score_block {
SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
}
| bookpart_body composite_music {
SCM proc = parser->lexer_->lookup_identifier ("bookpart-music-handler");
- scm_call_3 (proc, parser->self_scm (), $1, $2);
+ scm_call_2 (proc, $1, $2);
}
| bookpart_body full_markup {
SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
{
SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
scm_call_2 (proc, $1, out);
- } else if (Score::unsmob ($2))
+ } else if (unsmob<Score> ($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 (Output_def *od = unsmob<Output_def> ($2)) {
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper")))) {
+ unsmob<Book> ($1)->paper_ = od;
+ } else {
+ parser->parser_error (@2, _ ("need \\paper for paper block"));
+ }
+ } else if (ly_is_module ($2)) {
+ Book *book = unsmob<Book> ($1);
+ if (!ly_is_module (book->header_))
+ book->header_ = ly_make_module (false);
+ ly_module_copy (book->header_, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("bad expression type"));
}
| bookpart_body
{
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
if (!ly_is_module (book->header_))
book->header_ = ly_make_module (false);
parser->lexer_->add_scope (book->header_);
} lilypond_header
| bookpart_body error {
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
}
score_block:
SCORE '{' score_body '}' {
- Score::unsmob ($3)->origin ()->set_spot (@$);
+ unsmob<Score> ($3)->origin ()->set_spot (@$);
$$ = $3;
}
;
score_body:
score_items {
- if (!Score::unsmob ($1)) {
+ if (!unsmob<Score> ($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));
+ unsmob<Score> ($$)->set_header (scm_car ($1));
$1 = scm_cdr ($1);
}
for (SCM p = scm_reverse_x ($1, SCM_EOL);
scm_is_pair (p); p = scm_cdr (p))
{
- Score::unsmob ($$)->
- add_output_def (Output_def::unsmob (scm_car (p)));
+ unsmob<Score> ($$)->
+ add_output_def (unsmob<Output_def> (scm_car (p)));
}
}
}
| score_body error {
- Score::unsmob ($$)->error_found_ = true;
+ unsmob<Score> ($$)->error_found_ = true;
}
;
}
| score_items score_item
{
- Output_def *od = Output_def::unsmob ($2);
+ Output_def *od = unsmob<Output_def> ($2);
if (od) {
- if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
od = 0;
$2 = SCM_UNSPECIFIED;
}
- } else if (!Score::unsmob ($$)) {
- if (Music::unsmob ($2)) {
- SCM scorify = ly_lily_module_constant ("scorify-music");
- $2 = scm_call_2 (scorify, $2, parser->self_scm ());
+ } else if (!unsmob<Score> ($$)) {
+ if (unsmob<Music> ($2)) {
+ $2 = Lily::scorify_music ($2);
}
- if (Score::unsmob ($2))
+ if (unsmob<Score> ($2))
{
$$ = $2;
$2 = SCM_UNSPECIFIED;
}
}
- Score *score = Score::unsmob ($$);
+ Score *score = unsmob<Score> ($$);
if (score && scm_is_pair ($1)) {
if (ly_is_module (scm_car ($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)));
+ score->add_output_def (unsmob<Output_def> (scm_car (p)));
}
}
if (od) {
scm_set_cdr_x ($$, scm_cons ($2, scm_cdr ($$)));
else
$$ = scm_cons ($2, $$);
+ } else if (ly_is_module ($2)) {
+ SCM module = SCM_UNSPECIFIED;
+ if (score) {
+ module = score->get_header ();
+ if (!ly_is_module (module))
+ {
+ module = ly_make_module (false);
+ score->set_header (module);
+ }
+ } else if (scm_is_pair ($$) && ly_is_module (scm_car ($$)))
+ module = scm_car ($$);
+ else {
+ module = ly_make_module (false);
+ $$ = scm_cons (module, $$);
+ }
+ ly_module_copy (module, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("Spurious expression in \\score"));
}
| score_items
{
- if (Score *score = Score::unsmob ($1)) {
+ if (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 ());
paper_block:
output_def {
- Output_def *od = Output_def::unsmob ($1);
+ Output_def *od = unsmob<Output_def> ($1);
- if (od->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T)
+ if (!to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
parser->parser_error (@1, _ ("need \\paper for paper block"));
$$ = get_paper (parser)->unprotect ();
output_def_body:
output_def_head_with_mode_switch '{' {
- Output_def::unsmob ($1)->input_origin_.set_spot (@$);
+ unsmob<Output_def> ($1)->input_origin_.set_spot (@$);
// This is a stupid trick to mark the beginning of the
// body for deciding whether to allow
// embedded_scm_active to have an output definition
// definitions.
if (scm_is_pair ($1))
{
- Output_def *o = Output_def::unsmob ($2);
+ Output_def *o = unsmob<Output_def> ($2);
if (o) {
o->input_origin_.set_spot (@$);
$1 = o->self_scm ();
} else
$1 = scm_car ($1);
}
- if (Context_def::unsmob ($2))
- assign_context_def (Output_def::unsmob ($1), $2);
+ if (unsmob<Context_def> ($2))
+ assign_context_def (unsmob<Output_def> ($1), $2);
// Seems unlikely, but let's be complete:
- else if (Music::unsmob ($2))
+ else if (unsmob<Music> ($2))
{
SCM proc = parser->lexer_->lookup_identifier
("output-def-music-handler");
- scm_call_3 (proc, parser->self_scm (),
- $1, $2);
+ scm_call_2 (proc, $1, $2);
} else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _("bad expression type"));
$$ = $1;
{
if (scm_is_pair ($1))
$1 = scm_car ($1);
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} music_or_context_def
{
parser->lexer_->pop_state ();
- if (Context_def::unsmob ($3))
- assign_context_def (Output_def::unsmob ($1), $3);
+ if (unsmob<Context_def> ($3))
+ assign_context_def (unsmob<Output_def> ($1), $3);
else {
SCM proc = parser->lexer_->lookup_identifier
("output-def-music-handler");
- scm_call_3 (proc, parser->self_scm (),
- $1, $3);
+ scm_call_2 (proc, $1, $3);
}
$$ = $1;
}
tempo_event:
TEMPO steno_duration '=' tempo_range {
- $$ = MAKE_SYNTAX ("tempo", @$, SCM_EOL, $2, $4);
+ $$ = MAKE_SYNTAX (tempo, @$, SCM_EOL, $2, $4);
}
- | TEMPO scalar steno_duration '=' tempo_range {
- $$ = MAKE_SYNTAX ("tempo", @$, $2, $3, $5);
+ | TEMPO text steno_duration '=' tempo_range {
+ $$ = MAKE_SYNTAX (tempo, @$, $2, $3, $5);
}
- | TEMPO scalar {
- $$ = MAKE_SYNTAX ("tempo", @$, $2);
+ | TEMPO text {
+ $$ = MAKE_SYNTAX (tempo, @$, $2);
} %prec ':'
;
$$ = SCM_EOL;
}
| music_list music_embedded {
- if (Music::unsmob ($2))
+ if (unsmob<Music> ($2))
$$ = scm_cons ($2, $1);
}
| music_list error {
pitch_or_music
{
$$ = make_music_from_simple (parser, @1, $1);
- if (!Music::unsmob ($$))
+ if (!unsmob<Music> ($$))
{
parser->parser_error (@1, _ ("music expected"));
- $$ = MAKE_SYNTAX ("void-music", @$);
+ $$ = MAKE_SYNTAX (void_music, @$);
}
}
;
music_embedded:
music
{
- if (Music::unsmob ($1)->is_mus_type ("post-event")) {
+ if (unsmob<Music> ($1)->is_mus_type ("post-event")) {
parser->parser_error (@1, _ ("unexpected post-event"));
$$ = SCM_UNSPECIFIED;
}
{
Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
- parser->default_duration_ = *Duration::unsmob ($1);
+ parser->default_duration_ = *unsmob<Duration> ($1);
n->set_property ("duration", $1);
if (scm_is_pair ($2))
{
if (scm_is_eq ($1, SCM_UNSPECIFIED))
$$ = $1;
- else if (Music *m = Music::unsmob ($1)) {
+ else if (Music *m = unsmob<Music> ($1)) {
if (m->is_mus_type ("post-event")) {
parser->parser_error
(@1, _ ("unexpected post-event"));
repeated_music:
REPEAT simple_string unsigned_number music
{
- $$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, SCM_EOL);
+ $$ = MAKE_SYNTAX (repeat, @$, $2, $3, $4, SCM_EOL);
}
| REPEAT simple_string unsigned_number music ALTERNATIVE braced_music_list
{
- $$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, $6);
+ $$ = MAKE_SYNTAX (repeat, @$, $2, $3, $4, $6);
}
;
sequential_music:
SEQUENTIAL braced_music_list {
- $$ = MAKE_SYNTAX ("sequential-music", @$, $2);
+ $$ = MAKE_SYNTAX (sequential_music, @$, $2);
}
| braced_music_list {
- $$ = MAKE_SYNTAX ("sequential-music", @$, $1);
+ $$ = MAKE_SYNTAX (sequential_music, @$, $1);
}
;
simultaneous_music:
SIMULTANEOUS braced_music_list {
- $$ = MAKE_SYNTAX ("simultaneous-music", @$, $2);
+ $$ = MAKE_SYNTAX (simultaneous_music, @$, $2);
}
| DOUBLE_ANGLE_OPEN music_list DOUBLE_ANGLE_CLOSE {
- $$ = MAKE_SYNTAX ("simultaneous-music", @$, scm_reverse_x ($2, SCM_EOL));
+ $$ = MAKE_SYNTAX (simultaneous_music, @$, scm_reverse_x ($2, SCM_EOL));
}
;
context_modification:
WITH
{
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' context_mod_list '}'
{
parser->lexer_->pop_state ();
$$ = $4;
}
- | WITH CONTEXT_MOD_IDENTIFIER
- {
- $$ = $2;
- }
- | CONTEXT_MOD_IDENTIFIER
- {
- $$ = $1;
- }
| WITH context_modification_arg
{
- if (Music::unsmob ($2)) {
+ if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
- $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ $2 = scm_call_1 (proc, $2);
}
- if (Context_mod::unsmob ($2))
+ if (unsmob<Context_mod> ($2))
$$ = $2;
else {
- parser->parser_error (@2, _ ("not a context mod"));
+ // let's permit \with #*unspecified* to go for
+ // an empty context mod
+ if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _ ("not a context mod"));
$$ = Context_mod ().smobbed_copy ();
}
}
| MUSIC_IDENTIFIER
;
-optional_context_mod:
- /**/ {
- $$ = SCM_EOL;
- }
- | context_modification
+/* A list of single mods collected from a (possibly empty) sequence of
+ * context modifications, usually written as \with ... \with ...
+ */
+
+optional_context_mods:
+ context_modification_mods_list
{
- $$ = $1;
+ if (scm_is_pair ($1))
+ $$ = scm_append_x (scm_reverse_x ($1, SCM_EOL));
}
;
+/* The worker for optional_context_mods conses a (reversed) list where
+ * each element contains the list of single context mods from one
+ * context modification block. Context_mod::get_mods creates fresh
+ * copies, so it's okay to use append! on them.
+ */
+
+context_modification_mods_list:
+ /**/ {
+ $$ = SCM_EOL;
+ }
+ | context_modification_mods_list context_modification
+ {
+ if (Context_mod *m = unsmob<Context_mod> ($2))
+ $$ = scm_cons (m->get_mods (), $1);
+ }
+ ;
+
+/* A Context_mod is a container for a list of context mods like
+ * \consists ... \override ... . context_mod_list produces a
+ * Context_mod from the inside of a \with { ... } statement.
+ */
+
context_mod_list:
/**/ {
$$ = Context_mod ().smobbed_copy ();
}
| context_mod_list context_mod {
if (!SCM_UNBNDP ($2))
- Context_mod::unsmob ($1)->add_context_mod ($2);
- }
- | context_mod_list CONTEXT_MOD_IDENTIFIER {
- Context_mod *md = Context_mod::unsmob ($2);
- if (md)
- Context_mod::unsmob ($1)->add_context_mods (md->get_mods ());
+ unsmob<Context_mod> ($1)->add_context_mod ($2);
}
| context_mod_list context_mod_arg {
- if (scm_is_eq ($2, SCM_UNSPECIFIED))
- ;
- else if (Music::unsmob ($2)) {
+ if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
- $2 = scm_call_2 (proc, parser->self_scm (), $2);
+ $2 = scm_call_1 (proc, $2);
}
- if (Context_mod::unsmob ($2))
- Context_mod::unsmob ($$)->add_context_mods
- (Context_mod::unsmob ($2)->get_mods ());
- else {
+ if (unsmob<Context_mod> ($2))
+ unsmob<Context_mod> ($$)->add_context_mods
+ (unsmob<Context_mod> ($2)->get_mods ());
+ else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
parser->parser_error (@2, _ ("not a context mod"));
- }
}
;
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);
+ CONTEXT symbol optional_id optional_context_mods {
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, $4, 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);
+ | NEWCONTEXT symbol optional_id optional_context_mods {
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, $4, SCM_BOOL_T);
}
;
new_lyrics:
- ADDLYRICS lyric_mode_music {
- $$ = scm_list_1 ($2);
+ ADDLYRICS optional_context_mods lyric_mode_music {
+ $$ = scm_acons ($3, $2, SCM_EOL);
}
- | new_lyrics ADDLYRICS lyric_mode_music {
- $$ = scm_cons ($3, $1);
+ | new_lyrics ADDLYRICS optional_context_mods lyric_mode_music {
+ $$ = scm_acons ($4, $3, $1);
}
;
| repeated_music
| music_bare
| LYRICSTO simple_string lyric_mode_music {
- $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, SCM_EOL, $3);
+ $$ = MAKE_SYNTAX (lyric_combine, @$, $2, SCM_EOL, $3);
}
| LYRICSTO symbol '=' simple_string lyric_mode_music
{
- $$ = MAKE_SYNTAX ("lyric_combine", @$, $3, $2, $4);
+ $$ = MAKE_SYNTAX (lyric_combine, @$, $4, $2, $5);
}
;
Input i;
i.set_location (@1, @2);
$$ = FINISH_MAKE_SYNTAX ($1, i, $2);
- $$ = MAKE_SYNTAX ("add-lyrics", @$, $$, scm_reverse_x ($3, SCM_EOL));
+ $$ = MAKE_SYNTAX (add_lyrics, @$, $$, scm_reverse_x ($3, SCM_EOL));
} %prec COMPOSITE
| context_prefix contextable_music
{
| contexted_basic_music
| basic_music new_lyrics
{
- $$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL));
+ $$ = MAKE_SYNTAX (add_lyrics, @$, $1, scm_reverse_x ($2, SCM_EOL));
} %prec COMPOSITE
;
{
$$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
}
+ | SYMBOL_LIST ',' symbol_list_rev
+ {
+ $$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
+ }
;
symbol_list_rev:
{
$$ = scm_append_x (scm_list_2 ($3, $1));
}
+ | symbol_list_rev ',' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($3, $1));
+ }
;
-// symbol_list_part delivers elements in reverse copy.
+// symbol_list_part delivers elements in reverse copy, no lookahead
symbol_list_part:
- symbol_list_element
+ symbol_list_part_bare
+ | embedded_scm_bare
{
- SCM sym_l_p = ly_lily_module_constant ("symbol-list?");
- $$ = try_string_variants (sym_l_p, $1);
+ $$ = make_reverse_key_list ($1);
if (SCM_UNBNDP ($$)) {
- parser->parser_error (@1, _("not a symbol"));
+ parser->parser_error (@1, _("not a key"));
$$ = SCM_EOL;
- } else
- $$ = scm_reverse ($$);
+ }
}
;
symbol_list_element:
STRING
- | embedded_scm_bare
+ {
+ $$ = scm_string_to_symbol ($1);
+ }
+ | UNSIGNED
;
+symbol_list_part_bare:
+ WORD
+ {
+ $$ = try_word_variants (Lily::key_list_p, $1);
+ if (SCM_UNBNDP ($$)) {
+ parser->parser_error (@1, _("not a key"));
+ $$ = SCM_EOL;
+ } else
+ $$ = scm_reverse ($$);
+ }
+ | symbol_list_element
+ {
+ $$ = scm_list_1 ($1);
+ }
+ ;
+
function_arglist_nonbackup:
function_arglist_common
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
(parser, @3, $3),
$1, $2);
}
- | function_arglist_nonbackup_reparse REPARSE duration_length
+ | function_arglist_nonbackup_reparse REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE reparsed_rhythm
{
$$ = check_scheme_arg (parser, @3, $3, $1, $2);
}
}
;
+
+reparsed_rhythm:
+ DURATION_ARG dots multipliers post_events
+ {
+ $$ = make_music_from_simple (parser, @$,
+ make_duration ($1, scm_to_int ($2), $3));
+ Music *m = unsmob<Music> ($$);
+ assert (m);
+ if (scm_is_pair ($4))
+ m->set_property ("articulations",
+ scm_reverse_x ($4, SCM_EOL));
+ } %prec ':'
+ ;
+
function_arglist_nonbackup_reparse:
EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
{
else
MYREPARSE (@4, $2, SCM_ARG, $4);
}
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup WORD
+ {
+ $$ = $3;
+ SCM res = try_word_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;
{
$$ = $3;
if (scm_is_true (scm_call_1 ($2, $4)))
+ // May be 3 \cm or similar
MYREPARSE (@4, $2, REAL, $4);
+ else if (scm_is_true (scm_call_1 ($2, scm_list_1 ($4))))
+ MYREPARSE (@4, $2, SYMBOL_LIST, scm_list_1 ($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);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($2, d)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, d))))
+ MYREPARSE (@4, $2, DURATION_ARG, d);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
+ } else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
}
}
- | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup DURATION_IDENTIFIER {
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup DURATION_IDENTIFIER
+ {
$$ = $3;
- MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, $4))))
+ MYREPARSE (@4, $2, DURATION_ARG, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
}
;
$$ = scm_cons ($$, $3);
else
{
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_ARG, $4, @4);
}
}
{
$$ = scm_cons ($4, $3);
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (EVENT_IDENTIFIER, $4, @4);
}
}
} else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (PITCH_IDENTIFIER, $4, @4);
}
}
} else if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (TONICNAME_PITCH, $4, @4);
}
}
if (scm_is_true (scm_call_1 ($2, $4)))
$$ = scm_cons ($4, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_IDENTIFIER, $4, @4);
}
}
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup UNSIGNED
{
+ $$ = $3;
if (scm_is_true (scm_call_1 ($2, $4)))
- {
+ // May be 3 \cm or similar
MYREPARSE (@4, $2, REAL, $4);
- $$ = $3;
- } else {
+ else if (scm_is_true (scm_call_1 ($2, scm_list_1 ($4))))
+ MYREPARSE (@4, $2, SYMBOL_LIST, scm_list_1 ($4));
+ else {
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);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($2, d)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, d))))
+ MYREPARSE (@4, $2, DURATION_ARG, d);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (UNSIGNED, $4, @4);
+ }
} else {
- MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
- $$ = $3;
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (UNSIGNED, $4, @4);
}
}
}
$$ = $3;
MYREPARSE (@4, $2, REAL, $4);
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (REAL, $4, @4);
}
}
{
$$ = scm_cons ($4, $3);
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
}
}
if (scm_is_true (scm_call_1 ($2, $$)))
$$ = scm_cons ($$, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (UNSIGNED, $5, @5);
parser->lexer_->push_extra_token (@4, '-');
}
MYREPARSE (@5, $2, REAL, n);
$$ = $3;
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (REAL, n, @5);
}
}
if (scm_is_true (scm_call_1 ($2, n))) {
$$ = scm_cons (n, $3);
} else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (NUMBER_IDENTIFIER, n, @5);
}
}
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
{
+ $$ = $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);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, $4))))
+ MYREPARSE (@4, $2, DURATION_ARG, $4);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (DURATION_IDENTIFIER, $4, @4);
}
}
else
$$ = scm_cons (res, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
MYBACKUP (SCM_IDENTIFIER, $4, @4);
}
}
else
$$ = scm_cons (res, $3);
else {
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (STRING, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup WORD
+ {
+ SCM res = try_word_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_copy (parser, @3, $1), $3);
MYBACKUP (STRING, $4, @4);
}
}
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
}
- | function_arglist_backup REPARSE duration_length
+ | function_arglist_backup REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
+ }
+ | function_arglist_backup REPARSE reparsed_rhythm
{
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
function_arglist_nonbackup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
{
- $$ = scm_cons (loc_on_music (@4, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
;
function_arglist_nonbackup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
{
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ }
+ ;
+
+// Partial function arglists are returned just in their incomplete
+// state: when combined with the music function, the missing parts of
+// the signature can be reconstructed
+//
+// To serve as a partial arglist, the argument list must absolutely
+// _not_ be in "skipping optional arguments" mode since then there is
+// some backup token that has nowhere to go before \etc.
+//
+// So we can skim off an arbitrary number of arguments from the end of
+// the argument list. The argument list remaining afterwards has to
+// be in not-skipping-optional-arguments mode.
+
+function_arglist_partial:
+ EXPECT_SCM function_arglist_optional
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM function_arglist_partial_optional
+ {
+ $$ = $2;
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup
+ {
+ $$ = $3;
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_partial
+ {
+ $$ = $3;
+ }
+ ;
+
+function_arglist_partial_optional:
+ EXPECT_SCM function_arglist_optional
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM function_arglist_partial_optional
+ {
+ $$ = $2;
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup
+ {
+ $$ = $3;
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_partial_optional
+ {
+ $$ = $3;
}
;
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
}
- | function_arglist_common_reparse REPARSE duration_length
+ | function_arglist_common_reparse REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
+ }
+ | function_arglist_common_reparse REPARSE reparsed_rhythm
{
$$ = check_scheme_arg (parser, @3,
$3, $1, $2);
// know the predicate to be false.
MYREPARSE (@3, $1, SCM_ARG, $3);
}
+ | EXPECT_SCM function_arglist_optional WORD
+ {
+ $$ = $2;
+ SCM res = try_word_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_optional full_markup
{
$$ = $2;
{
$$ = $2;
if (scm_is_true (scm_call_1 ($1, $3)))
+ // May be 3 \cm or similar
MYREPARSE (@3, $1, REAL, $3);
+ else if (scm_is_true (scm_call_1 ($1, scm_list_1 ($3))))
+ MYREPARSE (@3, $1, SYMBOL_LIST, scm_list_1 ($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);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($1, d)))
+ MYREPARSE (@3, $1, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, d))))
+ MYREPARSE (@3, $1, DURATION_ARG, d);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
+ } else
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
}
}
| EXPECT_SCM function_arglist_optional DURATION_IDENTIFIER
{
$$ = $2;
- MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
+ if (scm_is_true (scm_call_1 ($1, $3)))
+ MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, DURATION_ARG, $3);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
}
| EXPECT_SCM function_arglist_optional '-' UNSIGNED
{
function_arglist_backup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
{
- $$ = scm_cons (loc_on_music (@4, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
| function_arglist_skip_backup BACKUP
;
function_arglist_backup
| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
{
- $$ = scm_cons (loc_on_music (@3, $1), $3);
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
}
;
music_function_call:
MUSIC_FUNCTION function_arglist {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
mode_changed_music:
mode_changing_head grouped_music_list {
- if ($1 == ly_symbol2scm ("chords"))
+ if (scm_is_eq ($1, ly_symbol2scm ("chords")))
{
- $$ = MAKE_SYNTAX ("unrelativable-music", @$, $2);
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $2);
}
else
{
}
parser->lexer_->pop_state ();
}
- | mode_changing_head_with_context optional_context_mod grouped_music_list {
- Context_mod *ctxmod = Context_mod::unsmob ($2);
- SCM mods = SCM_EOL;
- if (ctxmod)
- mods = ctxmod->get_mods ();
- $$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3);
- if ($1 == ly_symbol2scm ("ChordNames"))
+ | mode_changing_head_with_context optional_context_mods grouped_music_list {
+ $$ = MAKE_SYNTAX (context_specification, @$, $1, SCM_EOL, $2, SCM_BOOL_T, $3);
+ if (scm_is_eq ($1, ly_symbol2scm ("ChordNames")))
{
- $$ = MAKE_SYNTAX ("unrelativable-music", @$, $$);
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $$);
}
parser->lexer_->pop_state ();
}
mode_changing_head:
NOTEMODE {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
$$ = ly_symbol2scm ("notes");
}
| DRUMMODE
{
- SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("drums");
}
$$ = ly_symbol2scm ("figures");
}
| CHORDMODE {
- SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
- parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_chord_state (nn);
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("chords");
}
mode_changing_head_with_context:
DRUMS {
- SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("DrumStaff");
}
$$ = ly_symbol2scm ("FiguredBass");
}
| CHORDS {
- SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
- parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_chord_state (nn);
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("ChordNames");
}
| LYRICS
context_change:
CHANGE symbol '=' simple_string {
- $$ = MAKE_SYNTAX ("context-change", @$, $2, $4);
+ $$ = MAKE_SYNTAX (context_change, @$, $2, $4);
}
;
symbol_list_rev {
$$ = scm_reverse_x ($1, SCM_EOL);
}
- | symbol_list_rev property_path {
- $$ = scm_reverse_x ($1, $2);
- }
;
property_operation:
| UNSET symbol {
$$ = scm_list_2 (ly_symbol2scm ("unset"), $2);
}
- | OVERRIDE property_path '=' scalar {
+ | OVERRIDE revert_arg '=' scalar {
if (scm_ilength ($2) < 2) {
parser->parser_error (@2, _("bad grob property path"));
$$ = SCM_UNDEFINED;
{
$$ = scm_append_x (scm_list_2 ($5, $3));
}
+ | revert_arg_backup BACKUP SCM_ARG ',' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($5, $3));
+ }
| revert_arg_backup BACKUP SCM_ARG symbol_list_part
{
$$ = scm_append_x (scm_list_2 ($4, $3));
| context_def_mod STRING {
$$ = scm_list_2 ($1, $2);
}
+ | context_def_mod WORD {
+ $$ = scm_list_2 ($1, $2);
+ }
| context_def_mod embedded_scm
{
if (!scm_is_string ($2)
- && ly_symbol2scm ("consists") != $1
- && ly_symbol2scm ("remove") != $1)
+ && !scm_is_eq ($1, ly_symbol2scm ("consists"))
+ && !scm_is_eq ($1, ly_symbol2scm ("remove")))
{
$$ = SCM_EOL;
parser->parser_error (@1, _ ("only \\consists and \\remove take non-string argument."));
}
;
-simple_music_property_def:
- 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 {
- if (SCM_UNBNDP ($2))
- $$ = SCM_UNDEFINED;
- else
- $$ = scm_list_4 (scm_car ($2),
- ly_symbol2scm ("PropertySet"),
- scm_cadr ($2),
- $4);
- }
- | UNSET context_prop_spec {
- 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
;
music_property_def:
- simple_music_property_def {
- if (SCM_UNBNDP ($1))
- $$ = MAKE_SYNTAX ("void-music", @1);
+ OVERRIDE grob_prop_path '=' scalar {
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_override, @$,
+ scm_car ($2),
+ scm_cdr ($2),
+ $4);
+ }
+ | REVERT simple_revert_context revert_arg {
+ $$ = MAKE_SYNTAX (property_revert, @$, $2, $3);
+ }
+ | SET context_prop_spec '=' scalar {
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_set, @$,
+ scm_car ($2),
+ scm_cadr ($2),
+ $4);
+ }
+ | UNSET context_prop_spec {
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
else
- $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons2 (parser->self_scm (), @$.smobbed_copy (), $1));
+ $$ = MAKE_SYNTAX (property_unset, @$,
+ scm_car ($2),
+ scm_cadr ($2));
}
;
string:
- STRING {
- $$ = $1;
- }
+ STRING
+ | WORD
| full_markup
;
-simple_string: STRING {
- $$ = $1;
+text:
+ STRING
+ | WORD
+ | full_markup
+ | embedded_scm_bare
+ {
+ if (Text_interface::is_markup ($1)) {
+ $$ = $1;
+ } else {
+ parser->parser_error (@1, (_ ("markup expected")));
+ $$ = scm_string (SCM_EOL);
+ }
}
+ ;
+
+simple_string: STRING
+ | WORD
| embedded_scm_bare
{
if (scm_is_string ($1)) {
STRING {
$$ = scm_string_to_symbol ($1);
}
+ | WORD
+ {
+ if (!is_regular_identifier ($1, false))
+ parser->parser_error (@1, (_ ("symbol expected")));
+ $$ = 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);
+ $$ = try_string_variants (Guile_user::symbol_p, $1);
if (SCM_UNBNDP ($$))
{
parser->parser_error (@1, (_ ("symbol expected")));
$$ = scm_difference ($2, SCM_UNDEFINED);
}
| string
+ | symbol_list_part_bare '.' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
+ | symbol_list_part_bare ',' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
;
event_chord:
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
if (scm_is_pair ($2)) {
- Music::unsmob ($$)->set_property ("articulations",
+ unsmob<Music> ($$)->set_property ("articulations",
scm_reverse_x ($2, SCM_EOL));
}
} %prec ':'
| CHORD_REPETITION optional_notemode_duration post_events {
- Input i;
- i.set_location (@1, @3);
- $$ = MAKE_SYNTAX ("repetition-chord", i,
+ $$ = MAKE_SYNTAX (repetition_chord, @$,
$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,
+ $$ = MAKE_SYNTAX (multi_measure_rest, @$, $2,
scm_reverse_x ($3, SCM_EOL));
} %prec ':'
| tempo_event
note_chord_element:
chord_body optional_notemode_duration post_events
{
- Music *m = Music::unsmob ($1);
- SCM dur = Duration::unsmob ($2)->smobbed_copy ();
+ Music *m = unsmob<Music> ($1);
+ SCM dur = unsmob<Duration> ($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))
- Music::unsmob (scm_car (s))->set_property ("duration", dur);
+ unsmob<Music> (scm_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
- m-> set_property ("elements", es);
- m->set_spot (@$);
+ m->set_property ("elements", es);
+ m->set_spot (parser->lexer_->override_input (@$));
$$ = m->self_scm ();
} %prec ':'
;
chord_body:
ANGLE_OPEN chord_body_elements ANGLE_CLOSE
{
- $$ = MAKE_SYNTAX ("event-chord", @$, scm_reverse_x ($2, SCM_EOL));
+ $$ = 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));
+ $$ = MAKE_SYNTAX (event_chord, @$, scm_reverse_x ($2, SCM_EOL));
}
;
}
| music_function_chord_body
{
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
while (m && m->is_mus_type ("music-wrapper-music")) {
$$ = m->get_property ("element");
- m = Music::unsmob ($$);
+ m = unsmob<Music> ($$);
}
if (!(m && m->is_mus_type ("rhythmic-event"))) {
event_function_event:
EVENT_FUNCTION function_arglist {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
}
| post_events post_event {
$$ = $1;
- if (Music *m = Music::unsmob ($2))
+ if (Music *m = unsmob<Music> ($2))
{
if (m->is_mus_type ("post-event-wrapper"))
{
$$ = scm_cons (scm_car (p), $$);
}
} else {
- m->set_spot (@2);
+ m->set_spot (parser->lexer_->override_input (@2));
$$ = scm_cons ($2, $$);
}
}
}
| script_dir music_function_call {
$$ = $2;
- if (!Music::unsmob ($2)->is_mus_type ("post-event")) {
+ if (!unsmob<Music> ($2)->is_mus_type ("post-event")) {
parser->parser_error (@2, _ ("post-event expected"));
$$ = SCM_UNSPECIFIED;
} else if (!SCM_UNBNDP ($1))
{
- Music::unsmob ($$)->set_property ("direction", $1);
+ unsmob<Music> ($$)->set_property ("direction", $1);
}
}
| HYPHEN {
| script_dir direction_reqd_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = Music::unsmob ($2);
+ Music *m = unsmob<Music> ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| script_dir direction_less_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = Music::unsmob ($2);
+ Music *m = unsmob<Music> ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| '^' fingering
{
$$ = $2;
- Music::unsmob ($$)->set_property ("direction", scm_from_int (UP));
+ unsmob<Music> ($$)->set_property ("direction", scm_from_int (UP));
}
| '_' fingering
{
$$ = $2;
- Music::unsmob ($$)->set_property ("direction", scm_from_int (DOWN));
+ unsmob<Music> ($$)->set_property ("direction", scm_from_int (DOWN));
}
;
a->set_property ("articulation-type", s);
$$ = a->unprotect ();
} else {
- Music *original = Music::unsmob (s);
+ Music *original = unsmob<Music> (s);
if (original && original->is_mus_type ("post-event")) {
Music *a = original->clone ();
a->set_spot (parser->lexer_->override_input (@$));
NOTENAME_PITCH quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($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 = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($1);
p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
| PITCH_IDENTIFIER quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($1);
p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
make_simple_markup ($1));
$$ = t->unprotect ();
}
+ | WORD {
+ // Flag a warning? could be unintentional
+ Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
+ t->set_property ("text",
+ make_simple_markup ($1));
+ $$ = t->unprotect ();
+ }
| embedded_scm
{
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
if (m && m->is_mus_type ("post-event"))
$$ = $1;
else if (Text_interface::is_markup ($1)) {
script_abbreviation:
'^' {
- $$ = scm_from_locale_string ("Hat");
+ $$ = scm_from_ascii_string ("Hat");
}
| '+' {
- $$ = scm_from_locale_string ("Plus");
+ $$ = scm_from_ascii_string ("Plus");
}
| '-' {
- $$ = scm_from_locale_string ("Dash");
+ $$ = scm_from_ascii_string ("Dash");
}
| '!' {
- $$ = scm_from_locale_string ("Bang");
+ $$ = scm_from_ascii_string ("Bang");
}
| ANGLE_CLOSE {
- $$ = scm_from_locale_string ("Larger");
+ $$ = scm_from_ascii_string ("Larger");
}
| '.' {
- $$ = scm_from_locale_string ("Dot");
+ $$ = scm_from_ascii_string ("Dot");
}
| '_' {
- $$ = scm_from_locale_string ("Underscore");
+ $$ = scm_from_ascii_string ("Underscore");
}
;
| '-' { $$ = SCM_UNDEFINED; }
;
-duration_length:
- multiplied_duration {
- $$ = $1;
- }
- ;
-
maybe_notemode_duration:
{
$$ = SCM_UNDEFINED;
} %prec ':'
| multiplied_duration {
$$ = $1;
- parser->default_duration_ = *Duration::unsmob ($$);
+ parser->default_duration_ = *unsmob<Duration> ($$);
}
;
}
}
| DURATION_IDENTIFIER dots {
- Duration *d = Duration::unsmob ($1);
- Duration k (d->duration_log (),
- d->dot_count () + scm_to_int ($2));
- k = k.compressed (d->factor ());
- scm_remember_upto_here_1 ($1);
- $$ = k.smobbed_copy ();
+ $$ = make_duration ($1, scm_to_int ($2));
}
;
multiplied_duration:
- steno_duration {
- $$ = $1;
- }
- | multiplied_duration '*' UNSIGNED {
- $$ = 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)));
-
- $$ = Duration::unsmob ($$)->compressed (m).smobbed_copy ();
+ steno_duration multipliers {
+ $$ = make_duration ($1, 0, $2);
}
;
}
;
+multipliers:
+ /* empty */
+ {
+ $$ = SCM_UNDEFINED;
+ }
+ | multipliers '*' UNSIGNED
+ {
+ if (!SCM_UNBNDP ($1))
+ $$ = scm_product ($1, $3);
+ else
+ $$ = $3;
+ }
+ | multipliers '*' FRACTION
+ {
+ if (!SCM_UNBNDP ($1))
+ $$ = scm_product ($1, scm_divide (scm_car ($3),
+ scm_cdr ($3)));
+ else
+ $$ = scm_divide (scm_car ($3), scm_cdr ($3));
+ }
+ ;
+
tremolo_type:
':' {
$$ = scm_from_int (parser->default_tremolo_type_);
;
bass_number:
- UNSIGNED { $$ = $1; }
- | STRING { $$ = $1; }
- | full_markup { $$ = $1; }
+ UNSIGNED
+ | STRING
+ | WORD
+ | full_markup
| embedded_scm_bare
{
// as an integer, it needs to be non-negative, and otherwise
}
| bass_figure ']' {
$$ = $1;
- Music::unsmob ($1)->set_property ("bracket-stop", SCM_BOOL_T);
+ unsmob<Music> ($1)->set_property ("bracket-stop", SCM_BOOL_T);
}
| bass_figure figured_bass_alteration {
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($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 = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
m->set_property ($2, SCM_BOOL_T);
}
;
}
| '[' bass_figure {
$$ = $2;
- Music::unsmob ($$)->set_property ("bracket-start", SCM_BOOL_T);
+ unsmob<Music> ($$)->set_property ("bracket-start", SCM_BOOL_T);
}
;
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::unsmob ($1))
+ if (unsmob<Pitch> ($1))
$1 = make_chord_elements (@1,
$1,
parser->default_duration_.smobbed_copy (),
SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
- $$ = MAKE_SYNTAX ("event-chord", @1, elts);
- } else if (!Pitch::unsmob ($1))
- $$ = MAKE_SYNTAX ("event-chord", @1, $1);
+ $$ = MAKE_SYNTAX (event_chord, @1, elts);
+ } else if (!unsmob<Pitch> ($1))
+ $$ = MAKE_SYNTAX (event_chord, @1, $1);
// A mere pitch drops through.
} %prec ':'
;
parser->parser_error (@1, _ ("markup outside of text script or \\lyricmode"));
$$ = $1;
}
+ | WORD {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _f ("not a note name: %s", ly_scm2string ($1)));
+ $$ = $1;
+ }
| STRING {
if (!parser->lexer_->is_lyric_state ())
- parser->parser_error (@1, _ ("unrecognized string, not in text script or \\lyricmode"));
+ parser->parser_error (@1, _ ("string outside of text script or \\lyricmode"));
$$ = $1;
}
| LYRIC_ELEMENT
lyric_element_music:
lyric_element optional_notemode_duration post_events {
- $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
+ $$ = MAKE_SYNTAX (lyric_event, @$, $1, $2);
if (scm_is_pair ($3))
- Music::unsmob ($$)->set_property
+ unsmob<Music> ($$)->set_property
("articulations", scm_reverse_x ($3, SCM_EOL));
} %prec ':'
;
}
;
-full_markup:
+markup_mode:
MARKUP
- { parser->lexer_->push_markup_state (); }
- markup_top {
- $$ = $3;
+ {
+ parser->lexer_->push_markup_state ();
+ }
+ ;
+
+full_markup:
+ markup_mode markup_top {
+ $$ = $2;
+ parser->lexer_->pop_state ();
+ }
+ ;
+
+partial_markup:
+ markup_mode markup_partial_function ETC
+ {
+ $$ = MAKE_SYNTAX (partial_markup, @2, $2);
parser->lexer_->pop_state ();
}
;
markup_top:
markup_list {
- $$ = scm_list_2 (ly_lily_module_constant ("line-markup"), $1);
+ $$ = scm_list_2 (Lily::line_markup, $1);
}
| markup_head_1_list simple_markup
{
- $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
+ $$ = scm_car (MAKE_SYNTAX (composed_markup_list,
@2, $1, scm_list_1 ($2)));
}
| simple_markup {
;
markup_scm:
- embedded_scm_bare
+ embedded_scm
{
if (Text_interface::is_markup ($1))
MYBACKUP (MARKUP_IDENTIFIER, $1, @1);
$$ = $2;
}
| SCORELINES {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' score_body '}' {
- Score *sc = Score::unsmob ($4);
+ Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
if (sc->defs_.empty ()) {
Output_def *od = get_layout (parser);
sc->add_output_def (od);
od->unprotect ();
}
- $$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $4));
+ $$ = scm_list_1 (scm_list_2 (Lily::score_lines_markup_list, $4));
parser->lexer_->pop_state ();
}
;
markup_composed_list:
markup_head_1_list markup_uncomposed_list {
- $$ = MAKE_SYNTAX ("composed-markup-list",
+ $$ = MAKE_SYNTAX (composed_markup_list,
@2, $1, $2);
}
;
}
;
+markup_partial_function:
+ MARKUP_FUNCTION markup_arglist_partial
+ {
+ $$ = scm_list_1 (scm_cons ($1, scm_reverse_x ($2, SCM_EOL)));
+ }
+ | markup_head_1_list MARKUP_FUNCTION markup_arglist_partial
+ {
+ $$ = scm_cons (scm_cons ($2, scm_reverse_x ($3, SCM_EOL)),
+ $1);
+ }
+ ;
+
+markup_arglist_partial:
+ EXPECT_MARKUP markup_arglist_partial
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM markup_arglist_partial
+ {
+ $$= $2;
+ }
+ | EXPECT_MARKUP markup_command_list_arguments
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM markup_command_list_arguments
+ {
+ $$ = $2;
+ }
+ ;
+
markup_head_1_item:
MARKUP_FUNCTION EXPECT_MARKUP markup_command_list_arguments {
$$ = scm_cons ($1, scm_reverse_x ($3, SCM_EOL));
STRING {
$$ = make_simple_markup ($1);
}
+ | WORD {
+ $$ = make_simple_markup ($1);
+ }
| SCORE {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' score_body '}' {
- Score *sc = Score::unsmob ($4);
+ Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
if (sc->defs_.empty ()) {
Output_def *od = get_layout (parser);
sc->add_output_def (od);
od->unprotect ();
}
- $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $4);
+ $$ = scm_list_2 (Lily::score_markup, $4);
parser->lexer_->pop_state ();
}
| MARKUP_FUNCTION markup_command_basic_arguments {
markup:
markup_head_1_list simple_markup
{
- $$ = scm_car (MAKE_SYNTAX ("composed-markup-list",
+ $$ = scm_car (MAKE_SYNTAX (composed_markup_list,
@2, $1, scm_list_1 ($2)));
}
| simple_markup {
SCM
Lily_parser::do_yyparse ()
{
- SCM retval = SCM_UNDEFINED;
- yyparse (this, &retval);
- return retval;
+ return scm_c_with_fluid (Lily::f_parser,
+ self_scm (),
+ do_yyparse_trampoline,
+ static_cast <void *>(this));
}
-
+SCM
+Lily_parser::do_yyparse_trampoline (void *parser)
+{
+ SCM retval = SCM_UNDEFINED;
+ yyparse (static_cast <Lily_parser *>(parser), &retval);
+ return retval;
+}
int
Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
{
- if (Book::unsmob (sid)) {
- Book *book = Book::unsmob (sid)->clone ();
+ if (unsmob<Book> (sid)) {
+ Book *book = unsmob<Book> (sid)->clone ();
*destination = book->self_scm ();
book->unprotect ();
} else if (scm_is_number (sid)) {
*destination = sid;
return NUMBER_IDENTIFIER;
- } else if (Context_def::unsmob (sid))
+ } else if (unsmob<Context_def> (sid))
{
- *destination = Context_def::unsmob (sid)->clone ()->unprotect ();
+ *destination = unsmob<Context_def> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
- } else if (Context_mod::unsmob (sid)) {
- *destination = Context_mod::unsmob (sid)->smobbed_copy ();
- return CONTEXT_MOD_IDENTIFIER;
- } else if (Music *mus = Music::unsmob (sid)) {
+ } else if (unsmob<Context_mod> (sid)) {
+ *destination = unsmob<Context_mod> (sid)->smobbed_copy ();
+ return SCM_IDENTIFIER;
+ } else if (Music *mus = unsmob<Music> (sid)) {
mus = mus->clone ();
*destination = mus->self_scm ();
bool is_event = mus->is_mus_type ("post-event");
mus->unprotect ();
return is_event ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
- } else if (Pitch::unsmob (sid)) {
- *destination = Pitch::unsmob (sid)->smobbed_copy ();
+ } else if (unsmob<Pitch> (sid)) {
+ *destination = unsmob<Pitch> (sid)->smobbed_copy ();
return PITCH_IDENTIFIER;
- } else if (Duration::unsmob (sid)) {
- *destination = Duration::unsmob (sid)->smobbed_copy ();
+ } else if (unsmob<Duration> (sid)) {
+ *destination = unsmob<Duration> (sid)->smobbed_copy ();
return DURATION_IDENTIFIER;
- } else if (Output_def::unsmob (sid)) {
- *destination = Output_def::unsmob (sid)->clone ()->unprotect ();
+ } else if (unsmob<Output_def> (sid)) {
+ *destination = unsmob<Output_def> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
- } else if (Score::unsmob (sid)) {
- *destination = Score::unsmob (sid)->clone ()->unprotect ();
+ } else if (unsmob<Score> (sid)) {
+ *destination = unsmob<Score> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
+ } else if (scm_is_pair (sid)
+ && scm_is_pair (scm_car (sid))
+ && scm_is_true (Lily::key_p (scm_caar (sid)))) {
+ *destination = sid;
+ return LOOKUP_IDENTIFIER;
}
-
return -1;
}
SCM
get_next_unique_context_id ()
{
- return scm_from_locale_string ("$uniqueContextId");
+ return scm_from_ascii_string ("$uniqueContextId");
}
static int new_context_count;
char s[128];
snprintf (s, sizeof (s)-1, "uniqueContext%d", new_context_count++);
- return scm_from_locale_string (s);
+ return scm_from_ascii_string (s);
}
// check_scheme_arg checks one argument with a given predicate for use
return args;
}
scm_set_cdr_x (scm_last_pair (args), SCM_EOL);
- MAKE_SYNTAX ("argument-error", loc, scm_length (args), pred,
+ 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)
+SCM loc_on_copy (Lily_parser *parser, Input loc, SCM arg)
{
- if (Music *m = Music::unsmob (arg))
+ if (Music *m = unsmob<Music> (arg))
{
m = m->clone ();
- m->set_spot (loc);
+ m->set_spot (parser->lexer_->override_input (loc));
return m->unprotect ();
}
+ if (Book *b = unsmob<Book> (arg))
+ {
+ b = b->clone ();
+ b->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return b->unprotect ();
+ }
+ if (Context_def *cd = unsmob<Context_def> (arg))
+ {
+ cd = cd->clone ();
+ cd->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return cd->unprotect ();
+ }
+ if (Output_def *od = unsmob<Output_def> (arg))
+ {
+ od = od->clone ();
+ od->input_origin_ = parser->lexer_->override_input (loc);
+ return od->unprotect ();
+ }
+ if (Score *s = unsmob<Score> (arg))
+ {
+ s = s->clone ();
+ s->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return s->unprotect ();
+ }
+ if (Context_mod *cm = unsmob<Context_mod> (arg))
+ {
+ return cm->smobbed_copy ();
+ }
return arg;
}
+SCM
+make_reverse_key_list (SCM keys)
+{
+ if (scm_is_true (Lily::key_p (keys)))
+ return scm_list_1 (keys);
+ if (scm_is_string (keys))
+ return scm_list_1 (scm_string_to_symbol (keys));
+ if (!ly_is_list (keys))
+ return SCM_UNDEFINED;
+ SCM res = SCM_EOL;
+ for (; scm_is_pair (keys); keys = scm_cdr (keys))
+ {
+ SCM elt = scm_car (keys);
+ if (scm_is_true (Lily::key_p (elt)))
+ res = scm_cons (elt, res);
+ else if (scm_is_string (elt))
+ res = scm_cons (scm_string_to_symbol (elt), res);
+ else return SCM_UNDEFINED;
+ }
+ return res;
+}
+
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)) {
+ // a key may be interpreted as a list of keys if it helps
+ if (scm_is_true (Lily::key_p (str))) {
str = scm_list_1 (str);
if (scm_is_true (scm_call_1 (pred, str)))
return str;
return SCM_UNDEFINED;
}
+ if (!scm_is_string (str))
+ return SCM_UNDEFINED;
+
+ // Let's attempt the symbol list interpretation first.
+
+ str = scm_string_to_symbol (str);
+
+ SCM lst = scm_list_1 (str);
+
+ if (scm_is_true (scm_call_1 (pred, lst)))
+ return lst;
+
+ // Try the single symbol interpretation
+
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+
+ return SCM_UNDEFINED;
+}
+
+SCM
+try_word_variants (SCM pred, SCM str)
+{
+ // str is always a string when we come here
+
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+
// If this cannot be a string representation of a symbol list,
// we are through.
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_split (scm_car (p),
+ SCM_MAKE_CHAR (',')));
+ str = scm_append_x (str);
for (SCM p = str; scm_is_pair (p); p = scm_cdr (p))
scm_set_car_x (p, scm_string_to_symbol (scm_car (p)));
|| (c >= 'A' && c <= 'Z')
|| c > 0x7f)
middle = true;
- else if (middle && (c == '-' || c == '_' || (multiple && c == '.')))
+ else if (middle && (c == '-' || c == '_' || (multiple &&
+ (c == '.' || c == ','))))
middle = false;
else
return false;
SCM
make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
{
- if (Music::unsmob (simple))
+ if (unsmob<Music> (simple))
return simple;
- if (parser->lexer_->is_note_state ()) {
- if (scm_is_symbol (simple)) {
+
+ if (scm_is_symbol (simple))
+ {
+ SCM out = SCM_UNDEFINED;
+ switch (parser->lexer_->scan_word (out, simple))
+ {
+ case DRUM_PITCH:
+ {
Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
n->set_property ("duration", parser->default_duration_.smobbed_copy ());
- n->set_property ("drum-type", simple);
+ n->set_property ("drum-type", out);
return n->unprotect ();
}
- if (Pitch::unsmob (simple)) {
+ case NOTENAME_PITCH:
+ case TONICNAME_PITCH:
+ // Take the parsed pitch
+ simple = out;
+ break;
+ // Don't scan CHORD_MODIFIER etc.
+ }
+ }
+
+ if (parser->lexer_->is_note_state ()) {
+ if (unsmob<Pitch> (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 ();
}
+ SCM d = simple;
+ if (scm_is_integer (simple))
+ d = make_duration (simple);
+ if (unsmob<Duration> (d)) {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", d);
+ 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,
+ return MAKE_SYNTAX (lyric_event, loc, simple,
parser->default_duration_.smobbed_copy ());
} else if (parser->lexer_->is_chord_state ()) {
- if (Pitch::unsmob (simple))
+ if (unsmob<Pitch> (simple))
return MAKE_SYNTAX
- ("event-chord",
+ (event_chord,
loc,
make_chord_elements (loc, simple,
parser->default_duration_.smobbed_copy (),
}
SCM
-make_duration (SCM d, int dots)
+make_duration (SCM d, int dots, SCM factor)
{
- int t = scm_to_int (d);
- if (t > 0 && (t & (t-1)) == 0)
- return Duration (intlog2 (t), dots).smobbed_copy ();
- else
- return SCM_UNDEFINED;
+ Duration k;
+
+ if (Duration *dur = unsmob<Duration> (d)) {
+ if (!dots && SCM_UNBNDP (factor))
+ return d;
+ k = *dur;
+ if (dots)
+ k = Duration (k.duration_log (), k.dot_count () + dots)
+ .compressed (k.factor ());
+ } else {
+ int t = scm_to_int (d);
+ if (t > 0 && (t & (t-1)) == 0)
+ k = Duration (intlog2 (t), dots);
+ else
+ return SCM_UNDEFINED;
+ }
+
+ if (!SCM_UNBNDP (factor))
+ k = k.compressed (ly_scm2rational (factor));
+
+ return k.smobbed_copy ();
}
SCM
make_chord_step (SCM step_scm, Rational alter)
{
- int step = scm_to_int (step_scm);
+ Pitch m (0, scm_to_int (step_scm) - 1, alter);
- if (step == 7)
- alter += FLAT_ALTERATION;
+ // Notename/octave are normalized
+ if (m.get_notename () == 6)
+ m = m.transposed (Pitch (0, 0, FLAT_ALTERATION));
- while (step < 0)
- step += 7;
- Pitch m ((step -1) / 7, (step - 1) % 7, alter);
return m.smobbed_copy ();
}
SCM
make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list)
{
- SCM chord_ctor = ly_lily_module_constant ("construct-chord-elements");
- SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list);
+ SCM res = Lily::construct_chord_elements (pitch, dur, modification_list);
for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
{
- Music::unsmob (scm_car (s))->set_spot (loc);
+ unsmob<Music> (scm_car (s))->set_spot (loc);
}
return res;
}