X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=daf25c94ae1bb3ce0974d0ea48ba77b076fc7bf4;hb=e3ef776277b94f37a6246091f0d91e245500a4ef;hp=e31937f316598e7f22b2a941782975852121ee13;hpb=2cde1060ed33782cfcb5a42fa2f86c9ca79baa44;p=lilypond.git diff --git a/lily/parser.yy b/lily/parser.yy index e31937f316..daf25c94ae 100644 --- a/lily/parser.yy +++ b/lily/parser.yy @@ -113,7 +113,7 @@ or -%pure_parser +%pure-parser %locations @@ -157,7 +157,7 @@ using namespace std; #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); } @@ -194,7 +194,9 @@ 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. @@ -203,12 +205,12 @@ while (0) #define LOWLEVEL_MAKE_SYNTAX(proc, args) \ scm_apply_0 (proc, args) /* Syntactic Sugar. */ -#define MAKE_SYNTAX(name, location, ...) \ - LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_input (location) , ##__VA_ARGS__, SCM_UNDEFINED)) +#define MAKE_SYNTAX(name, location, ...) \ + LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_input (parser->lexer_->override_input (location)), ##__VA_ARGS__, SCM_UNDEFINED)) #define START_MAKE_SYNTAX(name, ...) \ scm_list_n (ly_lily_module_constant (name) , ##__VA_ARGS__, SCM_UNDEFINED) #define FINISH_MAKE_SYNTAX(start, location, ...) \ - LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons2 (parser->self_scm (), make_input (location), scm_append_x (scm_list_2 (scm_cdr (start), scm_list_n (__VA_ARGS__, SCM_UNDEFINED))))) + LOWLEVEL_MAKE_SYNTAX (scm_car (start), scm_cons2 (parser->self_scm (), make_input (parser->lexer_->override_input (location)), scm_append_x (scm_list_2 (scm_cdr (start), scm_list_n (__VA_ARGS__, SCM_UNDEFINED))))) SCM get_next_unique_context_id (); SCM get_next_unique_lyrics_context_id (); @@ -224,13 +226,15 @@ 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); +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); %} @@ -305,16 +309,8 @@ int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser); %token DOUBLE_ANGLE_OPEN "<<" %token DOUBLE_ANGLE_CLOSE ">>" %token E_BACKSLASH "\\" -%token E_ANGLE_CLOSE "\\>" -%token E_CHAR "\\C[haracter]" -%token E_CLOSE "\\)" %token E_EXCLAMATION "\\!" -%token E_BRACKET_OPEN "\\[" -%token E_OPEN "\\(" -%token E_BRACKET_CLOSE "\\]" -%token E_ANGLE_OPEN "\\<" %token E_PLUS "\\+" -%token E_TILDE "\\~" %token EXTENDER "__" /* @@ -326,7 +322,6 @@ If we give names, Bison complains. %token HYPHEN "--" %token CHORDMODIFIERS -%token LYRIC_MARKUP %token MULTI_MEASURE_REST @@ -360,9 +355,7 @@ If we give names, Bison complains. %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 @@ -374,11 +367,12 @@ If we give names, Bison complains. %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 SYMBOL_LIST %token TONICNAME_PITCH %left '-' '+' @@ -445,6 +439,24 @@ toplevel_expression: 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); + } + | 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 (!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); @@ -468,10 +480,17 @@ embedded_scm_bare: | SCM_IDENTIFIER ; +embedded_scm_active: + SCM_IDENTIFIER + | scm_function_call + ; + embedded_scm_bare_arg: - embedded_scm_bare - | STRING - | full_markup + SCM_ARG + | SCM_TOKEN + { + $$ = parser->lexer_->eval_scm_token ($1); + } | full_markup_list | context_modification | score_block @@ -504,6 +523,10 @@ scm_function_call: embedded_lilypond: /* empty */ { + // FIXME: @$ does not contain a useful source location + // for empty rules, and the only token in the whole + // production, EMBEDDED_LILY, is synthetic and also + // contains no source location. $$ = MAKE_SYNTAX ("void-music", @$); } | identifier_init @@ -530,6 +553,9 @@ lilypond_header_body: /* empty */ { $$ = SCM_UNSPECIFIED; } | lilypond_header_body assignment { + } + | lilypond_header_body embedded_scm { + } ; @@ -544,7 +570,6 @@ lilypond_header: */ assignment_id: STRING { $$ = $1; } - | LYRICS_STRING { $$ = $1; } ; assignment: @@ -557,7 +582,6 @@ assignment: parser->lexer_->set_identifier (path, $4); $$ = SCM_UNSPECIFIED; } - | embedded_scm { $$ = SCM_UNSPECIFIED; } ; @@ -568,7 +592,28 @@ identifier_init: | output_def | context_def_spec_block | music_assign - | post_event_nofinger + | post_event_nofinger post_events + { + $$ = scm_reverse_x ($2, SCM_EOL); + if (Music *m = unsmob_music ($1)) + { + if (m->is_mus_type ("post-event-wrapper")) + $$ = scm_append + (scm_list_2 (m->get_property ("elements"), + $$)); + else + $$ = scm_cons ($1, $$); + } + if (scm_is_pair ($$) + && scm_is_null (scm_cdr ($$))) + $$ = scm_car ($$); + else + { + Music * m = MY_MAKE_MUSIC ("PostEvents", @$); + m->set_property ("elements", $$); + $$ = m->unprotect (); + } + } | number_expression | FRACTION | string @@ -581,12 +626,22 @@ context_def_spec_block: CONTEXT '{' context_def_spec_body '}' { $$ = $3; + unsmob_context_def ($$)->origin ()->set_spot (@$); } ; context_mod_arg: embedded_scm - | composite_music + | + { + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); + } + composite_music + { + parser->lexer_->pop_state (); + $$ = $2; + } ; context_mod_embedded: @@ -600,6 +655,7 @@ context_mod_embedded: $$ = $1; else { parser->parser_error (@1, _ ("not a context mod")); + $$ = Context_mod ().smobbed_copy (); } } ; @@ -608,14 +664,13 @@ context_mod_embedded: context_def_spec_body: /**/ { $$ = Context_def::make_scm (); - unsmob_context_def ($$)->origin ()->set_spot (@$); } | CONTEXT_DEF_IDENTIFIER { $$ = $1; - unsmob_context_def ($$)->origin ()->set_spot (@$); } | context_def_spec_body context_mod { - unsmob_context_def ($$)->add_context_mod ($2); + if (!SCM_UNBNDP ($2)) + unsmob_context_def ($$)->add_context_mod ($2); } | context_def_spec_body context_modification { Context_def *td = unsmob_context_def ($$); @@ -638,6 +693,7 @@ context_def_spec_body: book_block: BOOK '{' book_body '}' { $$ = $3; + unsmob_book ($$)->origin ()->set_spot (@$); pop_paper (parser); parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F); } @@ -650,7 +706,6 @@ book_body: { Book *book = new Book; init_papers (parser); - book->origin ()->set_spot (@$); book->paper_ = dynamic_cast (unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ()); book->paper_->unprotect (); push_paper (parser, book->paper_); @@ -659,7 +714,6 @@ book_body: 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 { @@ -686,11 +740,28 @@ book_body: 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); + } + | 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 (!scm_is_eq ($2, SCM_UNSPECIFIED)) + parser->parser_error (@2, _("bad expression type")); + } | book_body { parser->lexer_->add_scope (unsmob_book ($1)->header_); } lilypond_header - | book_body embedded_scm { } | book_body error { Book *book = unsmob_book ($1); book->paper_ = 0; @@ -702,6 +773,7 @@ book_body: bookpart_block: BOOKPART '{' bookpart_body '}' { $$ = $3; + unsmob_book ($$)->origin ()->set_spot (@$); parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F); } ; @@ -709,12 +781,10 @@ bookpart_block: 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 { @@ -736,6 +806,24 @@ bookpart_body: 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); + } + | 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 (!scm_is_eq ($2, SCM_UNSPECIFIED)) + parser->parser_error (@2, _("bad expression type")); + } | bookpart_body { Book *book = unsmob_book ($1); @@ -743,7 +831,6 @@ bookpart_body: 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->paper_ = 0; @@ -764,8 +851,16 @@ score_body: unsmob_score ($$)->origin ()->set_spot (@$); } - | SCORE_IDENTIFIER { + | embedded_scm_active { + Score *score; + if (unsmob_score ($1)) + score = new Score (*unsmob_score ($1)); + else { + score = new Score; + parser->parser_error (@1, _("score expected")); + } unsmob_score ($$)->origin ()->set_spot (@$); + $$ = score->unprotect (); } | score_body { @@ -861,6 +956,7 @@ music_or_context_def: } '{' context_def_spec_body '}' { $$ = $4; + unsmob_context_def ($$)->origin ()->set_spot (@$); } ; @@ -878,6 +974,9 @@ output_def_body: } | output_def_body assignment { + } + | output_def_body embedded_scm { + } | output_def_body { @@ -945,15 +1044,40 @@ music: music_arg music_embedded: music - | embedded_scm { - if (unsmob_music ($1) - || scm_is_eq ($1, SCM_UNSPECIFIED)) + if (unsmob_music ($1)->is_mus_type ("post-event")) { + parser->parser_error (@1, _ ("unexpected post-event")); + $$ = SCM_UNSPECIFIED; + } + } + | music_embedded_backup + { + $$ = $1; + } + | music_embedded_backup BACKUP lyric_element_music + { + $$ = $3; + } + ; + +music_embedded_backup: + embedded_scm + { + if (scm_is_eq ($1, SCM_UNSPECIFIED)) $$ = $1; - else - { + else if (Music *m = unsmob_music ($1)) { + if (m->is_mus_type ("post-event")) { + parser->parser_error + (@1, _ ("unexpected post-event")); + $$ = SCM_UNSPECIFIED; + } else + $$ = $1; + } else if (parser->lexer_->is_lyric_state () + && Text_interface::is_markup ($1)) + MYBACKUP (LYRIC_ELEMENT, $1, @1); + else { @$.warning (_ ("Ignoring non-music expression")); - $$ = SCM_UNSPECIFIED; + $$ = $1; } } ; @@ -961,13 +1085,9 @@ music_embedded: music_arg: simple_music { - 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 (); - } + $$ = make_music_from_simple (parser, @1, $1); + if (!unsmob_music ($$)) + parser->parser_error (@1, _ ("music expected")); } | composite_music %prec COMPOSITE ; @@ -975,7 +1095,6 @@ music_arg: music_assign: simple_music | composite_music %prec COMPOSITE - | lyric_element_music ; repeated_music: @@ -1027,8 +1146,12 @@ context_modification: { $$ = $1; } - | WITH embedded_scm_closed + | WITH context_modification_arg { + if (unsmob_music ($2)) { + SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler"); + $2 = scm_call_2 (proc, parser->self_scm (), $2); + } if (unsmob_context_mod ($2)) $$ = $2; else { @@ -1038,6 +1161,11 @@ context_modification: } ; +context_modification_arg: + embedded_scm_closed + | MUSIC_IDENTIFIER + ; + optional_context_mod: /**/ { $$ = SCM_EOL; @@ -1053,7 +1181,8 @@ context_mod_list: $$ = Context_mod ().smobbed_copy (); } | context_mod_list context_mod { - unsmob_context_mod ($1)->add_context_mod ($2); + if (!SCM_UNBNDP ($2)) + unsmob_context_mod ($1)->add_context_mod ($2); } | context_mod_list CONTEXT_MOD_IDENTIFIER { Context_mod *md = unsmob_context_mod ($2); @@ -1096,6 +1225,34 @@ grouped_music_list: MUSIC_FUNCTION EXPECT_PITCH EXPECT_SCM EXPECT_SCM EXPECT_NO_MORE_ARGS and this rule returns the reversed list of arguments. */ +/* Function argument lists come in a number of flavors. Whenever + * LilyPond has to pick between different flavors, the decision is + * either made because of tokens it has already seen, or it is + * postponed until tokens suitable for making the decision come up. + * For postponing decisions, it may be necessary that the competing + * rules are written in a way making them compatible until a decision + * can be made. Sometimes this is done by putting common traits into + * a separate "common" rule set. + * + * function_arglist: a full argument list. Optional arguments at the + * end of the list can only be skipped by writing \default in their + * place. + * + * function_arglist_backup: an argument list ending in an optional + * argument that may be skipped depending on its predicate. + * + * function_arglist_skip: an argument list _not_ ending in an optional + * argument that is actually taken. + * + * function_arglist_nonbackup: an argument list ending in an optional + * argument that may not be skipped because it is in end position and + * has not been shortcircuited with \default. + * + * function_arglist* / function_arglist_closed*: The closed variants + * don't end in simple music expressions that might still accept + * things like a duration or a postevent. + */ + function_arglist_skip: function_arglist_common | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip @@ -1120,7 +1277,7 @@ function_arglist_nonbackup_common: | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed duration_length { $$ = scm_cons ($4, $3); } - | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed FRACTION + | EXPECT_OPTIONAL EXPECT_SCM function_arglist FRACTION { $$ = check_scheme_arg (parser, @4, $4, $3, $2); } @@ -1136,11 +1293,8 @@ function_arglist_nonbackup_common: 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); } } @@ -1168,8 +1322,62 @@ function_arglist_closed_nonbackup: { $$ = check_scheme_arg (parser, @4, $4, $3, $2); } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist SCM_IDENTIFIER + { + $$ = check_scheme_arg (parser, @4, + try_string_variants ($2, $4), + $3, $2, $4); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist STRING + { + $$ = check_scheme_arg (parser, @4, + try_string_variants ($2, $4), + $3, $2, $4); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist full_markup + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + ; + +symbol_list_arg: + SYMBOL_LIST + | SYMBOL_LIST '.' symbol_list_rev + { + $$ = 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_append_x (scm_list_2 ($3, $1)); + } + ; + +// symbol_list_part delivers elements in reverse copy. + +symbol_list_part: + symbol_list_element + { + 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 ($$); + } + ; + + +symbol_list_element: + STRING + | embedded_scm_bare ; + function_arglist_nonbackup: function_arglist_nonbackup_common | EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg @@ -1180,6 +1388,68 @@ function_arglist_nonbackup: { $$ = check_scheme_arg (parser, @4, $4, $3, $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_nonbackup_reparse: + EXPECT_OPTIONAL EXPECT_SCM function_arglist 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 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 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); + } ; function_arglist_keep: @@ -1200,7 +1470,7 @@ function_arglist_backup: $$ = scm_cons ($4, $3); } else { $$ = scm_cons (loc_on_music (@3, $1), $3); - MYBACKUP (SCM_IDENTIFIER, $4, @4); + MYBACKUP (SCM_ARG, $4, @4); } } | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep post_event_nofinger @@ -1213,21 +1483,13 @@ function_arglist_backup: MYBACKUP (EVENT_IDENTIFIER, $4, @4); } } - | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep lyric_element + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep full_markup { - // 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))) $$ = scm_cons ($4, $3); else { $$ = scm_cons (loc_on_music (@3, $1), $3); - MYBACKUP (LYRICS_STRING, $4, @4); + MYBACKUP (LYRIC_ELEMENT, $4, @4); } } | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep UNSIGNED @@ -1262,7 +1524,7 @@ function_arglist_backup: MYBACKUP (NUMBER_IDENTIFIER, $4, @4); } } - | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep FRACTION + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep FRACTION { if (scm_is_true (scm_call_1 ($2, $4))) { @@ -1299,6 +1561,7 @@ function_arglist_backup: MYREPARSE (@5, $2, REAL, n); $$ = $3; } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); MYBACKUP (REAL, n, @5); } } @@ -1308,6 +1571,7 @@ function_arglist_backup: 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); } } @@ -1319,20 +1583,49 @@ function_arglist_backup: { $$ = scm_cons ($4, $3); } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep SCM_IDENTIFIER + { + 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_keep STRING + { + 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); + } + } | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup BACKUP { $$ = scm_cons ($1, $3); MYBACKUP(0, SCM_UNDEFINED, @3); } - | function_arglist_backup REPARSE embedded_scm_arg_closed + | function_arglist_backup REPARSE bare_number { $$ = check_scheme_arg (parser, @3, $3, $1, $2); } - | function_arglist_backup REPARSE bare_number + | function_arglist_backup REPARSE symbol_list_arg { - $$ = check_scheme_arg (parser, @3, - $3, $1, $2); + $$ = check_scheme_arg (parser, @3, $3, $1, $2); } ; @@ -1353,7 +1646,7 @@ function_arglist_common: $$ = check_scheme_arg (parser, @3, $3, $2, $1); } - | EXPECT_SCM function_arglist_closed_optional FRACTION + | EXPECT_SCM function_arglist_optional FRACTION { $$ = check_scheme_arg (parser, @3, $3, $2, $1); @@ -1363,65 +1656,97 @@ function_arglist_common: $$ = check_scheme_arg (parser, @3, $3, $2, $1); } - | function_arglist_common_minus - | function_arglist_common_lyric + | EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER + { + SCM n = scm_difference ($4, SCM_UNDEFINED); + $$ = check_scheme_arg (parser, @4, n, $2, $1); + } + | function_arglist_common_reparse REPARSE SCM_ARG + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + | function_arglist_common_reparse REPARSE lyric_element_music + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + | function_arglist_common_reparse REPARSE bare_number + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + | function_arglist_common_reparse REPARSE symbol_list_arg + { + $$ = check_scheme_arg (parser, @3, $3, $1, $2); + } ; -function_arglist_common_lyric: - EXPECT_SCM function_arglist_optional lyric_element +function_arglist_common_reparse: + EXPECT_SCM function_arglist_optional SCM_IDENTIFIER { - // 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; + $$ = $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 { + else // This is going to flag a syntax error, we // know the predicate to be false. - check_scheme_arg (parser, @3, - $3, $2, $1); - } + MYREPARSE (@3, $1, SCM_ARG, $3); } - | function_arglist_common_lyric REPARSE lyric_element_arg + | EXPECT_SCM function_arglist_optional STRING { - // This should never be false - $$ = check_scheme_arg (parser, @3, - $3, $1, $2); + $$ = $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); } - ; - -function_arglist_common_minus: - EXPECT_SCM function_arglist_closed_optional '-' UNSIGNED + | EXPECT_SCM function_arglist_optional full_markup { + $$ = $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 '-' UNSIGNED + { + $$ = $2; SCM n = scm_difference ($4, SCM_UNDEFINED); - if (scm_is_true (scm_call_1 ($1, n))) { - $$ = $2; + if (scm_is_true (scm_call_1 ($1, n))) MYREPARSE (@4, $1, REAL, n); - } else { + 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); + SCM m = t->unprotect (); + if (scm_is_true (scm_call_1 ($1, m))) + MYREPARSE (@4, $1, SCM_ARG, m); else - $$ = check_scheme_arg (parser, @3, n, $2, $1); + MYREPARSE (@4, $1, SCM_ARG, $4); } } @@ -1431,15 +1756,6 @@ function_arglist_common_minus: SCM n = scm_difference ($4, SCM_UNDEFINED); MYREPARSE (@4, $1, REAL, n); } - | EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER - { - SCM n = scm_difference ($4, SCM_UNDEFINED); - $$ = check_scheme_arg (parser, @4, n, $2, $1); - } - | function_arglist_common_minus REPARSE bare_number - { - $$ = check_scheme_arg (parser, @3, $3, $1, $2); - } ; function_arglist_closed: @@ -1459,28 +1775,6 @@ function_arglist_closed_common: $$ = check_scheme_arg (parser, @3, $3, $2, $1); } - | EXPECT_SCM function_arglist_closed_optional '-' UNSIGNED - { - 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); - else - $$ = check_scheme_arg (parser, @3, n, $2, $1); - } - - } - | EXPECT_SCM function_arglist_closed_optional '-' REAL - { - $$ = check_scheme_arg (parser, @3, - scm_difference ($4, SCM_UNDEFINED), - $2, $1); - } | EXPECT_SCM function_arglist_closed_optional '-' NUMBER_IDENTIFIER { $$ = check_scheme_arg (parser, @3, @@ -1492,15 +1786,24 @@ function_arglist_closed_common: $$ = check_scheme_arg (parser, @3, $3, $2, $1); } - | EXPECT_SCM function_arglist_closed_optional FRACTION + | EXPECT_SCM function_arglist_optional FRACTION { $$ = check_scheme_arg (parser, @3, $3, $2, $1); } - | EXPECT_SCM function_arglist_optional lyric_element + | function_arglist_common_reparse REPARSE SCM_ARG { $$ = check_scheme_arg (parser, @3, - $3, $2, $1); + $3, $1, $2); + } + | function_arglist_common_reparse REPARSE bare_number + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + | function_arglist_common_reparse REPARSE symbol_list_arg + { + $$ = check_scheme_arg (parser, @3, $3, $1, $2); } ; @@ -1595,14 +1898,14 @@ complex_music: ; complex_music_prefix: - CONTEXT simple_string optional_id optional_context_mod { + CONTEXT symbol optional_id optional_context_mod { Context_mod *ctxmod = unsmob_context_mod ($4); SCM mods = SCM_EOL; if (ctxmod) mods = ctxmod->get_mods (); $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F); } - | NEWCONTEXT simple_string optional_id optional_context_mod { + | NEWCONTEXT symbol optional_id optional_context_mod { Context_mod *ctxmod = unsmob_context_mod ($4); SCM mods = SCM_EOL; if (ctxmod) @@ -1732,41 +2035,92 @@ context_change: ; -property_path_revved: - embedded_scm_closed { - $$ = scm_cons ($1, SCM_EOL); - } - | property_path_revved embedded_scm_closed { - $$ = scm_cons ($2, $1); - } - ; - property_path: - property_path_revved { + symbol_list_rev { $$ = scm_reverse_x ($1, SCM_EOL); } + | symbol_list_rev property_path { + $$ = scm_reverse_x ($1, $2); + } ; property_operation: - STRING '=' scalar { - $$ = scm_list_3 (ly_symbol2scm ("assign"), - scm_string_to_symbol ($1), $3); + symbol '=' scalar { + $$ = scm_list_3 (ly_symbol2scm ("assign"), $1, $3); } - | UNSET simple_string { - $$ = scm_list_2 (ly_symbol2scm ("unset"), - scm_string_to_symbol ($2)); + | UNSET symbol { + $$ = scm_list_2 (ly_symbol2scm ("unset"), $2); } - | OVERRIDE simple_string property_path '=' scalar { - $$ = scm_append (scm_list_2 (scm_list_3 (ly_symbol2scm ("push"), - scm_string_to_symbol ($2), $5), - $3)); + | 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; } - | REVERT simple_string embedded_scm { - $$ = scm_list_3 (ly_symbol2scm ("pop"), - scm_string_to_symbol ($2), $3); + ; + +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); } ; +// 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_arg_backup BACKUP SCM_ARG symbol_list_part + { + $$ = scm_append_x (scm_list_2 ($4, $3)); + } + ; + context_def_mod: CONSISTS { $$ = ly_symbol2scm ("consists"); } | REMOVE { $$ = ly_symbol2scm ("remove"); } @@ -1802,52 +2156,141 @@ context_mod: } ; -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 (SCM_IDENTIFIER, $1); + } else { + $$ = scm_car ($1); + parser->lexer_->push_extra_token (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 (), make_input (@$), $1)); } ; @@ -1856,26 +2299,12 @@ string: $$ = $1; } | full_markup - | string '+' string { - if (!scm_is_string ($1)) { - parser->parser_error (@1, (_ ("simple string expected"))); - $1 = scm_string (SCM_EOL); - } - if (!scm_is_string ($3)) { - parser->parser_error (@3, (_ ("simple string expected"))); - $3 = scm_string (SCM_EOL); - } - $$ = scm_string_append (scm_list_2 ($1, $3)); - } ; simple_string: STRING { $$ = $1; } - | LYRICS_STRING { - $$ = $1; - } - | MARKUP_IDENTIFIER + | embedded_scm_bare { if (scm_is_string ($1)) { $$ = $1; @@ -1884,29 +2313,63 @@ simple_string: STRING { $$ = scm_string (SCM_EOL); } } - | LYRIC_MARKUP_IDENTIFIER + ; + +symbol: + STRING { + $$ = scm_string_to_symbol ($1); + } + | embedded_scm_bare { - if (scm_is_string ($1)) { - $$ = $1; - } else { - parser->parser_error (@1, (_ ("simple string expected"))); - $$ = scm_string (SCM_EOL); + // 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 + | SCM_IDENTIFIER | bare_number + // The following is a rather defensive variant of admitting + // negative numbers: the grammar would permit number_factor or + // even number_expression. However, function arguments allow + // only this simple kind of negative number, so to have things + // like \tweak and \override behave reasonably similar, it + // makes sense to rule out things like -- which are rather an + // accent in function argument contexts. + | '-' bare_number + { + $$ = scm_difference ($2, SCM_UNDEFINED); + } | FRACTION - | lyric_element + | STRING + | full_markup ; scalar_closed: embedded_scm_arg_closed + | SCM_IDENTIFIER + // for scalar_closed to be an actually closed (no lookahead) + // expression, we'd need to use bare_number_closed here. It + // turns out that the only use of scalar_closed in TEMPO is + // not of the kind requiring the full closedness criterion. | bare_number + | '-' bare_number + { + $$ = scm_difference ($2, SCM_UNDEFINED); + } | FRACTION - | lyric_element + | STRING + | full_markup ; @@ -1914,15 +2377,12 @@ 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", - scm_reverse_x ($2, SCM_EOL)); + $$ = make_music_from_simple (parser, @1, $1); + if (unsmob_music ($$)) + unsmob_music ($$)->set_property ("articulations", + scm_reverse_x ($2, SCM_EOL)); + else + parser->parser_error (@1, _("music expected")); } } | simple_chord_elements post_events { @@ -2065,40 +2525,10 @@ 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 { + tempo_event { $$ = $1; } ; @@ -2109,8 +2539,22 @@ post_events: $$ = SCM_EOL; } | post_events post_event { - unsmob_music ($2)->set_spot (@2); - $$ = scm_cons ($2, $$); + $$ = $1; + if (Music *m = unsmob_music ($2)) + { + if (m->is_mus_type ("post-event-wrapper")) + { + for (SCM p = m->get_property ("elements"); + scm_is_pair (p); + p = scm_cdr (p)) + { + $$ = scm_cons (scm_car (p), $$); + } + } else { + m->set_spot (@2); + $$ = scm_cons ($2, $$); + } + } } ; @@ -2120,7 +2564,10 @@ post_event_nofinger: } | script_dir music_function_call_closed { $$ = $2; - if (!SCM_UNBNDP ($1)) + if (!unsmob_music ($2)->is_mus_type ("post-event")) { + parser->parser_error (@2, _ ("post-event expected")); + $$ = SCM_UNSPECIFIED; + } else if (!SCM_UNBNDP ($1)) { unsmob_music ($$)->set_property ("direction", $1); } @@ -2178,55 +2625,8 @@ string_number_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; } @@ -2332,11 +2732,17 @@ gen_text_def: make_simple_markup ($1)); $$ = t->unprotect (); } - | LYRICS_STRING { - Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$); - t->set_property ("text", - make_simple_markup ($1)); - $$ = t->unprotect (); + | embedded_scm_closed + { + Music *m = unsmob_music ($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")); } ; @@ -2358,8 +2764,8 @@ script_abbreviation: | '-' { $$ = scm_from_locale_string ("Dash"); } - | '|' { - $$ = scm_from_locale_string ("Bar"); + | '!' { + $$ = scm_from_locale_string ("Bang"); } | ANGLE_CLOSE { $$ = scm_from_locale_string ("Larger"); @@ -2463,6 +2869,18 @@ bass_number: 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: @@ -2504,38 +2922,23 @@ bass_figure: } | bass_figure figured_bass_modification { Music *m = unsmob_music ($1); - if ($2 == ly_symbol2scm ("plus")) - { - m->set_property ("augmented", SCM_BOOL_T); - } - else if ($2 == ly_symbol2scm ("slash")) - { - m->set_property ("diminished", SCM_BOOL_T); - } - else if ($2 == ly_symbol2scm ("exclamation")) - { - m->set_property ("no-continuation", SCM_BOOL_T); - } - else if ($2 == ly_symbol2scm ("backslash")) - { - m->set_property ("augmented-slash", SCM_BOOL_T); - } + m->set_property ($2, SCM_BOOL_T); } ; figured_bass_modification: E_PLUS { - $$ = ly_symbol2scm ("plus"); + $$ = ly_symbol2scm ("augmented"); } | E_EXCLAMATION { - $$ = ly_symbol2scm ("exclamation"); + $$ = ly_symbol2scm ("no-continuation"); } | '/' { - $$ = ly_symbol2scm ("slash"); + $$ = ly_symbol2scm ("diminished"); } | E_BACKSLASH { - $$ = ly_symbol2scm ("backslash"); + $$ = ly_symbol2scm ("augmented-slash"); } ; @@ -2645,37 +3048,19 @@ simple_chord_elements: ; 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); @@ -2754,7 +3139,7 @@ tempo_range: UNSIGNED { $$ = $1; } - | UNSIGNED '~' UNSIGNED { + | UNSIGNED '-' UNSIGNED { $$ = scm_cons ($1, $3); } ; @@ -2838,27 +3223,8 @@ questions: } ; -/* -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; @@ -2867,10 +3233,7 @@ full_markup_list: ; full_markup: - MARKUP_IDENTIFIER { - $$ = $1; - } - | MARKUP + MARKUP { parser->lexer_->push_markup_state (); } markup_top { $$ = $3; @@ -2879,11 +3242,13 @@ full_markup: ; markup_top: - markup_list { + simple_markup_list { $$ = scm_list_2 (ly_lily_module_constant ("line-markup"), $1); } - | markup_head_1_list simple_markup { - $$ = scm_car (scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, scm_list_1 ($2))); + | markup_head_1_list simple_markup + { + $$ = scm_car (MAKE_SYNTAX ("composed-markup-list", + @2, $1, scm_list_1 ($2))); } | simple_markup { $$ = $1; @@ -2905,14 +3270,15 @@ markup_scm: ; -markup_list: - MARKUPLIST_IDENTIFIER { - $$ = $1; - } - | markup_composed_list { +simple_markup_list: + markup_composed_list { $$ = $1; } - | markup_braced_list { + | markup_uncomposed_list + ; + +markup_uncomposed_list: + markup_braced_list { $$ = $1; } | markup_command_list { @@ -2924,10 +3290,28 @@ markup_list: } ; -markup_composed_list: - markup_head_1_list markup_braced_list { - $$ = scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, $2); +markup_list: + simple_markup_list + | markup_score + { + $$ = scm_list_1 (scm_list_2 (ly_lily_module_constant ("score-lines-markup-list"), $1)); + } + ; + +markup_score: + SCORE { + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); + } '{' score_body '}' { + $$ = $4; + parser->lexer_->pop_state (); + } + ; +markup_composed_list: + markup_head_1_list markup_uncomposed_list { + $$ = MAKE_SYNTAX ("composed-markup-list", + @2, $1, $2); } ; @@ -2942,7 +3326,7 @@ markup_braced_list_body: | markup_braced_list_body markup { $$ = scm_cons ($2, $1); } - | markup_braced_list_body markup_list { + | markup_braced_list_body simple_markup_list { $$ = scm_reverse_x ($2, $1); } ; @@ -2991,19 +3375,6 @@ simple_markup: STRING { $$ = make_simple_markup ($1); } - | MARKUP_IDENTIFIER { - $$ = $1; - } - | LYRIC_MARKUP_IDENTIFIER { - $$ = $1; - } - | SCORE { - SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); - parser->lexer_->push_note_state (nn); - } '{' score_body '}' { - $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $4); - parser->lexer_->pop_state (); - } | MARKUP_FUNCTION markup_command_basic_arguments { $$ = scm_cons ($1, scm_reverse_x ($2, SCM_EOL)); } @@ -3011,12 +3382,17 @@ simple_markup: { $$ = $2; } + | markup_score + { + $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), $1); + } ; markup: - markup_head_1_list simple_markup { - SCM mapper = ly_lily_module_constant ("map-markup-command-list"); - $$ = scm_car (scm_call_2 (mapper, $1, scm_list_1 ($2))); + markup_head_1_list simple_markup + { + $$ = scm_car (MAKE_SYNTAX ("composed-markup-list", + @2, $1, scm_list_1 ($2))); } | simple_markup { $$ = $1; @@ -3072,18 +3448,9 @@ Lily_lexer::try_special_identifiers (SCM *destination, SCM sid) *destination = unsmob_context_mod (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)) { 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; @@ -3100,14 +3467,6 @@ Lily_lexer::try_special_identifiers (SCM *destination, SCM sid) *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; } return -1; @@ -3129,14 +3488,34 @@ get_next_unique_lyrics_context_id () 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; } @@ -3152,23 +3531,103 @@ SCM loc_on_music (Input loc, SCM arg) 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 (unsmob_music (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 (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 (); + } + 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 (unsmob_pitch (simple)) + return make_chord_elements (loc, simple, + parser->default_duration_.smobbed_copy (), + SCM_EOL); + } + return simple; } Music *