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); \
#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)
- 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)
+
+static SCM
+syntax_call (void *arg)
+{
+ SCM sarg = reinterpret_cast <SCM> (arg);
+ return scm_apply_0 (scm_car (sarg), scm_cdr (sarg));
+}
+
+#define LOWLEVEL_MAKE_SYNTAX(location, args) \
+ scm_c_with_fluid \
+ (Lily::f_location, \
+ parser->lexer_->override_input (location).smobbed_copy (), \
+ syntax_call, \
+ reinterpret_cast <void*> (args))
+
/* Syntactic Sugar. */
#define MAKE_SYNTAX(name, location, ...) \
- LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->lexer_->override_input (location).smobbed_copy (), ##__VA_ARGS__, SCM_UNDEFINED))
+ LOWLEVEL_MAKE_SYNTAX (location, \
+ scm_list_n (Lily::name, \
+ ##__VA_ARGS__, SCM_UNDEFINED))
+
#define START_MAKE_SYNTAX(name, ...) \
- scm_list_n (ly_lily_module_constant (name) , ##__VA_ARGS__, SCM_UNDEFINED)
+ scm_list_n (Lily::name, \
+ ##__VA_ARGS__, SCM_UNDEFINED)
+
#define FINISH_MAKE_SYNTAX(start, location, ...) \
- LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons (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, \
+ scm_append_x \
+ (scm_list_2 (start, scm_list_n \
+ (__VA_ARGS__, SCM_UNDEFINED))))
SCM get_next_unique_context_id ();
SCM get_next_unique_lyrics_context_id ();
}
| 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
(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);
+ 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);
+ scm_call_1 (proc, $1);
} else if (Output_def * od = unsmob<Output_def> ($1)) {
SCM id = SCM_EOL;
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
$3 = scm_cons ($2, $3);
if (unsmob<Music> ($1))
$3 = scm_cons ($1, $3);
- $$ = MAKE_SYNTAX ("sequential-music", @$, $3);
+ $$ = MAKE_SYNTAX (sequential_music, @$, $3);
}
| error {
parser->error_level_ = 1;
}
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 = unsmob<Context_mod> ($2)) {
for (SCM m = cm->get_mods (); scm_is_pair (m); m = scm_cdr (m)) {
}
| 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");
}
| 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");
}
} else if (!unsmob<Score> ($$)) {
if (unsmob<Music> ($2)) {
- SCM scorify = ly_lily_module_constant ("scorify-music");
- $2 = scm_call_2 (scorify, $2, parser->self_scm ());
+ $2 = Lily::scorify_music ($2);
}
if (unsmob<Score> ($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;
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);
+ $$ = MAKE_SYNTAX (tempo, @$, $2, $3, $5);
}
| TEMPO scalar {
- $$ = MAKE_SYNTAX ("tempo", @$, $2);
+ $$ = MAKE_SYNTAX (tempo, @$, $2);
} %prec ':'
;
if (!unsmob<Music> ($$))
{
parser->parser_error (@1, _ ("music expected"));
- $$ = MAKE_SYNTAX ("void-music", @$);
+ $$ = MAKE_SYNTAX (void_music, @$);
}
}
;
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));
}
;
{
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 (unsmob<Context_mod> ($2))
$$ = $2;
;
else 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 (unsmob<Context_mod> ($2))
unsmob<Context_mod> ($$)->add_context_mods
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
- $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F);
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, mods, SCM_BOOL_F);
}
| NEWCONTEXT symbol optional_id optional_context_mod {
Context_mod *ctxmod = unsmob<Context_mod> ($4);
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
- $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_T);
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, mods, SCM_BOOL_T);
}
;
| 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, @$, $3, $2, $4);
}
;
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
;
symbol_list_part:
symbol_list_element
{
- SCM sym_l_p = ly_lily_module_constant ("symbol-list?");
- $$ = try_string_variants (sym_l_p, $1);
+ $$ = try_string_variants (Lily::symbol_list_p, $1);
if (SCM_UNBNDP ($$)) {
parser->parser_error (@1, _("not a symbol"));
$$ = SCM_EOL;
music_function_call:
MUSIC_FUNCTION function_arglist {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
mode_changing_head grouped_music_list {
if (scm_is_eq ($1, ly_symbol2scm ("chords")))
{
- $$ = MAKE_SYNTAX ("unrelativable-music", @$, $2);
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $2);
}
else
{
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
- $$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3);
+ $$ = MAKE_SYNTAX (context_specification, @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3);
if (scm_is_eq ($1, ly_symbol2scm ("ChordNames")))
{
- $$ = MAKE_SYNTAX ("unrelativable-music", @$, $$);
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $$);
}
parser->lexer_->pop_state ();
}
context_change:
CHANGE symbol '=' simple_string {
- $$ = MAKE_SYNTAX ("context-change", @$, $2, $4);
+ $$ = MAKE_SYNTAX (context_change, @$, $2, $4);
}
;
}
;
-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_operation, @$,
+ scm_car ($2),
+ ly_symbol2scm ("OverrideProperty"),
+ scm_cadr ($2),
+ $4,
+ scm_cddr ($2));
+ }
+ }
+ | REVERT simple_revert_context revert_arg {
+ $$ = MAKE_SYNTAX (property_operation, @$,
+ $2,
+ ly_symbol2scm ("RevertProperty"),
+ scm_car ($3),
+ scm_cdr ($3));
+ }
+ | SET context_prop_spec '=' scalar {
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_operation, @$,
+ scm_car ($2),
+ ly_symbol2scm ("PropertySet"),
+ 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_cons (@$.smobbed_copy (), $1));
+ $$ = MAKE_SYNTAX (property_operation, @$,
+ scm_car ($2),
+ ly_symbol2scm ("PropertyUnset"),
+ scm_cadr ($2));
}
;
{
// 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")));
| CHORD_REPETITION optional_notemode_duration post_events {
Input i;
i.set_location (@1, @3);
- $$ = MAKE_SYNTAX ("repetition-chord", i,
+ $$ = 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,
+ $$ = MAKE_SYNTAX (multi_measure_rest, i, $2,
scm_reverse_x ($3, SCM_EOL));
} %prec ':'
| tempo_event
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));
}
;
event_function_event:
EVENT_FUNCTION function_arglist {
- $$ = MAKE_SYNTAX ("music-function", @$,
- $1, $2);
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
- $$ = MAKE_SYNTAX ("event-chord", @1, elts);
+ $$ = MAKE_SYNTAX (event_chord, @1, elts);
} else if (!unsmob<Pitch> ($1))
- $$ = MAKE_SYNTAX ("event-chord", @1, $1);
+ $$ = MAKE_SYNTAX (event_chord, @1, $1);
// A mere pitch drops through.
} %prec ':'
;
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))
unsmob<Music> ($$)->set_property
("articulations", scm_reverse_x ($3, SCM_EOL));
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 {
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);
}
;
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 ()
{
- return scm_c_with_fluid (ly_lily_module_constant ("%parser"),
+ return scm_c_with_fluid (Lily::f_parser,
self_scm (),
do_yyparse_trampoline,
static_cast <void *>(this));
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;
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 (unsmob<Pitch> (simple))
return MAKE_SYNTAX
- ("event-chord",
+ (event_chord,
loc,
make_chord_elements (loc, simple,
parser->default_duration_.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))
{
unsmob<Music> (scm_car (s))->set_spot (loc);
projects / lilypond.git / blobdiff