X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=fc9aea63be73c95966a31ebe207b12228fdff2bf;hb=32a34dcef0c0041c6d62677487a380b5c8b85712;hp=0bb4c152f273455dd1e02f201803e66d8eeaa685;hpb=e90f0536f9be39ada0bef0aeb0d275dec3b2fb5b;p=lilypond.git diff --git a/lily/parser.yy b/lily/parser.yy index 0bb4c152f2..fc9aea63be 100644 --- a/lily/parser.yy +++ b/lily/parser.yy @@ -1,7 +1,8 @@ +/* -*- mode: c++; c-file-style: "linux" -*- */ /* This file is part of LilyPond, the GNU music typesetter. - Copyright (C) 1997--2011 Han-Wen Nienhuys + Copyright (C) 1997--2012 Han-Wen Nienhuys Jan Nieuwenhuizen LilyPond is free software: you can redistribute it and/or modify @@ -18,15 +19,17 @@ along with LilyPond. If not, see . */ -%{ +/* Mode and indentation are at best a rough approximation based on TAB + * formatting (reasonable for compatibility with unspecific editor + * modes as Bison modes are hard to find) and need manual correction + * frequently. Without a reasonably dependable way of formatting a + * Bison file sensibly, there is little point in trying to fix the + * inconsistent state of indentation. + */ -#define YYDEBUG 1 -#define YYERROR_VERBOSE 1 -#define YYPARSE_PARAM my_lily_parser -#define YYLEX_PARAM my_lily_parser -#define PARSER ((Lily_parser *) my_lily_parser) +%{ -#define yyerror PARSER->parser_error +#define yyerror Lily_parser::parser_error /* We use custom location type: Input objects */ #define YYLTYPE Input @@ -36,17 +39,20 @@ %} +%parse-param {Lily_parser *parser} +%lex-param {Lily_parser *parser} +%error-verbose +%debug + /* We use SCMs to do strings, because it saves us the trouble of -deleting them. Let's hope that a stack overflow doesnt trigger a move +deleting them. Let's hope that a stack overflow doesn't trigger a move of the parse stack onto the heap. */ -%left PREC_TOP -%left ADDLYRICS %left PREC_BOT +%nonassoc REPEAT +%nonassoc ALTERNATIVE -%expect 1 - -/* One shift/reduce problem +/* The above precedences tackle the shift/reduce problem 1. \repeat \repeat .. \alternative @@ -58,6 +64,41 @@ or \repeat { \repeat } \alternative */ +%nonassoc COMPOSITE +%left ADDLYRICS + + /* ADDLYRICS needs to have lower precedence than argument scanning, + * or we won't be able to tell music apart from closed_music without + * lookahead in the context of function calls. + */ + +%nonassoc DEFAULT + + /* \default is only applied after exhausting function arguments */ + +%nonassoc FUNCTION_ARGLIST + + /* expressions with units are permitted into argument lists */ + +%right PITCH_IDENTIFIER NOTENAME_PITCH TONICNAME_PITCH + UNSIGNED REAL DURATION_IDENTIFIER ':' + + /* The above are the symbols that can start optional function arguments + that are recognized in the grammar rather than by predicate + */ + +%nonassoc NUMBER_IDENTIFIER '/' + + /* Number-unit expressions, where permitted, are concatenated into + * function arguments, just like fractions and tremoli. Tremoli must + * not have higher precedence than UNSIGNED, or Lilypond will not + * join ':' with a following optional number. + */ + +%left PREC_TOP + + + %pure_parser %locations @@ -95,15 +136,46 @@ using namespace std; #include "main.hh" #include "misc.hh" #include "music.hh" -#include "music.hh" #include "output-def.hh" #include "paper-book.hh" -#include "program-option.hh" #include "scm-hash.hh" #include "score.hh" #include "text-interface.hh" #include "warn.hh" +void +Lily_parser::parser_error (Input const *i, Lily_parser *parser, string s) +{ + parser->parser_error (*i, s); +} + +#define MYBACKUP(Token, Value, Location) \ +do \ + if (yychar == YYEMPTY) \ + { \ + if (Token) \ + parser->lexer_->push_extra_token (Token, Value); \ + parser->lexer_->push_extra_token (BACKUP); \ + } else { \ + parser->parser_error \ + (Location, _("Too much lookahead")); \ + } \ +while (0) + + +#define MYREPARSE(Location, Pred, Token, Value) \ +do \ + if (yychar == YYEMPTY) \ + { \ + parser->lexer_->push_extra_token (Token, Value); \ + parser->lexer_->push_extra_token (REPARSE, \ + Pred); \ + } else { \ + parser->parser_error \ + (Location, _("Too much lookahead")); \ + } \ +while (0) + %} @@ -112,7 +184,6 @@ using namespace std; Output_def *outputdef; SCM scm; std::string *string; - Music *music; Score *score; int i; } @@ -129,7 +200,11 @@ using namespace std; 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)); + LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant (name), scm_list_n (parser->self_scm (), make_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))))) SCM get_next_unique_context_id (); SCM get_next_unique_lyrics_context_id (); @@ -144,16 +219,15 @@ SCM get_next_unique_lyrics_context_id (); static Music *make_music_with_input (SCM name, Input where); -SCM make_music_relative (Pitch start, SCM music, Input loc); -SCM run_music_function (Lily_parser *, SCM expr); -SCM get_first_context_id (SCM type, Music *m); -SCM make_chord_elements (SCM pitch, SCM dur, SCM modification_list); +SCM check_scheme_arg (Lily_parser *parser, Input loc, + SCM arg, SCM args, SCM pred); +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 (int step, Rational alter); SCM make_simple_markup (SCM a); bool is_duration (int t); bool is_regular_identifier (SCM id); -bool ly_input_procedure_p (SCM x); -int yylex (YYSTYPE *s, YYLTYPE *loc, void *v); +int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser); void set_music_properties (Music *p, SCM a); %} @@ -185,26 +259,19 @@ void set_music_properties (Music *p, SCM a); %token DRUMS "\\drums" %token FIGUREMODE "\\figuremode" %token FIGURES "\\figures" -%token GROBDESCRIPTIONS "\\grobdescriptions" %token HEADER "\\header" -%token INVALID "\\invalid" -%token KEY "\\key" +%token INVALID "\\version-error" %token LAYOUT "\\layout" %token LYRICMODE "\\lyricmode" %token LYRICS "\\lyrics" %token LYRICSTO "\\lyricsto" -%token MARK "\\mark" %token MARKUP "\\markup" -%token MARKUPLINES "\\markuplines" +%token MARKUPLIST "\\markuplist" %token MIDI "\\midi" %token NAME "\\name" %token NOTEMODE "\\notemode" -%token OCTAVE "\\octave" -%token ONCE "\\once" %token OVERRIDE "\\override" %token PAPER "\\paper" -%token PARTIAL "\\partial" -%token RELATIVE "\\relative" %token REMOVE "\\remove" %token REPEAT "\\repeat" %token REST "\\rest" @@ -213,16 +280,12 @@ void set_music_properties (Music *p, SCM a); %token SEQUENTIAL "\\sequential" %token SET "\\set" %token SIMULTANEOUS "\\simultaneous" -%token SKIP "\\skip" %token TEMPO "\\tempo" -%token TIMES "\\times" -%token TRANSPOSE "\\transpose" %token TYPE "\\type" %token UNSET "\\unset" %token WITH "\\with" /* Keyword token exceptions. */ -%token TIME_T "\\time" %token NEWCONTEXT "\\new" @@ -263,18 +326,24 @@ If we give names, Bison complains. %token MULTI_MEASURE_REST -%token DIGIT %token E_UNSIGNED -%token UNSIGNED +%token UNSIGNED /* Artificial tokens, for more generic function syntax */ -%token EXPECT_MARKUP; -%token EXPECT_MUSIC; -%token EXPECT_SCM; -%token EXPECT_MARKUP_LIST +%token EXPECT_MARKUP "markup?" +%token EXPECT_PITCH "ly:pitch?" +%token EXPECT_DURATION "ly:duration?" +%token EXPECT_SCM "scheme?" +%token BACKUP "(backed-up?)" +%token REPARSE "(reparsed?)" +%token EXPECT_MARKUP_LIST "markup-list?" +%token EXPECT_OPTIONAL "optional?" /* After the last argument. */ %token EXPECT_NO_MORE_ARGS; +/* An artificial token for parsing embedded Lilypond */ +%token EMBEDDED_LILY "#{" + %token BOOK_IDENTIFIER %token CHORDMODIFIER_PITCH %token CHORD_MODIFIER @@ -282,15 +351,18 @@ If we give names, Bison complains. %token CONTEXT_DEF_IDENTIFIER %token CONTEXT_MOD_IDENTIFIER %token DRUM_PITCH +%token PITCH_IDENTIFIER %token DURATION_IDENTIFIER %token EVENT_IDENTIFIER +%token EVENT_FUNCTION %token FRACTION %token LYRICS_STRING +%token LYRIC_ELEMENT %token LYRIC_MARKUP_IDENTIFIER %token MARKUP_FUNCTION %token MARKUP_LIST_FUNCTION %token MARKUP_IDENTIFIER -%token MARKUPLINES_IDENTIFIER +%token MARKUPLIST_IDENTIFIER %token MUSIC_FUNCTION %token MUSIC_IDENTIFIER %token NOTENAME_PITCH @@ -298,6 +370,7 @@ If we give names, Bison complains. %token OUTPUT_DEF_IDENTIFIER %token REAL %token RESTNAME +%token SCM_FUNCTION %token SCM_IDENTIFIER %token SCM_TOKEN %token SCORE_IDENTIFIER @@ -325,8 +398,17 @@ If we give names, Bison complains. /* Music */ %type composite_music %type grouped_music_list +%type braced_music_list +%type closed_music %type music -%type prefix_composite_music +%type music_bare +%type music_arg +%type music_assign +%type music_embedded +%type music_or_context_def +%type complex_music +%type complex_music_prefix +%type mode_changed_music %type repeated_music %type sequential_music %type simple_music @@ -339,15 +421,18 @@ If we give names, Bison complains. %type context_change %type direction_less_event %type direction_reqd_event +%type embedded_lilypond %type event_chord +%type fingering %type gen_text_def %type music_property_def %type note_chord_element %type post_event +%type post_event_nofinger %type re_rhythmed_music -%type relative_music %type simple_element %type simple_music_property_def +%type start_symbol %type string_number_event %type tempo_event @@ -357,12 +442,11 @@ If we give names, Bison complains. %type output_def %type paper_block -%type alternative_music -%type generic_prefix_music_scm +%type music_function_call %type music_list -%type absolute_pitch %type assignment_id %type bare_number +%type bare_number_closed %type unsigned_number %type bass_figure %type figured_bass_modification @@ -376,25 +460,45 @@ If we give names, Bison complains. %type context_def_spec_block %type context_def_spec_body %type context_mod +%type context_mod_arg +%type context_mod_embedded %type context_mod_list %type context_prop_spec %type direction_less_char %type duration_length %type embedded_scm +%type embedded_scm_arg +%type embedded_scm_arg_closed +%type embedded_scm_bare +%type embedded_scm_bare_arg +%type embedded_scm_closed +%type event_function_event %type figure_list %type figure_spec -%type fraction %type full_markup %type full_markup_list -%type function_scm_argument %type function_arglist -%type function_arglist_music_last -%type function_arglist_nonmusic_last -%type function_arglist_nonmusic +%type function_arglist_optional +%type function_arglist_backup +%type function_arglist_nonbackup +%type function_arglist_nonbackup_common +%type function_arglist_closed_nonbackup +%type function_arglist_skip +%type function_arglist_bare +%type function_arglist_closed +%type function_arglist_closed_optional +%type function_arglist_common +%type function_arglist_common_lyric +%type function_arglist_common_minus +%type function_arglist_closed_common +%type function_arglist_keep +%type function_arglist_closed_keep %type identifier_init +%type lilypond %type lilypond_header -%type lilypond_header_body %type lyric_element +%type lyric_element_arg +%type lyric_element_music %type lyric_markup %type markup %type markup_braced_list @@ -407,10 +511,10 @@ If we give names, Bison complains. %type markup_head_1_list %type markup_list %type markup_top +%type maybe_notemode_duration %type mode_changing_head %type mode_changing_head_with_context %type multiplied_duration -%type music_function_identifier_musicless_prefix %type music_function_event %type music_function_chord_body %type new_chord @@ -428,6 +532,9 @@ If we give names, Bison complains. %type property_operation %type property_path property_path_revved %type scalar +%type scalar_closed +%type scm_function_call +%type scm_function_call_closed %type script_abbreviation %type simple_chord_elements %type simple_markup @@ -453,55 +560,68 @@ prec levels in different prods */ %% -lilypond: /* empty */ +start_symbol: + lilypond + | EMBEDDED_LILY { + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); + } embedded_lilypond { + parser->lexer_->pop_state (); + parser->lexer_->set_identifier (ly_symbol2scm ("parseStringResult"), $3); + } + ; + +lilypond: /* empty */ { } | lilypond toplevel_expression { } | lilypond assignment { } | lilypond error { - PARSER->error_level_ = 1; + parser->error_level_ = 1; } | lilypond INVALID { - PARSER->error_level_ = 1; + parser->error_level_ = 1; } ; toplevel_expression: - lilypond_header { - PARSER->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $1); + { + parser->lexer_->add_scope (get_header (parser)); + } lilypond_header { + parser->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $2); } | book_block { Book *book = $1; - SCM proc = PARSER->lexer_->lookup_identifier ("toplevel-book-handler"); - scm_call_2 (proc, PARSER->self_scm (), book->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("toplevel-book-handler"); + scm_call_2 (proc, parser->self_scm (), book->self_scm ()); book->unprotect (); } | bookpart_block { Book *bookpart = $1; - SCM proc = PARSER->lexer_->lookup_identifier ("toplevel-bookpart-handler"); - scm_call_2 (proc, PARSER->self_scm (), bookpart->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler"); + scm_call_2 (proc, parser->self_scm (), bookpart->self_scm ()); bookpart->unprotect (); } | score_block { Score *score = $1; - SCM proc = PARSER->lexer_->lookup_identifier ("toplevel-score-handler"); - scm_call_2 (proc, PARSER->self_scm (), score->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler"); + scm_call_2 (proc, parser->self_scm (), score->self_scm ()); score->unprotect (); } | composite_music { Music *music = unsmob_music ($1); - SCM proc = PARSER->lexer_->lookup_identifier ("toplevel-music-handler"); - scm_call_2 (proc, PARSER->self_scm (), music->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("toplevel-music-handler"); + scm_call_2 (proc, parser->self_scm (), music->self_scm ()); } | full_markup { - SCM proc = PARSER->lexer_->lookup_identifier ("toplevel-text-handler"); - scm_call_2 (proc, PARSER->self_scm (), scm_list_1 ($1)); + SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler"); + scm_call_2 (proc, parser->self_scm (), 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 proc = parser->lexer_->lookup_identifier ("toplevel-text-handler"); + scm_call_2 (proc, parser->self_scm (), $1); } | output_def { SCM id = SCM_EOL; @@ -514,22 +634,94 @@ toplevel_expression: else if ($1->c_variable ("is-layout") == SCM_BOOL_T) id = ly_symbol2scm ("$defaultlayout"); - PARSER->lexer_->set_identifier (id, od->self_scm ()); + parser->lexer_->set_identifier (id, od->self_scm ()); od->unprotect(); } ; -embedded_scm: +embedded_scm_bare: SCM_TOKEN + { + $$ = parser->lexer_->eval_scm_token ($1); + } | SCM_IDENTIFIER ; +embedded_scm_bare_arg: + embedded_scm_bare + | STRING + | STRING_IDENTIFIER + | full_markup + | full_markup_list + | context_modification + | score_block + { + $$ = $1->self_scm (); + $1->unprotect (); + } + | context_def_spec_block + | book_block + { + $$ = $1->self_scm (); + $1->unprotect (); + } + | bookpart_block + { + $$ = $1->self_scm (); + $1->unprotect (); + } + | output_def + { + $$ = $1->self_scm (); + $1->unprotect (); + } + ; + +/* The generic version may end in music, or not */ -lilypond_header_body: +embedded_scm: + embedded_scm_bare + | scm_function_call + ; + +embedded_scm_arg: + embedded_scm_bare_arg + | scm_function_call + | music_arg + ; + +scm_function_call: + SCM_FUNCTION function_arglist { + $$ = MAKE_SYNTAX ("music-function", @$, + $1, $2); + } + ; + +embedded_lilypond: + /* empty */ { - $$ = get_header (PARSER); - PARSER->lexer_->add_scope ($$); + $$ = MAKE_SYNTAX ("void-music", @$); + } + | identifier_init + | music_embedded music_embedded music_list { + $3 = scm_reverse_x ($3, SCM_EOL); + if (unsmob_music ($2)) + $3 = scm_cons ($2, $3); + if (unsmob_music ($1)) + $3 = scm_cons ($1, $3); + $$ = MAKE_SYNTAX ("sequential-music", @$, $3); + } + | error { + parser->error_level_ = 1; } + | INVALID embedded_lilypond { + parser->error_level_ = 1; + } + ; + + +lilypond_header_body: + /* empty */ | lilypond_header_body assignment { } @@ -537,7 +729,7 @@ lilypond_header_body: lilypond_header: HEADER '{' lilypond_header_body '}' { - $$ = PARSER->lexer_->remove_scope (); + $$ = parser->lexer_->remove_scope (); } ; @@ -551,11 +743,11 @@ assignment_id: assignment: assignment_id '=' identifier_init { - PARSER->lexer_->set_identifier ($1, $3); + parser->lexer_->set_identifier ($1, $3); } | assignment_id property_path '=' identifier_init { SCM path = scm_cons (scm_string_to_symbol ($1), $2); - PARSER->lexer_->set_identifier (path, $4); + parser->lexer_->set_identifier (path, $4); ; /* TODO: devise standard for protection in parser. @@ -589,24 +781,18 @@ identifier_init: | context_def_spec_block { $$ = $1; } - | music { - /* Hack: Create event-chord around standalone events. - Prevents the identifier from being interpreted as a post-event. */ - Music *mus = unsmob_music ($1); - bool is_event = mus && - (scm_memq (ly_symbol2scm ("event"), mus->get_property ("types")) - != SCM_BOOL_F); - if (!is_event) - $$ = $1; - else - $$ = MAKE_SYNTAX ("event-chord", @$, scm_list_1 ($1)); + | music_assign { + $$ = $1; } - | post_event { + | post_event_nofinger { $$ = $1; } | number_expression { $$ = $1; } + | FRACTION { + $$ = $1; + } | string { $$ = $1; } @@ -619,9 +805,6 @@ identifier_init: | full_markup_list { $$ = $1; } - | DIGIT { - $$ = scm_from_int ($1); - } | context_modification { $$ = $1; } @@ -634,6 +817,27 @@ context_def_spec_block: } ; +context_mod_arg: + embedded_scm + | composite_music + ; + +context_mod_embedded: + context_mod_arg + { + if (unsmob_music ($1)) { + SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler"); + $1 = scm_call_2 (proc, parser->self_scm (), $1); + } + if (unsmob_context_mod ($1)) + $$ = $1; + else { + parser->parser_error (@1, _ ("not a context mod")); + } + } + ; + + context_def_spec_body: /**/ { $$ = Context_def::make_scm (); @@ -643,17 +847,6 @@ context_def_spec_body: $$ = $1; unsmob_context_def ($$)->origin ()->set_spot (@$); } - | context_def_spec_body GROBDESCRIPTIONS embedded_scm { - Context_def*td = unsmob_context_def ($$); - - for (SCM p = $3; scm_is_pair (p); p = scm_cdr (p)) { - SCM tag = scm_caar (p); - - /* TODO: should make new tag "grob-definition" ? */ - td->add_context_mod (scm_list_3 (ly_symbol2scm ("assign"), - tag, scm_cons (scm_cdar (p), SCM_EOL))); - } - } | context_def_spec_body context_mod { unsmob_context_def ($$)->add_context_mod ($2); } @@ -664,6 +857,13 @@ context_def_spec_body: td->add_context_mod (scm_car (m)); } } + | context_def_spec_body context_mod_embedded { + Context_def *td = unsmob_context_def ($$); + SCM new_mods = unsmob_context_mod ($2)->get_mods (); + for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) { + td->add_context_mod (scm_car (m)); + } + } ; @@ -671,8 +871,8 @@ context_def_spec_body: book_block: BOOK '{' book_body '}' { $$ = $3; - pop_paper (PARSER); - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F); + pop_paper (parser); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F); } ; @@ -682,55 +882,55 @@ book_block: book_body: { $$ = new Book; - init_papers (PARSER); + init_papers (parser); $$->origin ()->set_spot (@$); - $$->paper_ = dynamic_cast (unsmob_output_def (PARSER->lexer_->lookup_identifier ("$defaultpaper"))->clone ()); + $$->paper_ = dynamic_cast (unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ()); $$->paper_->unprotect (); - push_paper (PARSER, $$->paper_); - $$->header_ = PARSER->lexer_->lookup_identifier ("$defaultheader"); - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $$->self_scm ()); - PARSER->lexer_->set_identifier (ly_symbol2scm ("book-output-suffix"), SCM_BOOL_F); - PARSER->lexer_->set_identifier (ly_symbol2scm ("book-filename"), SCM_BOOL_F); + push_paper (parser, $$->paper_); + $$->header_ = get_header (parser); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $$->self_scm ()); } | BOOK_IDENTIFIER { $$ = unsmob_book ($1); $$->protect (); $$->origin ()->set_spot (@$); - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1); } | book_body paper_block { $$->paper_ = $2; $2->unprotect (); - set_paper (PARSER, $2); + set_paper (parser, $2); } | book_body bookpart_block { Book *bookpart = $2; - SCM proc = PARSER->lexer_->lookup_identifier ("book-bookpart-handler"); + SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler"); scm_call_2 (proc, $$->self_scm (), bookpart->self_scm ()); bookpart->unprotect (); } | book_body score_block { Score *score = $2; - SCM proc = PARSER->lexer_->lookup_identifier ("book-score-handler"); + SCM proc = parser->lexer_->lookup_identifier ("book-score-handler"); scm_call_2 (proc, $$->self_scm (), score->self_scm ()); score->unprotect (); } | book_body composite_music { Music *music = unsmob_music ($2); - SCM proc = PARSER->lexer_->lookup_identifier ("book-music-handler"); - scm_call_3 (proc, PARSER->self_scm (), $$->self_scm (), music->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("book-music-handler"); + scm_call_3 (proc, parser->self_scm (), $$->self_scm (), music->self_scm ()); } | 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, $$->self_scm (), scm_list_1 ($2)); } | book_body full_markup_list { - SCM proc = PARSER->lexer_->lookup_identifier ("book-text-handler"); + SCM proc = parser->lexer_->lookup_identifier ("book-text-handler"); scm_call_2 (proc, $$->self_scm (), $2); } - | book_body lilypond_header { - $$->header_ = $2; - } + | book_body + { + parser->lexer_->add_scope ($1->header_); + } lilypond_header + | book_body embedded_scm { } | book_body error { $$->paper_ = 0; $$->scores_ = SCM_EOL; @@ -741,7 +941,7 @@ book_body: bookpart_block: BOOKPART '{' bookpart_body '}' { $$ = $3; - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F); } ; @@ -749,13 +949,13 @@ bookpart_body: { $$ = new Book; $$->origin ()->set_spot (@$); - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $$->self_scm ()); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $$->self_scm ()); } | BOOK_IDENTIFIER { $$ = unsmob_book ($1); $$->protect (); $$->origin ()->set_spot (@$); - PARSER->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1); + parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1); } | bookpart_body paper_block { $$->paper_ = $2; @@ -763,26 +963,30 @@ bookpart_body: } | bookpart_body score_block { Score *score = $2; - SCM proc = PARSER->lexer_->lookup_identifier ("bookpart-score-handler"); + SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler"); scm_call_2 (proc, $$->self_scm (), score->self_scm ()); score->unprotect (); } | bookpart_body composite_music { Music *music = unsmob_music ($2); - SCM proc = PARSER->lexer_->lookup_identifier ("bookpart-music-handler"); - scm_call_3 (proc, PARSER->self_scm (), $$->self_scm (), music->self_scm ()); + SCM proc = parser->lexer_->lookup_identifier ("bookpart-music-handler"); + scm_call_3 (proc, parser->self_scm (), $$->self_scm (), music->self_scm ()); } | 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, $$->self_scm (), scm_list_1 ($2)); } | bookpart_body full_markup_list { - SCM proc = PARSER->lexer_->lookup_identifier ("bookpart-text-handler"); + SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler"); scm_call_2 (proc, $$->self_scm (), $2); } - | bookpart_body lilypond_header { - $$->header_ = $2; - } + | bookpart_body + { + if (!ly_is_module ($1->header_)) + $1->header_ = ly_make_module (false); + parser->lexer_->add_scope ($1->header_); + } lilypond_header + | bookpart_body embedded_scm { } | bookpart_body error { $$->paper_ = 0; $$->scores_ = SCM_EOL; @@ -799,7 +1003,7 @@ score_body: music { SCM m = $1; SCM scorify = ly_lily_module_constant ("scorify-music"); - SCM score = scm_call_2 (scorify, m, PARSER->self_scm ()); + SCM score = scm_call_2 (scorify, m, parser->self_scm ()); // pass ownernship to C++ again. $$ = unsmob_score (score); @@ -811,13 +1015,16 @@ score_body: $$->protect (); $$->origin ()->set_spot (@$); } - | score_body lilypond_header { - $$->set_header ($2); - } + | score_body + { + if (!ly_is_module ($1->get_header ())) + $1->set_header (ly_make_module (false)); + parser->lexer_->add_scope ($1->get_header ()); + } lilypond_header | score_body output_def { if ($2->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T) { - PARSER->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead")); + parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead")); } else @@ -841,9 +1048,9 @@ paper_block: $$ = $1; if ($$->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T) { - PARSER->parser_error (@1, _ ("need \\paper for paper block")); + parser->parser_error (@1, _ ("need \\paper for paper block")); $1->unprotect (); - $$ = get_paper (PARSER); + $$ = get_paper (parser); } } ; @@ -853,37 +1060,56 @@ output_def: output_def_body '}' { $$ = $1; - PARSER->lexer_->remove_scope (); - PARSER->lexer_->pop_state (); + parser->lexer_->remove_scope (); + parser->lexer_->pop_state (); } ; output_def_head: PAPER { - $$ = get_paper (PARSER); + $$ = get_paper (parser); $$->input_origin_ = @$; - PARSER->lexer_->add_scope ($$->scope_); + parser->lexer_->add_scope ($$->scope_); } | MIDI { - Output_def *p = get_midi (PARSER); + Output_def *p = get_midi (parser); $$ = p; - PARSER->lexer_->add_scope (p->scope_); + parser->lexer_->add_scope (p->scope_); } | LAYOUT { - Output_def *p = get_layout (PARSER); + Output_def *p = get_layout (parser); - PARSER->lexer_->add_scope (p->scope_); + parser->lexer_->add_scope (p->scope_); $$ = p; } ; output_def_head_with_mode_switch: output_def_head { - PARSER->lexer_->push_initial_state (); + parser->lexer_->push_initial_state (); $$ = $1; } ; +// We need this weird nonterminal because both music as well as a +// context definition can start with \context and the difference is +// only apparent after looking at the next token. If it is '{', there +// is still time to escape from notes mode. + +music_or_context_def: + music_arg + { + parser->lexer_->pop_state (); + } + | CONTEXT + { + parser->lexer_->pop_state (); + } '{' context_def_spec_body '}' + { + $$ = $4; + } + ; + output_def_body: output_def_head_with_mode_switch '{' { $$ = $1; @@ -896,14 +1122,27 @@ output_def_body: o->input_origin_.set_spot (@$); $$ = o; $$->protect (); - PARSER->lexer_->remove_scope (); - PARSER->lexer_->add_scope (o->scope_); + parser->lexer_->remove_scope (); + parser->lexer_->add_scope (o->scope_); } | output_def_body assignment { } - | output_def_body context_def_spec_block { - assign_context_def ($$, $2); + | output_def_body + { + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); + } music_or_context_def + { + if (unsmob_context_def ($3)) + assign_context_def ($$, $3); + else { + + SCM proc = parser->lexer_->lookup_identifier + ("output-def-music-handler"); + scm_call_3 (proc, parser->self_scm (), + $1->self_scm (), $3); + } } | output_def_body error { @@ -914,7 +1153,7 @@ tempo_event: TEMPO steno_duration '=' tempo_range { $$ = MAKE_SYNTAX ("tempo", @$, SCM_EOL, $2, $4); } - | TEMPO scalar steno_duration '=' tempo_range { + | TEMPO scalar_closed steno_duration '=' tempo_range { $$ = MAKE_SYNTAX ("tempo", @$, $2, $3, $5); } | TEMPO scalar { @@ -923,96 +1162,110 @@ tempo_event: ; /* -The representation of a list is the - - (LIST . LAST-CONS) - - to have efficient append. */ +The representation of a list is reversed to have efficient append. */ music_list: /* empty */ { - $$ = scm_cons (SCM_EOL, SCM_EOL); - } - | music_list music { - SCM s = $$; - SCM c = scm_cons ($2, SCM_EOL); - - if (scm_is_pair (scm_cdr (s))) - scm_set_cdr_x (scm_cdr (s), c); /* append */ - else - scm_set_car_x (s, c); /* set first cons */ - scm_set_cdr_x (s, c); /* remember last cell */ + $$ = SCM_EOL; } - | music_list embedded_scm { - + | music_list music_embedded { + if (unsmob_music ($2)) + $$ = scm_cons ($2, $1); } | music_list error { Music *m = MY_MAKE_MUSIC("Music", @$); // ugh. code dup m->set_property ("error-found", SCM_BOOL_T); - SCM s = $$; - SCM c = scm_cons (m->self_scm (), SCM_EOL); + $$ = scm_cons (m->self_scm (), $1); m->unprotect (); /* UGH */ + } + ; - if (scm_is_pair (scm_cdr (s))) - scm_set_cdr_x (scm_cdr (s), c); /* append */ - else - scm_set_car_x (s, c); /* set first cons */ - scm_set_cdr_x (s, c); /* remember last cell */ +braced_music_list: + '{' music_list '}' + { + $$ = scm_reverse_x ($2, SCM_EOL); } ; -music: - simple_music - | composite_music +music: music_arg + | lyric_element_music ; -alternative_music: - /* empty */ { - $$ = SCM_EOL; +music_embedded: + music + | embedded_scm + { + if (unsmob_music ($1) + || scm_is_eq ($1, SCM_UNSPECIFIED)) + $$ = $1; + else + { + @$.warning (_ ("Ignoring non-music expression")); + $$ = SCM_UNSPECIFIED; + } } - | ALTERNATIVE '{' music_list '}' { - $$ = scm_car ($3); + ; + +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 (); + } } + | composite_music %prec COMPOSITE ; +music_assign: + simple_music + | composite_music %prec COMPOSITE + | lyric_element_music + ; repeated_music: - REPEAT simple_string unsigned_number music alternative_music + REPEAT simple_string unsigned_number music { - $$ = MAKE_SYNTAX ("repeat", @$, $2, $3, $4, $5); + $$ = 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); } ; sequential_music: - SEQUENTIAL '{' music_list '}' { - $$ = MAKE_SYNTAX ("sequential-music", @$, scm_car ($3)); + SEQUENTIAL braced_music_list { + $$ = MAKE_SYNTAX ("sequential-music", @$, $2); } - | '{' music_list '}' { - $$ = MAKE_SYNTAX ("sequential-music", @$, scm_car ($2)); + | braced_music_list { + $$ = MAKE_SYNTAX ("sequential-music", @$, $1); } ; simultaneous_music: - SIMULTANEOUS '{' music_list '}'{ - $$ = MAKE_SYNTAX ("simultaneous-music", @$, scm_car ($3)); + SIMULTANEOUS braced_music_list { + $$ = MAKE_SYNTAX ("simultaneous-music", @$, $2); } | DOUBLE_ANGLE_OPEN music_list DOUBLE_ANGLE_CLOSE { - $$ = MAKE_SYNTAX ("simultaneous-music", @$, scm_car ($2)); + $$ = MAKE_SYNTAX ("simultaneous-music", @$, scm_reverse_x ($2, SCM_EOL)); } ; simple_music: event_chord - | MUSIC_IDENTIFIER | music_property_def | context_change ; context_modification: - WITH { PARSER->lexer_->push_initial_state (); } '{' context_mod_list '}' + WITH { parser->lexer_->push_initial_state (); } '{' context_mod_list '}' { - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); $$ = $4; } | WITH CONTEXT_MOD_IDENTIFIER @@ -1023,6 +1276,15 @@ context_modification: { $$ = $1; } + | WITH embedded_scm_closed + { + if (unsmob_context_mod ($2)) + $$ = $2; + else { + parser->parser_error (@2, _ ("not a context mod")); + $$ = Context_mod ().smobbed_copy (); + } + } ; optional_context_mod: @@ -1047,71 +1309,518 @@ context_mod_list: if (md) unsmob_context_mod ($1)->add_context_mods (md->get_mods ()); } + | context_mod_list context_mod_embedded { + unsmob_context_mod ($1)->add_context_mods + (unsmob_context_mod ($2)->get_mods ()); + } ; composite_music: - prefix_composite_music { $$ = $1; } - | grouped_music_list { $$ = $1; } + complex_music + | music_bare + ; + +/* Music that can be parsed without lookahead */ +closed_music: + music_bare + | complex_music_prefix closed_music + { + $$ = FINISH_MAKE_SYNTAX ($1, @$, $2); + } + ; + +music_bare: + mode_changed_music + | MUSIC_IDENTIFIER + | grouped_music_list + ; + +grouped_music_list: + simultaneous_music { $$ = $1; } + | sequential_music { $$ = $1; } + ; + +/* An argument list. If a function \foo expects scm scm pitch, then the lexer expands \foo into the token sequence: + MUSIC_FUNCTION EXPECT_PITCH EXPECT_SCM EXPECT_SCM EXPECT_NO_MORE_ARGS +and this rule returns the reversed list of arguments. */ + +function_arglist_skip: + function_arglist_common + | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip + { + $$ = scm_cons ($1, $3); + } %prec FUNCTION_ARGLIST + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_skip + { + $$ = scm_cons ($1, $3); + } %prec FUNCTION_ARGLIST + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip + { + $$ = scm_cons ($1, $3); + } %prec FUNCTION_ARGLIST + ; + + +function_arglist_nonbackup_common: + EXPECT_OPTIONAL EXPECT_PITCH function_arglist pitch_also_in_chords { + $$ = scm_cons ($4, $3); + } + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed duration_length { + $$ = scm_cons ($4, $3); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed FRACTION + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed post_event_nofinger + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' UNSIGNED + { + SCM n = scm_difference ($5, SCM_UNDEFINED); + if (scm_is_true (scm_call_1 ($2, n))) + $$ = scm_cons (n, $3); + else { + Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5); + t->set_property ("digit", $5); + $$ = t->unprotect (); + if (scm_is_true (scm_call_1 ($2, $$))) + $$ = scm_cons ($$, $3); + else + $$ = check_scheme_arg (parser, @4, n, $3, $2); + } + + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' REAL + { + $$ = check_scheme_arg (parser, @4, + scm_difference ($5, SCM_UNDEFINED), + $3, $2); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed '-' NUMBER_IDENTIFIER + { + $$ = check_scheme_arg (parser, @4, + scm_difference ($5, SCM_UNDEFINED), + $3, $2); + } + ; + +function_arglist_closed_nonbackup: + function_arglist_nonbackup_common + | EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg_closed + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number_closed + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + ; + +function_arglist_nonbackup: + function_arglist_nonbackup_common + | EXPECT_OPTIONAL EXPECT_SCM function_arglist embedded_scm_arg + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed bare_number + { + $$ = check_scheme_arg (parser, @4, $4, $3, $2); + } + ; + +function_arglist_keep: + function_arglist_common + | function_arglist_backup + ; + +function_arglist_closed_keep: + function_arglist_closed_common + | function_arglist_backup + ; + +function_arglist_backup: + EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep embedded_scm_arg_closed + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = scm_cons ($4, $3); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (SCM_IDENTIFIER, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep post_event_nofinger + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = scm_cons ($4, $3); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (EVENT_IDENTIFIER, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_keep lyric_element + { + // 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); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep UNSIGNED + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = $3; + MYREPARSE (@4, $2, UNSIGNED, $4); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (UNSIGNED, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep REAL + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = $3; + MYREPARSE (@4, $2, REAL, $4); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (REAL, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep NUMBER_IDENTIFIER + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = scm_cons ($4, $3); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (NUMBER_IDENTIFIER, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep FRACTION + { + if (scm_is_true (scm_call_1 ($2, $4))) + { + $$ = scm_cons ($4, $3); + } else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (FRACTION, $4, @4); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' UNSIGNED + { + SCM n = scm_difference ($5, SCM_UNDEFINED); + if (scm_is_true (scm_call_1 ($2, n))) { + $$ = $3; + MYREPARSE (@5, $2, REAL, n); + } else { + Music *t = MY_MAKE_MUSIC ("FingeringEvent", @5); + t->set_property ("digit", $5); + $$ = t->unprotect (); + if (scm_is_true (scm_call_1 ($2, $$))) + $$ = scm_cons ($$, $3); + else { + $$ = scm_cons (loc_on_music (@3, $1), $3); + MYBACKUP (UNSIGNED, $5, @5); + parser->lexer_->push_extra_token ('-'); + } + } + + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' REAL + { + SCM n = scm_difference ($5, SCM_UNDEFINED); + if (scm_is_true (scm_call_1 ($2, n))) { + MYREPARSE (@5, $2, REAL, n); + $$ = $3; + } else { + MYBACKUP (REAL, n, @5); + } + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_closed_keep '-' NUMBER_IDENTIFIER + { + SCM n = scm_difference ($5, SCM_UNDEFINED); + if (scm_is_true (scm_call_1 ($2, n))) { + $$ = scm_cons (n, $3); + } else { + MYBACKUP (NUMBER_IDENTIFIER, n, @5); + } + } + | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_keep pitch_also_in_chords + { + $$ = scm_cons ($4, $3); + } + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_keep duration_length + { + $$ = scm_cons ($4, $3); + } + | 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 + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + | function_arglist_backup REPARSE bare_number + { + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } + ; + +function_arglist: + function_arglist_common + | function_arglist_nonbackup + ; + +function_arglist_common: + function_arglist_bare + | EXPECT_SCM function_arglist_optional embedded_scm_arg + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional bare_number + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional FRACTION + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional post_event_nofinger + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | function_arglist_common_minus + | function_arglist_common_lyric + ; + +function_arglist_common_lyric: + EXPECT_SCM function_arglist_optional lyric_element + { + // We check how the predicate thinks about a lyrics + // event or about a markup. If it accepts neither, we + // backup the original token. Otherwise we commit to + // taking the token. Depending on what the predicate + // is willing to accept, we interpret as a string, as + // a lyric event, or ambiguously (meaning that if + // something looking like a duration or post event + // follows, we take the event, otherwise the string). + SCM lyric_event = MAKE_SYNTAX ("lyric-event", @3, $3, + parser->default_duration_.smobbed_copy ()); + if (scm_is_true (scm_call_1 ($1, $3))) + if (scm_is_true (scm_call_1 ($1, lyric_event))) + { + $$ = $2; + MYREPARSE (@3, $1, LYRICS_STRING, $3); + } else { + $$ = scm_cons ($3, $2); + } + else if (scm_is_true (scm_call_1 ($1, lyric_event))) + { + $$ = $2; + MYREPARSE (@3, $1, LYRIC_ELEMENT, $3); + } else { + // This is going to flag a syntax error, we + // know the predicate to be false. + check_scheme_arg (parser, @3, + $3, $2, $1); + } + } + | function_arglist_common_lyric REPARSE lyric_element_arg + { + // This should never be false + $$ = check_scheme_arg (parser, @3, + $3, $1, $2); + } ; -grouped_music_list: - simultaneous_music { $$ = $1; } - | sequential_music { $$ = $1; } +function_arglist_common_minus: + EXPECT_SCM function_arglist_closed_optional '-' UNSIGNED + { + SCM n = scm_difference ($4, SCM_UNDEFINED); + if (scm_is_true (scm_call_1 ($1, n))) { + $$ = $2; + MYREPARSE (@4, $1, REAL, n); + } else { + Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4); + t->set_property ("digit", $4); + $$ = t->unprotect (); + if (scm_is_true (scm_call_1 ($1, $$))) + $$ = scm_cons ($$, $2); + else + $$ = check_scheme_arg (parser, @3, n, $2, $1); + } + + } + | EXPECT_SCM function_arglist_closed_optional '-' REAL + { + $$ = $2; + 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_scm_argument: - embedded_scm - | simple_string +function_arglist_closed: + function_arglist_closed_common + | function_arglist_closed_nonbackup ; -/* An argument list. If a function \foo expects scm scm music, then the lexer expands \foo into the token sequence: - MUSIC_FUNCTION EXPECT_MUSIC EXPECT_SCM EXPECT_SCM EXPECT_NO_MORE_ARGS -and this rule returns the reversed list of arguments. */ - -function_arglist_music_last: - EXPECT_MUSIC function_arglist music { - $$ = scm_cons ($3, $2); +function_arglist_closed_common: + function_arglist_bare + | EXPECT_SCM function_arglist_optional embedded_scm_arg_closed + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional bare_number + { + $$ = 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, + scm_difference ($4, SCM_UNDEFINED), + $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional post_event_nofinger + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_closed_optional FRACTION + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); + } + | EXPECT_SCM function_arglist_optional lyric_element + { + $$ = check_scheme_arg (parser, @3, + $3, $2, $1); } ; -function_arglist_nonmusic_last: - EXPECT_MARKUP function_arglist full_markup { - $$ = scm_cons ($3, $2); +function_arglist_optional: + function_arglist_keep %prec FUNCTION_ARGLIST + | function_arglist_backup BACKUP + | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_optional + { + $$ = scm_cons ($1, $3); } - | EXPECT_MARKUP function_arglist simple_string { - $$ = scm_cons ($3, $2); + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_optional + { + $$ = scm_cons ($1, $3); } - | EXPECT_SCM function_arglist function_scm_argument { - $$ = scm_cons ($3, $2); + ; + +function_arglist_closed_optional: + function_arglist_closed_keep %prec FUNCTION_ARGLIST + | function_arglist_backup BACKUP + | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_closed_optional + { + $$ = scm_cons ($1, $3); + } + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_closed_optional + { + $$ = scm_cons ($1, $3); } ; -function_arglist_nonmusic: EXPECT_NO_MORE_ARGS { +embedded_scm_closed: + embedded_scm_bare + | scm_function_call_closed + ; + +embedded_scm_arg_closed: + embedded_scm_bare_arg + | scm_function_call_closed + | closed_music + ; + +scm_function_call_closed: + SCM_FUNCTION function_arglist_closed { + $$ = MAKE_SYNTAX ("music-function", @$, + $1, $2); + } %prec FUNCTION_ARGLIST + ; + +function_arglist_bare: + EXPECT_NO_MORE_ARGS { $$ = SCM_EOL; } - | EXPECT_MARKUP function_arglist_nonmusic full_markup { + | EXPECT_PITCH function_arglist_optional pitch_also_in_chords { $$ = scm_cons ($3, $2); } - | EXPECT_MARKUP function_arglist_nonmusic simple_string { + | EXPECT_DURATION function_arglist_closed_optional duration_length { $$ = scm_cons ($3, $2); } - | EXPECT_SCM function_arglist_nonmusic function_scm_argument { - $$ = scm_cons ($3, $2); + | EXPECT_OPTIONAL EXPECT_PITCH function_arglist_skip DEFAULT { + $$ = scm_cons ($1, $3); } - ; - -function_arglist: EXPECT_NO_MORE_ARGS { - /* This is for 0-ary functions, so they don't need to - read a lookahead token */ - $$ = SCM_EOL; + | EXPECT_OPTIONAL EXPECT_DURATION function_arglist_skip DEFAULT { + $$ = scm_cons ($1, $3); + } + | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip DEFAULT { + $$ = scm_cons ($1, $3); } - | function_arglist_music_last - | function_arglist_nonmusic_last ; -generic_prefix_music_scm: +music_function_call: MUSIC_FUNCTION function_arglist { - $$ = ly_append2 (scm_list_2 ($1, make_input (@$)), scm_reverse_x ($2, SCM_EOL)); + $$ = MAKE_SYNTAX ("music-function", @$, + $1, $2); } ; @@ -1123,37 +1832,35 @@ optional_id: } ; - -prefix_composite_music: - generic_prefix_music_scm { - $$ = run_music_function (PARSER, $1); +complex_music: + music_function_call + | repeated_music { $$ = $1; } + | re_rhythmed_music { $$ = $1; } + | complex_music_prefix music + { + $$ = FINISH_MAKE_SYNTAX ($1, @$, $2); } - | CONTEXT simple_string optional_id optional_context_mod music { + ; + +complex_music_prefix: + CONTEXT simple_string optional_id optional_context_mod { Context_mod *ctxmod = unsmob_context_mod ($4); SCM mods = SCM_EOL; if (ctxmod) mods = ctxmod->get_mods (); - $$ = MAKE_SYNTAX ("context-specification", @$, $2, $3, $5, mods, SCM_BOOL_F); + $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F); } - | NEWCONTEXT simple_string optional_id optional_context_mod music { + | NEWCONTEXT simple_string optional_id optional_context_mod { Context_mod *ctxmod = unsmob_context_mod ($4); SCM mods = SCM_EOL; if (ctxmod) mods = ctxmod->get_mods (); - $$ = MAKE_SYNTAX ("context-specification", @$, $2, $3, $5, mods, SCM_BOOL_T); + $$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_T); } + ; - | TIMES fraction music { - $$ = MAKE_SYNTAX ("time-scaled-music", @$, $2, $3); - } - | repeated_music { $$ = $1; } - | TRANSPOSE pitch_also_in_chords pitch_also_in_chords music { - Pitch from = *unsmob_pitch ($2); - Pitch to = *unsmob_pitch ($3); - SCM pitch = pitch_interval (from, to).smobbed_copy (); - $$ = MAKE_SYNTAX ("transpose-music", @$, pitch, $4); - } - | mode_changing_head grouped_music_list { +mode_changed_music: + mode_changing_head grouped_music_list { if ($1 == ly_symbol2scm ("chords")) { $$ = MAKE_SYNTAX ("unrelativable-music", @$, $2); @@ -1162,135 +1869,106 @@ prefix_composite_music: { $$ = $2; } - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } | mode_changing_head_with_context optional_context_mod grouped_music_list { Context_mod *ctxmod = unsmob_context_mod ($2); SCM mods = SCM_EOL; if (ctxmod) mods = ctxmod->get_mods (); - $$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, $3, mods, SCM_BOOL_T); + $$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3); if ($1 == ly_symbol2scm ("ChordNames")) { $$ = MAKE_SYNTAX ("unrelativable-music", @$, $$); } - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } - | relative_music { $$ = $1; } - | re_rhythmed_music { $$ = $1; } ; mode_changing_head: NOTEMODE { - SCM nn = PARSER->lexer_->lookup_identifier ("pitchnames"); - PARSER->lexer_->push_note_state (alist_to_hashq (nn)); + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); $$ = ly_symbol2scm ("notes"); } | DRUMMODE { - SCM nn = PARSER->lexer_->lookup_identifier ("drumPitchNames"); - PARSER->lexer_->push_note_state (alist_to_hashq (nn)); + SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames"); + parser->lexer_->push_note_state (nn); $$ = ly_symbol2scm ("drums"); } | FIGUREMODE { - PARSER->lexer_->push_figuredbass_state (); + parser->lexer_->push_figuredbass_state (); $$ = 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 (alist_to_hashq (nn)); + 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); $$ = ly_symbol2scm ("chords"); } | LYRICMODE - { PARSER->lexer_->push_lyric_state (); + { parser->lexer_->push_lyric_state (); $$ = ly_symbol2scm ("lyrics"); } ; mode_changing_head_with_context: DRUMS { - SCM nn = PARSER->lexer_->lookup_identifier ("drumPitchNames"); - PARSER->lexer_->push_note_state (alist_to_hashq (nn)); + SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames"); + parser->lexer_->push_note_state (nn); $$ = ly_symbol2scm ("DrumStaff"); } | FIGURES { - PARSER->lexer_->push_figuredbass_state (); + parser->lexer_->push_figuredbass_state (); $$ = 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 (alist_to_hashq (nn)); + 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); $$ = ly_symbol2scm ("ChordNames"); } | LYRICS - { PARSER->lexer_->push_lyric_state (); + { parser->lexer_->push_lyric_state (); $$ = ly_symbol2scm ("Lyrics"); } ; - -relative_music: - RELATIVE absolute_pitch music { - Pitch start = *unsmob_pitch ($2); - $$ = make_music_relative (start, $3, @$); - } - | RELATIVE composite_music { - Pitch middle_c (0, 0, 0); - $$ = make_music_relative (middle_c, $2, @$); - } - ; - new_lyrics: - ADDLYRICS { PARSER->lexer_->push_lyric_state (); } + ADDLYRICS { parser->lexer_->push_lyric_state (); } /*cont */ - grouped_music_list { + composite_music { /* Can also use music at the expensive of two S/Rs similar to \repeat \alternative */ - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); $$ = scm_cons ($3, SCM_EOL); } - | ADDLYRICS { - PARSER->lexer_->push_lyric_state (); } - MUSIC_IDENTIFIER { - PARSER->lexer_->pop_state (); - $$ = scm_cons ($3, SCM_EOL); - } | new_lyrics ADDLYRICS { - PARSER->lexer_->push_lyric_state (); - } grouped_music_list { - PARSER->lexer_->pop_state (); - $$ = scm_cons ($4, $1); - } - | new_lyrics ADDLYRICS { - PARSER->lexer_->push_lyric_state (); - } MUSIC_IDENTIFIER { - PARSER->lexer_->pop_state (); + parser->lexer_->push_lyric_state (); + } composite_music { + parser->lexer_->pop_state (); $$ = scm_cons ($4, $1); } ; re_rhythmed_music: - grouped_music_list new_lyrics { - $$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL)); - } - | MUSIC_IDENTIFIER new_lyrics { + composite_music new_lyrics { $$ = MAKE_SYNTAX ("add-lyrics", @$, $1, scm_reverse_x ($2, SCM_EOL)); - } + } %prec COMPOSITE | LYRICSTO simple_string { - PARSER->lexer_->push_lyric_state (); + parser->lexer_->push_lyric_state (); } music { - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); $$ = MAKE_SYNTAX ("lyric-combine", @$, $2, $4); } ; @@ -1303,10 +1981,10 @@ context_change: property_path_revved: - embedded_scm { + embedded_scm_closed { $$ = scm_cons ($1, SCM_EOL); } - | property_path_revved embedded_scm { + | property_path_revved embedded_scm_closed { $$ = scm_cons ($2, $1); } ; @@ -1356,16 +2034,19 @@ context_mod: | context_def_mod STRING { $$ = scm_list_2 ($1, $2); } - | context_def_mod embedded_scm { - if (ly_symbol2scm ("consists") != $1) - { - $$ = SCM_EOL; - PARSER->parser_error (@1, _ ("only \\consists takes non-string argument.")); - } - else - { - $$ = scm_list_2 ($1, $2); - } + | context_def_mod embedded_scm + { + if (!scm_is_string ($2) + && ly_symbol2scm ("consists") != $1 + && ly_symbol2scm ("remove") != $1) + { + $$ = SCM_EOL; + parser->parser_error (@1, _ ("only \\consists and \\remove take non-string argument.")); + } + else + { + $$ = scm_list_2 ($1, $2); + } } ; @@ -1414,10 +2095,7 @@ simple_music_property_def: music_property_def: simple_music_property_def { - $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons (PARSER->self_scm (), scm_cons2 (make_input (@$), SCM_BOOL_F, $1))); - } - | ONCE simple_music_property_def { - $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons (PARSER->self_scm (), scm_cons2 (make_input (@$), SCM_BOOL_T, $2))); + $$ = LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("property-operation"), scm_cons2 (parser->self_scm (), make_input (@$), $1)); } ; @@ -1444,31 +2122,37 @@ simple_string: STRING { } ; -scalar: string { - $$ = $1; - } - | LYRICS_STRING { - $$ = $1; - } - | bare_number { - $$ = $1; - } - | embedded_scm { - $$ = $1; - } - | full_markup { - $$ = $1; - } - | DIGIT { - $$ = scm_from_int ($1); - } +scalar: + embedded_scm_arg + | bare_number + | FRACTION + | lyric_element + ; + +scalar_closed: + embedded_scm_arg_closed + | bare_number + | FRACTION + | lyric_element ; + event_chord: - /* TODO: Create a special case that avoids the creation of - EventChords around simple_elements that have no post_events? - */ - simple_chord_elements post_events { + 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)); + } + } + | simple_chord_elements post_events { SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL)); Input i; @@ -1481,8 +2165,6 @@ event_chord: Input i; i.set_location (@1, @3); $$ = MAKE_SYNTAX ("repetition-chord", i, - PARSER->lexer_->chord_repetition_.last_chord_, - PARSER->lexer_->chord_repetition_.repetition_function_, $2, scm_reverse_x ($3, SCM_EOL)); } | MULTI_MEASURE_REST optional_notemode_duration post_events { @@ -1492,13 +2174,7 @@ event_chord: scm_reverse_x ($3, SCM_EOL)); } | command_element - /* note chord elements are memorized into - PARSER->lexer_->chord_repetition_ so that the chord repetition - mechanism copy them when a chord repetition symbol is found - */ - | note_chord_element { - PARSER->lexer_->chord_repetition_.last_chord_ = $$; - } + | note_chord_element ; @@ -1530,7 +2206,8 @@ chord_body: chord_body_elements: /* empty */ { $$ = SCM_EOL; } | chord_body_elements chord_body_element { - $$ = scm_cons ($2, $1); + if (!SCM_UNBNDP ($2)) + $$ = scm_cons ($2, $1); } ; @@ -1563,7 +2240,6 @@ chord_body_element: } | DRUM_PITCH post_events { Music *n = MY_MAKE_MUSIC ("NoteEvent", @$); - n->set_property ("duration", $2); n->set_property ("drum-type", $1); if (scm_is_pair ($2)) { @@ -1572,41 +2248,43 @@ chord_body_element: } $$ = n->unprotect (); } - | music_function_chord_body { - $$ = run_music_function (PARSER, $1); - } - ; + | music_function_chord_body + { + Music *m = unsmob_music ($1); -music_function_identifier_musicless_prefix: MUSIC_FUNCTION { - SCM sig = scm_object_property (yylval.scm, ly_symbol2scm ("music-function-signature")); - if (scm_is_pair (sig) && to_boolean (scm_memq (ly_music_p_proc, scm_cdr (scm_reverse (sig))))) - { - PARSER->parser_error (@$, "Music function applied to event may not have a Music argument, except as the last argument."); + while (m && m->is_mus_type ("music-wrapper-music")) { + $$ = m->get_property ("element"); + m = unsmob_music ($$); + } + + if (!(m && m->is_mus_type ("rhythmic-event"))) { + parser->parser_error (@$, _ ("not a rhythmic event")); + $$ = SCM_UNDEFINED; } } ; music_function_chord_body: - /* We could allow chord functions to have multiple music arguments, - but it's more consistent with music_function_event if we - prohibit it here too */ - music_function_identifier_musicless_prefix EXPECT_MUSIC function_arglist_nonmusic chord_body_element { - $$ = ly_append2 (scm_list_2 ($1, make_input (@$)), scm_reverse_x ($3, scm_list_1 ($4))); - } - | music_function_identifier_musicless_prefix function_arglist_nonmusic { - $$ = ly_append2 (scm_list_2 ($1, make_input (@$)), scm_reverse_x ($2, SCM_EOL)); - } + music_function_call + | MUSIC_IDENTIFIER ; +// Event functions may only take closed arglists, otherwise it would +// not be clear whether a following postevent should be associated +// with the last argument of the event function or with the expression +// for which the function call acts itself as event. + music_function_event: - /* Post-events can only have the last argument as music, without this - restriction we get a shift/reduce conflict from e.g. - c8-\partcombine c8 -. */ - music_function_identifier_musicless_prefix EXPECT_MUSIC function_arglist_nonmusic post_event { - $$ = ly_append2 (scm_list_2 ($1, make_input (@$)), scm_reverse_x ($3, scm_list_1 ($4))); + MUSIC_FUNCTION function_arglist_closed { + $$ = MAKE_SYNTAX ("music-function", @$, + $1, $2); } - | music_function_identifier_musicless_prefix function_arglist_nonmusic { - $$ = ly_append2 (scm_list_2 ($1, make_input (@$)), scm_reverse_x ($2, SCM_EOL)); + ; + +event_function_event: + EVENT_FUNCTION function_arglist_closed { + $$ = MAKE_SYNTAX ("music-function", @$, + $1, $2); } ; @@ -1614,9 +2292,6 @@ command_element: command_event { $$ = $1; } - | SKIP duration_length { - $$ = MAKE_SYNTAX ("skip-music", @$, $2); - } | E_BRACKET_OPEN { Music *m = MY_MAKE_MUSIC ("LigatureEvent", @$); m->set_property ("span-direction", scm_from_int (START)); @@ -1628,10 +2303,10 @@ command_element: $$ = m->unprotect (); } | E_BACKSLASH { - $$ = MAKE_SYNTAX ("voice-separator", @$, SCM_UNDEFINED); + $$ = MAKE_SYNTAX ("voice-separator", @$); } | '|' { - SCM pipe = PARSER->lexer_->lookup_identifier ("pipeSymbol"); + SCM pipe = parser->lexer_->lookup_identifier ("pipeSymbol"); Music *m = unsmob_music (pipe); if (m) @@ -1641,20 +2316,8 @@ command_element: $$ = m->unprotect (); } else - $$ = MAKE_SYNTAX ("bar-check", @$, SCM_UNDEFINED); - - } - | PARTIAL duration_length { - $$ = MAKE_SYNTAX ("partial", @$, $2); - } - - | TIME_T fraction { - SCM proc = ly_lily_module_constant ("make-time-signature-set"); + $$ = MAKE_SYNTAX ("bar-check", @$); - $$ = scm_apply_2 (proc, scm_car ($2), scm_cdr ($2), SCM_EOL); - } - | MARK scalar { - $$ = MAKE_SYNTAX ("make-mark-set", @$, $2); } ; @@ -1662,31 +2325,9 @@ command_event: E_TILDE { $$ = MY_MAKE_MUSIC ("PesOrFlexaEvent", @$)->unprotect (); } - | MARK DEFAULT { - Music *m = MY_MAKE_MUSIC ("MarkEvent", @$); - $$ = m->unprotect (); - } | tempo_event { $$ = $1; } - | KEY DEFAULT { - Music *key = MY_MAKE_MUSIC ("KeyChangeEvent", @$); - $$ = key->unprotect (); - } - | KEY NOTENAME_PITCH SCM_IDENTIFIER { - - Music *key = MY_MAKE_MUSIC ("KeyChangeEvent", @$); - if (scm_ilength ($3) > 0) - { - key->set_property ("pitch-alist", $3); - key->set_property ("tonic", Pitch (0, 0, 0).smobbed_copy ()); - key->transpose (* unsmob_pitch ($2)); - } else { - PARSER->parser_error (@3, _ ("second argument must be pitch list")); - } - - $$ = key->unprotect (); - } ; @@ -1700,25 +2341,25 @@ post_events: } ; -post_event: +post_event_nofinger: direction_less_event { $$ = $1; } | script_dir music_function_event { - $$ = run_music_function (PARSER, $2); + $$ = $2; if ($1) { unsmob_music ($$)->set_property ("direction", scm_from_int ($1)); } } | HYPHEN { - if (!PARSER->lexer_->is_lyric_state ()) - PARSER->parser_error (@1, _ ("have to be in Lyric mode for lyrics")); + if (!parser->lexer_->is_lyric_state ()) + parser->parser_error (@1, _ ("have to be in Lyric mode for lyrics")); $$ = MY_MAKE_MUSIC ("HyphenEvent", @$)->unprotect (); } | EXTENDER { - if (!PARSER->lexer_->is_lyric_state ()) - PARSER->parser_error (@1, _ ("have to be in Lyric mode for lyrics")); + if (!parser->lexer_->is_lyric_state ()) + parser->parser_error (@1, _ ("have to be in Lyric mode for lyrics")); $$ = MY_MAKE_MUSIC ("ExtenderEvent", @$)->unprotect (); } | script_dir direction_reqd_event { @@ -1738,6 +2379,23 @@ post_event: $$ = $2; } | string_number_event + | '^' fingering + { + $$ = $2; + unsmob_music ($$)->set_property ("direction", scm_from_int (UP)); + } + | '_' fingering + { + $$ = $2; + unsmob_music ($$)->set_property ("direction", scm_from_int (DOWN)); + } + ; + +post_event: + post_event_nofinger + | '-' fingering { + $$ = $2; + } ; string_number_event: @@ -1783,7 +2441,7 @@ direction_less_char: direction_less_event: direction_less_char { - SCM predefd = PARSER->lexer_->lookup_identifier_symbol ($1); + SCM predefd = parser->lexer_->lookup_identifier_symbol ($1); Music *m = 0; if (unsmob_music (predefd)) { @@ -1804,6 +2462,7 @@ direction_less_event: a->set_property ("tremolo-type", scm_from_int ($1)); $$ = a->unprotect (); } + | event_function_event ; direction_reqd_event: @@ -1811,11 +2470,11 @@ direction_reqd_event: $$ = $1; } | script_abbreviation { - SCM s = PARSER->lexer_->lookup_identifier ("dash" + ly_scm2string ($1)); + SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1)); Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$); if (scm_is_string (s)) a->set_property ("articulation-type", s); - else PARSER->parser_error (@1, _ ("expecting string as script definition")); + else parser->parser_error (@1, _ ("expecting string as script definition")); $$ = a->unprotect (); } ; @@ -1886,6 +2545,7 @@ pitch: steno_pitch { $$ = $1; } + | PITCH_IDENTIFIER ; pitch_also_in_chords: @@ -1899,15 +2559,18 @@ gen_text_def: t->set_property ("text", $1); $$ = t->unprotect (); } - | string { + | simple_string { Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$); t->set_property ("text", make_simple_markup ($1)); $$ = t->unprotect (); } - | DIGIT { + ; + +fingering: + UNSIGNED { Music *t = MY_MAKE_MUSIC ("FingeringEvent", @$); - t->set_property ("digit", scm_from_int ($1)); + t->set_property ("digit", $1); $$ = t->unprotect (); } ; @@ -1942,27 +2605,28 @@ script_dir: | '-' { $$ = CENTER; } ; - -absolute_pitch: - steno_pitch { - $$ = $1; - } - ; - duration_length: multiplied_duration { $$ = $1; } ; -optional_notemode_duration: +maybe_notemode_duration: { - Duration dd = PARSER->default_duration_; - $$ = dd.smobbed_copy (); + $$ = SCM_UNDEFINED; } | multiplied_duration { $$ = $1; - PARSER->default_duration_ = *unsmob_duration ($$); + parser->default_duration_ = *unsmob_duration ($$); + } +; + + +optional_notemode_duration: + maybe_notemode_duration + { + if (SCM_UNBNDP ($$)) + $$ = parser->default_duration_.smobbed_copy (); } ; @@ -1970,7 +2634,7 @@ steno_duration: bare_unsigned dots { int len = 0; if (!is_duration ($1)) - PARSER->parser_error (@1, _f ("not a duration: %d", $1)); + parser->parser_error (@1, _f ("not a duration: %d", $1)); else len = intlog2 ($1); @@ -1999,13 +2663,6 @@ multiplied_duration: } ; -fraction: - FRACTION { $$ = $1; } - | UNSIGNED '/' UNSIGNED { - $$ = scm_cons (scm_from_int ($1), scm_from_int ($3)); - } - ; - dots: /* empty */ { $$ = 0; @@ -2021,18 +2678,13 @@ tremolo_type: } | ':' bare_unsigned { if (!is_duration ($2)) - PARSER->parser_error (@2, _f ("not a duration: %d", $2)); + parser->parser_error (@2, _f ("not a duration: %d", $2)); $$ = $2; } ; bass_number: - DIGIT { - $$ = scm_from_int ($1); - } - | UNSIGNED { - $$ = scm_from_int ($1); - } + UNSIGNED { $$ = $1; } | STRING { $$ = $1; } | full_markup { $$ = $1; } ; @@ -2143,31 +2795,37 @@ optional_rest: ; simple_element: - pitch exclamations questions octave_check optional_notemode_duration optional_rest { - if (!PARSER->lexer_->is_note_state ()) - PARSER->parser_error (@1, _ ("have to be in Note mode for notes")); - - Music *n = 0; - if ($6) - n = MY_MAKE_MUSIC ("RestEvent", @$); - else - n = MY_MAKE_MUSIC ("NoteEvent", @$); - - n->set_property ("pitch", $1); - n->set_property ("duration", $5); - - if (scm_is_number ($4)) + pitch exclamations questions octave_check maybe_notemode_duration optional_rest { + if (!parser->lexer_->is_note_state ()) + parser->parser_error (@1, _ ("have to be in Note mode for notes")); + if ($2 || $3 || scm_is_number ($4) || !SCM_UNBNDP ($5) || $6) { - int q = scm_to_int ($4); - n->set_property ("absolute-octave", scm_from_int (q-1)); + Music *n = 0; + if ($6) + n = MY_MAKE_MUSIC ("RestEvent", @$); + else + n = MY_MAKE_MUSIC ("NoteEvent", @$); + + n->set_property ("pitch", $1); + if (SCM_UNBNDP ($5)) + n->set_property ("duration", + parser->default_duration_.smobbed_copy ()); + else + n->set_property ("duration", $5); + + if (scm_is_number ($4)) + { + int q = scm_to_int ($4); + n->set_property ("absolute-octave", scm_from_int (q-1)); + } + + if ($3 % 2) + n->set_property ("cautionary", SCM_BOOL_T); + if ($2 % 2 || $3 % 2) + n->set_property ("force-accidental", SCM_BOOL_T); + + $$ = n->unprotect (); } - - if ($3 % 2) - n->set_property ("cautionary", SCM_BOOL_T); - if ($2 % 2 || $3 % 2) - n->set_property ("force-accidental", SCM_BOOL_T); - - $$ = n->unprotect (); } | DRUM_PITCH optional_notemode_duration { Music *n = MY_MAKE_MUSIC ("NoteEvent", @$); @@ -2189,24 +2847,12 @@ simple_element: ev->set_property ("duration", $2); $$ = ev->unprotect (); } - | lyric_element optional_notemode_duration { - if (!PARSER->lexer_->is_lyric_state ()) - PARSER->parser_error (@1, _ ("have to be in Lyric mode for lyrics")); - - Music *levent = MY_MAKE_MUSIC ("LyricEvent", @$); - levent->set_property ("text", $1); - levent->set_property ("duration",$2); - $$= levent->unprotect (); - } ; simple_chord_elements: - simple_element { - $$ = scm_list_1 ($1); - } - | new_chord { - if (!PARSER->lexer_->is_chord_state ()) - PARSER->parser_error (@1, _ ("have to be in Chord mode for chords")); + new_chord { + if (!parser->lexer_->is_chord_state ()) + parser->parser_error (@1, _ ("have to be in Chord mode for chords")); $$ = $1; } | figure_spec optional_notemode_duration { @@ -2227,13 +2873,45 @@ lyric_element: } ; +lyric_element_arg: + lyric_element + | lyric_element multiplied_duration post_events { + $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2); + if (scm_is_pair ($3)) + unsmob_music ($$)->set_property + ("articulations", scm_reverse_x ($3, SCM_EOL)); + } + | lyric_element post_event post_events { + $$ = MAKE_SYNTAX ("lyric-event", @$, $1, + parser->default_duration_.smobbed_copy ()); + unsmob_music ($$)->set_property + ("articulations", scm_cons ($2, scm_reverse_x ($3, SCM_EOL))); + } + | LYRIC_ELEMENT optional_notemode_duration post_events { + $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2); + if (scm_is_pair ($3)) + unsmob_music ($$)->set_property + ("articulations", scm_reverse_x ($3, SCM_EOL)); + } + ; + + +lyric_element_music: + lyric_element optional_notemode_duration post_events { + $$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2); + if (scm_is_pair ($3)) + unsmob_music ($$)->set_property + ("articulations", scm_reverse_x ($3, SCM_EOL)); + } + ; + new_chord: steno_tonic_pitch optional_notemode_duration { - $$ = make_chord_elements ($1, $2, SCM_EOL); + $$ = make_chord_elements (@$, $1, $2, SCM_EOL); } | steno_tonic_pitch optional_notemode_duration chord_separator chord_items { SCM its = scm_reverse_x ($4, SCM_EOL); - $$ = make_chord_elements ($1, $2, scm_cons ($3, its)); + $$ = make_chord_elements (@$, $1, $2, scm_cons ($3, its)); } ; @@ -2338,38 +3016,30 @@ number_factor: bare_number: - UNSIGNED { - $$ = scm_from_int ($1); - } - | REAL { - $$ = $1; - } - | NUMBER_IDENTIFIER { - $$ = $1; + bare_number_closed + | UNSIGNED NUMBER_IDENTIFIER { + $$ = scm_product ($1, $2); } | REAL NUMBER_IDENTIFIER { - $$ = scm_from_double (scm_to_double ($1) *scm_to_double ($2)); - } - | UNSIGNED NUMBER_IDENTIFIER { - $$ = scm_from_double ($1 *scm_to_double ($2)); + $$ = scm_product ($1, $2); } ; +bare_number_closed: + UNSIGNED + | REAL + | NUMBER_IDENTIFIER + ; bare_unsigned: UNSIGNED { - $$ = $1; - } - | DIGIT { - $$ = $1; + $$ = scm_to_int ($1); } ; unsigned_number: - bare_unsigned { $$ = scm_from_int ($1); } - | NUMBER_IDENTIFIER { - $$ = $1; - } + UNSIGNED + | NUMBER_IDENTIFIER ; exclamations: @@ -2391,22 +3061,22 @@ lyric_markup: $$ = $1; } | LYRIC_MARKUP - { PARSER->lexer_->push_markup_state (); } + { parser->lexer_->push_markup_state (); } markup_top { $$ = $3; - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } ; full_markup_list: - MARKUPLINES_IDENTIFIER { + MARKUPLIST_IDENTIFIER { $$ = $1; } - | MARKUPLINES - { PARSER->lexer_->push_markup_state (); } + | MARKUPLIST + { parser->lexer_->push_markup_state (); } markup_list { $$ = $3; - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } ; @@ -2415,10 +3085,10 @@ full_markup: $$ = $1; } | MARKUP - { PARSER->lexer_->push_markup_state (); } + { parser->lexer_->push_markup_state (); } markup_top { $$ = $3; - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } ; @@ -2434,8 +3104,23 @@ markup_top: } ; +markup_scm: + embedded_scm_bare + { + if (Text_interface::is_markup ($1)) + MYBACKUP (MARKUP_IDENTIFIER, $1, @1); + else if (Text_interface::is_markup_list ($1)) + MYBACKUP (MARKUPLIST_IDENTIFIER, $1, @1); + else { + parser->parser_error (@1, _ ("not a markup")); + MYBACKUP (MARKUP_IDENTIFIER, scm_string (SCM_EOL), @1); + } + } BACKUP + ; + + markup_list: - MARKUPLINES_IDENTIFIER { + MARKUPLIST_IDENTIFIER { $$ = $1; } | markup_composed_list { @@ -2447,6 +3132,10 @@ markup_list: | markup_command_list { $$ = scm_list_1 ($1); } + | markup_scm MARKUPLIST_IDENTIFIER + { + $$ = $2; + } ; markup_composed_list: @@ -2482,8 +3171,8 @@ markup_command_basic_arguments: EXPECT_MARKUP_LIST markup_command_list_arguments markup_list { $$ = scm_cons ($3, $2); } - | EXPECT_SCM markup_command_list_arguments embedded_scm { - $$ = scm_cons ($3, $2); + | EXPECT_SCM markup_command_list_arguments embedded_scm_closed { + $$ = check_scheme_arg (parser, @3, $3, $2, $1); } | EXPECT_NO_MORE_ARGS { $$ = SCM_EOL; @@ -2526,17 +3215,21 @@ simple_markup: $$ = $1; } | SCORE { - SCM nn = PARSER->lexer_->lookup_identifier ("pitchnames"); - PARSER->lexer_->push_note_state (alist_to_hashq (nn)); + SCM nn = parser->lexer_->lookup_identifier ("pitchnames"); + parser->lexer_->push_note_state (nn); } '{' score_body '}' { Score * sc = $4; $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), sc->self_scm ()); sc->unprotect (); - PARSER->lexer_->pop_state (); + parser->lexer_->pop_state (); } | MARKUP_FUNCTION markup_command_basic_arguments { $$ = scm_cons ($1, scm_reverse_x ($2, SCM_EOL)); } + | markup_scm MARKUP_IDENTIFIER + { + $$ = $2; + } ; markup: @@ -2560,7 +3253,7 @@ Lily_parser::set_yydebug (bool x) void Lily_parser::do_yyparse () { - yyparse ((void*)this); + yyparse (this); } @@ -2611,11 +3304,12 @@ Lily_lexer::try_special_identifiers (SCM *destination, SCM sid) unsmob_music (*destination)-> set_property ("origin", make_input (last_input_)); - bool is_event = scm_memq (ly_symbol2scm ("event"), mus->get_property ("types")) - != SCM_BOOL_F; - + bool is_event = mus->is_mus_type ("post-event"); mus->unprotect (); return is_event ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER; + } else if (unsmob_pitch (sid)) { + *destination = unsmob_pitch (sid)->smobbed_copy (); + return PITCH_IDENTIFIER; } else if (unsmob_duration (sid)) { *destination = unsmob_duration (sid)->smobbed_copy (); return DURATION_IDENTIFIER; @@ -2633,7 +3327,7 @@ Lily_lexer::try_special_identifiers (SCM *destination, SCM sid) return MARKUP_IDENTIFIER; } else if (Text_interface::is_markup_list (sid)) { *destination = sid; - return MARKUPLINES_IDENTIFIER; + return MARKUPLIST_IDENTIFIER; } return -1; @@ -2655,25 +3349,27 @@ get_next_unique_lyrics_context_id () return scm_from_locale_string (s); } - -SCM -run_music_function (Lily_parser *parser, SCM expr) +SCM check_scheme_arg (Lily_parser *parser, Input loc, + SCM arg, SCM args, SCM pred) { - SCM func = scm_car (expr); - Input *loc = unsmob_input (scm_cadr (expr)); - SCM args = scm_cddr (expr); - SCM sig = scm_object_property (func, ly_symbol2scm ("music-function-signature")); - - SCM type_check_proc = ly_lily_module_constant ("type-check-list"); + 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); + scm_set_cdr_x (scm_last_pair (args), SCM_BOOL_F); + return args; +} - if (!to_boolean (scm_call_3 (type_check_proc, scm_cadr (expr), sig, args))) +SCM loc_on_music (Input loc, SCM arg) +{ + if (Music *m = unsmob_music (arg)) { - parser->error_level_ = 1; - return LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("void-music"), scm_list_2 (parser->self_scm (), make_input (*loc))); + m = m->clone (); + m->set_spot (loc); + return m->unprotect (); } - - SCM syntax_args = scm_list_4 (parser->self_scm (), make_input (*loc), func, args); - return LOWLEVEL_MAKE_SYNTAX (ly_lily_module_constant ("music-function"), syntax_args); + return arg; } bool @@ -2703,19 +3399,6 @@ make_music_with_input (SCM name, Input where) return m; } -SCM -get_first_context_id (SCM type, Music *m) -{ - SCM id = m->get_property ("context-id"); - if (SCM_BOOL_T == scm_equal_p (m->get_property ("context-type"), type) - && scm_is_string (m->get_property ("context-id")) - && scm_c_string_length (id) > 0) - { - return id; - } - return SCM_EOL; -} - SCM make_simple_markup (SCM a) { @@ -2750,41 +3433,23 @@ make_chord_step (int step, Rational alter) SCM -make_chord_elements (SCM pitch, SCM dur, SCM modification_list) +make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list) { SCM chord_ctor = ly_lily_module_constant ("construct-chord-elements"); - return scm_call_3 (chord_ctor, pitch, dur, modification_list); -} - - -/* Todo: actually also use apply iso. call too ... */ -bool -ly_input_procedure_p (SCM x) -{ - return ly_is_procedure (x) - || (scm_is_pair (x) && ly_is_procedure (scm_car (x))); -} - -SCM -make_music_relative (Pitch start, SCM music, Input loc) -{ - Music *relative = MY_MAKE_MUSIC ("RelativeOctaveMusic", loc); - relative->set_property ("element", music); - - Music *m = unsmob_music (music); - Pitch last = m->to_relative_octave (start); - if (lily_1_8_relative) - m->set_property ("last-pitch", last.smobbed_copy ()); - return relative->unprotect (); + SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list); + for (SCM s = res; scm_is_pair (s); s = scm_cdr (s)) + { + unsmob_music (scm_car (s))->set_spot (loc); + } + return res; } int -yylex (YYSTYPE *s, YYLTYPE *loc, void *v) +yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser) { - Lily_parser *pars = (Lily_parser*) v; - Lily_lexer *lex = pars->lexer_; + Lily_lexer *lex = parser->lexer_; - lex->lexval_ = (void*) s; + lex->lexval_ = s; lex->lexloc_ = loc; lex->prepare_for_next_token (); return lex->yylex ();