-%{ // -*-Fundamental-*-
-
+/* -*- mode: c++; c-file-style: "linux"; indent-tabs-mode: t -*- */
/*
- parser.yy -- Bison/C++ parser for LilyPond
+ This file is part of LilyPond, the GNU music typesetter.
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ Copyright (C) 1997--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
-*/
-/*
-
-TODO:
+ LilyPond is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
-* The rules for who is protecting what are very shady. Uniformise
- this.
-
-* There are too many lexical modes?
+ LilyPond is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
*/
-#include <ctype.h>
-#include <stdlib.h>
-#include <stdio.h>
+/* 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.
+ */
+%{
-#include "book.hh"
-#include "context-def.hh"
-#include "dimensions.hh"
-#include "event.hh"
-#include "file-path.hh"
-#include "input-smob.hh"
-#include "input.hh"
-#include "lily-guile.hh"
-#include "lilypond-input-version.hh"
-#include "main.hh"
-#include "misc.hh"
-#include "lily-lexer.hh"
-#include "lily-parser.hh"
-#include "paper-book.hh"
-#include "output-def.hh"
-#include "scm-hash.hh"
-#include "scm-option.hh"
-#include "score.hh"
-#include "text-item.hh"
-#include "warn.hh"
+#define yyerror Lily_parser::parser_error
-#define MY_MAKE_MUSIC(x) make_music_by_name (ly_symbol2scm (x))
+/* We use custom location type: Input objects */
+#define YYLTYPE Input
+#define YYSTYPE SCM
+#define YYLLOC_DEFAULT(Current,Rhs,N) \
+ ((Current).set_location ((Rhs)[1], (Rhs)[N]))
-Music *property_op_to_music (SCM op);
-Music *context_spec_music (SCM type, SCM id, Music *m, SCM ops);
-SCM get_next_unique_context_id ();
-SCM get_next_unique_lyrics_context_id ();
+#define YYPRINT(file, type, value) \
+ do { \
+ if (scm_is_eq (value, SCM_UNSPECIFIED)) \
+ break; \
+ SCM s = Display::value_to_lily_string (value); \
+ char *p = scm_to_locale_string (s); \
+ fputs (p, file); \
+ free (p); \
+ } while (0)
-#define YYERROR_VERBOSE 1
+%}
-#define YYPARSE_PARAM my_lily_parser
-#define YYLEX_PARAM my_lily_parser
-#define THIS\
- ((Lily_parser *) my_lily_parser)
+%parse-param {Lily_parser *parser}
+%parse-param {SCM *retval}
+%lex-param {Lily_parser *parser}
+%error-verbose
+%debug
-#define yyerror THIS->parser_error
+/* We use SCMs to do strings, because it saves us the trouble of
+deleting them. Let's hope that a stack overflow doesn't trigger a move
+of the parse stack onto the heap. */
-/* We use custom location type: Input objects */
-#define YYLTYPE Input
-#define YYLLOC_DEFAULT(Current,Rhs,N) \
- ((Current).set_location ((Rhs)[1], (Rhs)[N]))
+%left PREC_BOT
+%nonassoc REPEAT
+%nonassoc ALTERNATIVE
+/* The above precedences tackle the shift/reduce problem
-/* Add symbols to the TAGS field of a music object. */
+1. \repeat
+ \repeat .. \alternative
-void
-tag_music (Music *m, SCM tag, Input ip)
-{
- SCM tags = m->get_property ("tags");
- if (scm_is_symbol (tag))
- tags = scm_cons (tag, tags);
- else if (ly_c_list_p (tag))
- tags = ly_append2 (tag, tags);
- else
- ip.warning (_ ("Tag must be symbol or list of symbols."));
-
- m->set_property ("tags", tags);
-}
+ \repeat { \repeat .. \alternative }
-bool
-is_regular_identifier (SCM id)
-{
- String str = ly_scm2string (id);
- char const *s = str.to_str0 ();
+or
- bool v = true;
-#if 0
- isalpha (*s);
- s++;
-#endif
- while (*s && v)
- {
- v = v && isalnum (*s);
- s++;
- }
- return v;
-}
+ \repeat { \repeat } \alternative
+*/
+%nonassoc COMPOSITE
+%left ADDLYRICS
-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;
-}
+%right ':' UNSIGNED REAL E_UNSIGNED EVENT_IDENTIFIER EVENT_FUNCTION '^' '_'
+ HYPHEN EXTENDER DURATION_IDENTIFIER '!'
-SCM
-make_simple_markup (SCM a)
-{
- SCM simple = ly_lily_module_constant ("simple-markup");
- return scm_list_2 (simple, a);
-}
+ /* The above are needed for collecting tremoli and other items (that
+ could otherwise be interpreted as belonging to the next function
+ argument) greedily, and together with the next rule will serve to
+ join numbers and units greedily instead of allowing them into
+ separate function arguments
+ */
-bool
-is_duration (int t)
-{
- return t && t == 1 << intlog2 (t);
-}
+%nonassoc NUMBER_IDENTIFIER
-void
-set_music_properties (Music *p, SCM a)
-{
- for (SCM k = a; scm_is_pair (k); k = scm_cdr (k))
- p->internal_set_property (scm_caar (k), scm_cdar (k));
-}
+%left PREC_TOP
-SCM
-make_chord_step (int step, int alter)
-{
- if (step == 7)
- alter += FLAT;
- while (step < 0)
- step += 7;
- Pitch m ((step -1) / 7, (step - 1) % 7, alter);
- return m.smobbed_copy ();
-}
-SCM
-make_chord (SCM pitch, SCM dur, SCM modification_list)
-{
- SCM chord_ctor = ly_lily_module_constant ("construct-chord");
- SCM ch = scm_call_3 (chord_ctor, pitch, dur, modification_list);
- scm_gc_protect_object (ch);
- return ch;
-}
+%pure-parser
+%locations
-/* Todo: actually also use apply iso. call too ... */
-bool
-ly_input_procedure_p (SCM x)
-{
- return ly_c_procedure_p (x)
- || (scm_is_pair (x) && ly_c_procedure_p (scm_car (x)));
-}
-Music*
-set_property_music (SCM sym, SCM value)
-{
- Music *p = MY_MAKE_MUSIC ("PropertySet");
- p->set_property ("symbol", sym);
- p->set_property ("value", value);
- return p;
-}
-Music*
-make_music_relative (Pitch start, Music *music)
-{
- Music *relative = MY_MAKE_MUSIC ("RelativeOctaveMusic");
- relative->set_property ("element", music->self_scm ());
-
- Pitch last = music->to_relative_octave (start);
- if (lily_1_8_relative)
- music->set_property ("last-pitch", last.smobbed_copy ());
- return relative;
-}
+%{ // -*-Fundamental-*-
-Music*
-make_lyric_combine_music (SCM name, Music *music)
-{
- Music *combine = MY_MAKE_MUSIC ("NewLyricCombineMusic");
- combine->set_property ("element", music->self_scm ());
- combine->set_property ("associated-context", name);
- return combine;
-}
+/*
+FIXME:
-%}
+ * The rules for who is protecting what are very shady. Uniformise
+ this.
-/* 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
-of the parse stack onto the heap. */
+ * There are too many lexical modes?
+*/
-%left ADDLYRICS
+#include "config.hh"
-%union {
- Book *book;
- Output_def *outputdef;
- SCM scm;
- String *string;
- Music *music;
- Score *score;
- int i;
-}
-%{
+#include <cctype>
+#include <cstdlib>
+#include <cstdio>
+using namespace std;
-int
-yylex (YYSTYPE *s, YYLTYPE *l, void *v)
-{
- Lily_parser *pars = (Lily_parser*) v;
- Lily_lexer *lex = pars->lexer_;
+#include "book.hh"
+#include "context.hh"
+#include "context-def.hh"
+#include "context-mod.hh"
+#include "dimensions.hh"
+#include "file-path.hh"
+#include "input.hh"
+#include "international.hh"
+#include "lily-guile.hh"
+#include "lily-lexer.hh"
+#include "lily-parser.hh"
+#include "ly-module.hh"
+#include "main.hh"
+#include "misc.hh"
+#include "music.hh"
+#include "output-def.hh"
+#include "paper-book.hh"
+#include "scm-hash.hh"
+#include "score.hh"
+#include "text-interface.hh"
+#include "warn.hh"
+#include "lily-imports.hh"
- lex->lexval = (void*) s;
- lex->lexloc = l;
- lex->prepare_for_next_token ();
- return lex->yylex ();
+void
+Lily_parser::parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s)
+{
+ parser->parser_error (*i, s);
}
+// The following are somewhat precarious constructs as they may change
+// the value of the lookahead token. That implies that the lookahead
+// token must not yet have made an impact on the state stack other
+// than causing the reduction of the current rule, or switching the
+// lookahead token while Bison is mulling it over will cause trouble.
+
+#define MYBACKUP(Token, Value, Location) \
+ do { \
+ if (yychar != YYEMPTY) \
+ parser->lexer_->push_extra_token \
+ (yylloc, yychar, yylval); \
+ if (Token) \
+ parser->lexer_->push_extra_token \
+ (Location, Token, Value); \
+ parser->lexer_->push_extra_token (Location, BACKUP); \
+ yychar = YYEMPTY; \
+ } while (0)
+
+
+#define MYREPARSE(Location, Pred, Token, Value) \
+ do { \
+ if (yychar != YYEMPTY) \
+ parser->lexer_->push_extra_token \
+ (yylloc, yychar, yylval); \
+ parser->lexer_->push_extra_token \
+ (Location, Token, Value); \
+ parser->lexer_->push_extra_token \
+ (Location, REPARSE, Pred); \
+ yychar = YYEMPTY; \
+ } while (0)
%}
-%expect 3
-/*
- Three shift/reduce problems:
+%{
-2. \markup identifier.
+#define MY_MAKE_MUSIC(x, spot) \
+ make_music_with_input (ly_symbol2scm (x), \
+ parser->lexer_->override_input (spot))
- (what? --hwn)
+/* ES TODO:
+- delay application of the function
+*/
-3. \markup { }
+#define LOWLEVEL_MAKE_SYNTAX(location, proc, ...) \
+ with_location \
+ (parser->lexer_->override_input (location).smobbed_copy (), \
+ proc, \
+ ##__VA_ARGS__)
- (what? --hwn)
+/* Syntactic Sugar. */
+#define MAKE_SYNTAX(name, location, ...) \
+ LOWLEVEL_MAKE_SYNTAX (location, Syntax::name, ##__VA_ARGS__)
+#define START_MAKE_SYNTAX(name, ...) \
+ scm_list_n (Syntax::name, ##__VA_ARGS__, SCM_UNDEFINED)
-4. \repeat
- \repeat .. \alternative
+#define FINISH_MAKE_SYNTAX(start, location, ...) \
+ LOWLEVEL_MAKE_SYNTAX \
+ (location, \
+ Guile_user::apply, \
+ scm_car (start), \
+ scm_append_x \
+ (scm_list_2 (scm_cdr (start), \
+ scm_list_n (__VA_ARGS__, SCM_UNDEFINED))))
+SCM get_next_unique_context_id ();
+SCM get_next_unique_lyrics_context_id ();
- \repeat { \repeat .. \alternative }
+#undef _
+#if !HAVE_GETTEXT
+#define _(x) x
+#else
+#include <libintl.h>
+#define _(x) gettext (x)
+#endif
-or
- \repeat { \repeat } \alternative
+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 disp = SCM_UNDEFINED);
+SCM make_music_from_simple (Lily_parser *parser, Input loc, SCM pitch);
+SCM loc_on_copy (Lily_parser *parser, Input loc, SCM arg);
+SCM make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list);
+SCM make_chord_step (SCM step, Rational alter);
+SCM make_simple_markup (SCM a);
+SCM make_duration (SCM t, int dots = 0, SCM factor = SCM_UNDEFINED);
+bool is_regular_identifier (SCM id, bool multiple=false);
+SCM make_reverse_key_list (SCM keys);
+SCM try_word_variants (SCM pred, SCM str);
+SCM try_string_variants (SCM pred, SCM str);
+int yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser);
-)
- */
+%}
+/* The third option is an alias that will be used to display the
+ syntax error. Bison CVS now correctly handles backslash escapes.
-%pure_parser
-%locations
+ FIXME: Bison needs to translate some of these, eg, STRING.
+
+*/
+
+/* Keyword tokens with plain escaped name. */
+%token END_OF_FILE 0 "end of input"
+%token ACCEPTS "\\accepts"
+%token ADDLYRICS "\\addlyrics"
+%token ALIAS "\\alias"
+%token ALTERNATIVE "\\alternative"
+%token BOOK "\\book"
+%token BOOKPART "\\bookpart"
+%token CHANGE "\\change"
+%token CHORDMODE "\\chordmode"
+%token CHORDS "\\chords"
+%token CONSISTS "\\consists"
+%token CONTEXT "\\context"
+%token DEFAULT "\\default"
+%token DEFAULTCHILD "\\defaultchild"
+%token DENIES "\\denies"
+%token DESCRIPTION "\\description"
+%token DRUMMODE "\\drummode"
+%token DRUMS "\\drums"
+%token ETC "\\etc"
+%token FIGUREMODE "\\figuremode"
+%token FIGURES "\\figures"
+%token HEADER "\\header"
+%token INVALID "\\version-error"
+%token LAYOUT "\\layout"
+%token LYRICMODE "\\lyricmode"
+%token LYRICS "\\lyrics"
+%token LYRICSTO "\\lyricsto"
+%token MARKUP "\\markup"
+%token MARKUPLIST "\\markuplist"
+%token MIDI "\\midi"
+%token NAME "\\name"
+%token NOTEMODE "\\notemode"
+%token OVERRIDE "\\override"
+%token PAPER "\\paper"
+%token REMOVE "\\remove"
+%token REPEAT "\\repeat"
+%token REST "\\rest"
+%token REVERT "\\revert"
+%token SCORE "\\score"
+%token SCORELINES "\\score-lines"
+%token SEQUENTIAL "\\sequential"
+%token SET "\\set"
+%token SIMULTANEOUS "\\simultaneous"
+%token TEMPO "\\tempo"
+%token TYPE "\\type"
+%token UNSET "\\unset"
+%token WITH "\\with"
+
+/* Keyword token exceptions. */
+%token NEWCONTEXT "\\new"
+
+
+/* Other string tokens. */
+
+%token CHORD_BASS "/+"
+%token CHORD_CARET "^"
+%token CHORD_COLON ":"
+%token CHORD_MINUS "-"
+%token CHORD_SLASH "/"
+%token ANGLE_OPEN "<"
+%token ANGLE_CLOSE ">"
+%token DOUBLE_ANGLE_OPEN "<<"
+%token DOUBLE_ANGLE_CLOSE ">>"
+%token E_BACKSLASH "\\"
+%token E_EXCLAMATION "\\!"
+%token E_PLUS "\\+"
+%token EXTENDER "__"
+
+/*
+If we give names, Bison complains.
+*/
+%token FIGURE_CLOSE /* "\\>" */
+%token FIGURE_OPEN /* "\\<" */
+%token FIGURE_SPACE "_"
+%token HYPHEN "--"
-%token ACCEPTS
-%token ADDQUOTE
-%token LYRICSTO
-%token ALIAS
-%token ALTERNATIVE
-%token BAR
-%token BOOK
-%token CHANGE
-%token CHORDMODIFIERS
-%token CHORDS
-%token CHORDMODE
-%token DOUBLE_ANGLE_OPEN
-%token DOUBLE_ANGLE_CLOSE
-%token CLEF
-%token COMMANDSPANREQUEST
-%token CONSISTS
-%token CONTEXT
-%token DEFAULT
-%token DENIES
-%token DESCRIPTION
-%token EXTENDER
-%token FIGURES
-%token FIGUREMODE
-%token FIGURE_OPEN FIGURE_CLOSE
-%token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
-%token GROBDESCRIPTIONS
-%token HEADER
-%token HYPHEN
-%token INVALID
-%token KEY
-%token LAYOUT
-%token LYRICS
-%token LYRICMODE
-%token MARK
-%token MIDI
%token MULTI_MEASURE_REST
-%token NAME
-%token NEWCONTEXT
-%token NOTEMODE
-%token OBJECTID
-%token OCTAVE
-%token ONCE
-%token OVERRIDE SET REVERT
-%token PAPER
-%token PARTIAL
-%token QUOTE
-%token RELATIVE
-%token REMOVE
-%token REPEAT
-%token REST
-%token SCM_T
-%token SCORE
-%token SEQUENTIAL
-%token ADDLYRICS
-%token SIMULTANEOUS
-%token SKIP
-%token SPANREQUEST
-%token TAG
-%token TEMPO
-%token TIMES
-%token TIME_T
-%token TRANSPOSE
-%token TRANSPOSITION
-%token TYPE
-%token UNSET
-%token WITH
-%token MARKUP
-
-/* escaped */
-/* FIXME: this sucks. The user will get to see these names:
- syntax error, unexpected E_CHAR:
- \
- %%
- */
-
-%token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
-%token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
-%token E_BACKSLASH
-%token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET CHORD_SLASH
-%token FIGURE_SPACE
-
-%token <i> DIGIT
-%token <i> UNSIGNED
-%token <i> E_UNSIGNED
-%token <id> IDENTIFIER
-%token <scm> CHORDMODIFIER_PITCH
-%token <scm> DRUM_PITCH
-%token <scm> DURATION_IDENTIFIER
-%token <scm> EVENT_IDENTIFIER
-%token <scm> MUSIC_IDENTIFIER CONTEXT_DEF_IDENTIFIER
-%token <scm> NOTENAME_PITCH
-%token <scm> NUMBER_IDENTIFIER
-%token <scm> OUTPUT_DEF_IDENTIFIER
-%token <scm> RESTNAME
-%token <scm> LYRICS_STRING
-%token <scm> SCM_T
-%token <scm> SCORE_IDENTIFIER
-%token <scm> STRING
-%token <scm> STRING_IDENTIFIER SCM_IDENTIFIER
-%token <scm> TONICNAME_PITCH
-%token <scm> CHORD_MODIFIER
-%token <scm> FRACTION
-%token <scm> REAL
-%token <scm> MARKUP_HEAD_EMPTY
-%token <scm> MARKUP_HEAD_MARKUP0
-%token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
-%token <scm> MARKUP_HEAD_SCM0
-%token <scm> MARKUP_HEAD_SCM0_MARKUP1
-%token <scm> MARKUP_HEAD_SCM0_SCM1
-%token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
-%token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
-%token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
-%token <scm> MUSIC_FUNCTION
-%token <scm> MUSIC_FUNCTION_MUSIC
-%token <scm> MUSIC_FUNCTION_MUSIC_MUSIC
-%token <scm> MUSIC_FUNCTION_SCM
-%token <scm> MUSIC_FUNCTION_SCM_SCM
-%token <scm> MUSIC_FUNCTION_SCM_MUSIC
-%token <scm> MUSIC_FUNCTION_SCM_MUSIC_MUSIC
-%token <scm> MUSIC_FUNCTION_SCM_SCM_MUSIC
-%token <scm> MUSIC_FUNCTION_MARKUP
-%token <scm> MUSIC_FUNCTION_MARKUP_MARKUP
-%token <scm> MUSIC_FUNCTION_MARKUP_MUSIC
-%token <scm> MUSIC_FUNCTION_MARKUP_MUSIC_MUSIC
-%token <scm> MUSIC_FUNCTION_MARKUP_MARKUP_MUSIC
-
-%token DRUMS
-%token DRUMMODE
-
-
-%type <book> book_block book_body
-%type <i> bare_int bare_unsigned
-%type <i> exclamations questions dots optional_rest
-%type <i> script_dir
-%type <i> sub_quotes sup_quotes
-%type <i> tremolo_type
-%type <i> bass_mod
-
-%type <music> Composite_music Simple_music Prefix_composite_music Generic_prefix_music
-%type <music> Grouped_music_list
-%type <music> Music Sequential_music Simultaneous_music
-%type <music> Repeated_music
-%type <music> command_req
-%type <music> gen_text_def direction_less_event direction_reqd_event
-%type <music> music_property_def context_change
-%type <music> note_chord_element chord_body chord_body_element
-%type <music> post_event tagged_post_event
-%type <music> relative_music re_rhythmed_music
-%type <music> simple_element event_chord command_element
-%type <music> string_number_event
-%type <music> toplevel_music
-%type <music> tempo_event
-
-%type <outputdef> output_def_body output_def_head
-%type <outputdef> output_def paper_block
-
-%type <scm> assignment_id
-%type <scm> Music_list
-%type <scm> chord_body_elements
-%type <scm> chord_item chord_items chord_separator new_chord
-%type <scm> context_def_spec_block context_def_spec_body
-%type <scm> context_mod context_def_mod optional_context_mod
-%type <scm> context_prop_spec
-%type <scm> direction_less_char
-%type <scm> duration_length fraction
-%type <scm> embedded_scm scalar
-%type <scm> identifier_init
-%type <scm> lilypond_header lilypond_header_body
-%type <scm> new_lyrics
-%type <scm> post_events
-%type <scm> property_operation
-%type <scm> script_abbreviation
-%type <scm> simple_string
-%type <scm> steno_pitch pitch absolute_pitch pitch_also_in_chords
-%type <scm> steno_tonic_pitch
-%type <scm> step_number step_numbers
-%type <scm> string bare_number number_expression number_term number_factor
-%type <scm> bass_number br_bass_figure bass_figure figure_list figure_spec
-%type <scm> context_mod_list
-%type <scm> octave_check
-%type <scm> steno_duration optional_notemode_duration multiplied_duration
-%type <scm> Generic_prefix_music_scm
-%type <scm> lyric_element
-%type <scm> Alternative_music
-%type <scm> full_markup markup_list markup_composed_list markup_braced_list markup_braced_list_body
-%type <scm> markup_head_1_item markup_head_1_list markup simple_markup markup_top
-%type <scm> mode_changing_head
-%type <scm> mode_changing_head_with_context
-%type <scm> object_id_setting
-
-%type <score> score_block score_body
+%token E_UNSIGNED
+%token UNSIGNED
+
+/* Artificial tokens, for more generic function syntax */
+%token EXPECT_MARKUP "markup?"
+%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 CHORD_MODIFIER
+%token CHORD_REPETITION
+%token DRUM_PITCH
+ /* Artificial token for durations in argument lists */
+%token DURATION_ARG
+%token DURATION_IDENTIFIER
+%token EVENT_IDENTIFIER
+%token EVENT_FUNCTION
+%token FRACTION
+%token LOOKUP_IDENTIFIER
+%token LYRIC_ELEMENT
+%token MARKUP_FUNCTION
+%token MARKUP_LIST_FUNCTION
+%token MARKUP_IDENTIFIER
+%token MARKUPLIST_IDENTIFIER
+%token MUSIC_FUNCTION
+%token MUSIC_IDENTIFIER
+%token NOTENAME_PITCH
+%token NUMBER_IDENTIFIER
+%token PITCH_IDENTIFIER
+%token REAL
+%token RESTNAME
+%token SCM_ARG
+%token SCM_FUNCTION
+%token SCM_IDENTIFIER
+%token SCM_TOKEN
+%token STRING
+%token SYMBOL_LIST
+%token TONICNAME_PITCH
+%token SYMBOL
+
%left '-' '+'
/* We don't assign precedence to / and *, because we might need varied
%%
-lilypond: /* empty */
+start_symbol:
+ lilypond
+ | EMBEDDED_LILY {
+ parser->lexer_->push_note_state (Lily::pitchnames);
+ } embedded_lilypond {
+ parser->lexer_->pop_state ();
+ *retval = $3;
+ }
+ ;
+
+lilypond: /* empty */ { $$ = SCM_UNSPECIFIED; }
| lilypond toplevel_expression {
}
| lilypond assignment {
}
| lilypond error {
- THIS->error_level_ = 1;
+ parser->error_level_ = 1;
}
| lilypond INVALID {
- THIS->error_level_ = 1;
+ parser->error_level_ = 1;
}
;
-object_id_setting:
- OBJECTID STRING { $$ = $2; }
- ;
-
toplevel_expression:
- lilypond_header {
- THIS->lexer_->set_identifier (ly_symbol2scm ("$globalheader"), $1);
- }
- | add_quote {
-
+ header_block {
+ parser->lexer_->set_identifier (ly_symbol2scm ("$defaultheader"), $1);
}
| book_block {
- Book *book = $1;
- SCM proc = THIS->lexer_->lookup_identifier ("toplevel-book-handler");
- scm_call_2 (proc, THIS->self_scm (), book->self_scm ());
- scm_gc_unprotect_object (book->self_scm ());
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-book-handler");
+ scm_call_1 (proc, $1);
+ }
+ | bookpart_block {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-bookpart-handler");
+ scm_call_1 (proc, $1);
+ }
+ | BOOK_IDENTIFIER {
+ SCM proc = parser->lexer_->lookup_identifier
+ (unsmob<Book>($1)->paper_
+ ? "toplevel-book-handler"
+ : "toplevel-bookpart-handler");
+ scm_call_1 (proc, $1);
}
| score_block {
- Score *score = $1;
-
- SCM proc = THIS->lexer_->lookup_identifier ("toplevel-score-handler");
- scm_call_2 (proc, THIS->self_scm (), score->self_scm ());
- scm_gc_unprotect_object (score->self_scm ());
- }
- | toplevel_music {
- Music *music = $1;
- SCM proc = THIS->lexer_->lookup_identifier ("toplevel-music-handler");
- scm_call_2 (proc, THIS->self_scm (), music->self_scm ());
- scm_gc_unprotect_object (music->self_scm ());
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
+ scm_call_1 (proc, $1);
+ }
+ | composite_music {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-music-handler");
+ scm_call_1 (proc, $1);
+ }
+ | full_markup {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
+ scm_call_1 (proc, scm_list_1 ($1));
+ }
+ | full_markup_list {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
+ scm_call_1 (proc, $1);
+ }
+ | SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($1, @1);
+ }
+ | embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($1))
+ out = scm_list_1 ($1);
+ else if (Text_interface::is_markup_list ($1))
+ out = $1;
+ if (scm_is_pair (out))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
+ scm_call_1 (proc, out);
+ } else if (unsmob<Score> ($1))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
+ scm_call_1 (proc, $1);
+ } else if (Output_def * od = unsmob<Output_def> ($1)) {
+ SCM id = SCM_EOL;
+
+ if (to_boolean (od->c_variable ("is-paper")))
+ id = ly_symbol2scm ("$defaultpaper");
+ else if (to_boolean (od->c_variable ("is-midi")))
+ id = ly_symbol2scm ("$defaultmidi");
+ else if (to_boolean (od->c_variable ("is-layout")))
+ id = ly_symbol2scm ("$defaultlayout");
+
+ parser->lexer_->set_identifier (id, $1);
+ } else if (ly_is_module ($1))
+ {
+ SCM module = get_header (parser);
+ ly_module_copy (module, $1);
+ parser->lexer_->set_identifier
+ (ly_symbol2scm ("$defaultheader"), module);
+ } else if (!scm_is_eq ($1, SCM_UNSPECIFIED))
+ parser->parser_error (@1, _("bad expression type"));
}
| output_def {
SCM id = SCM_EOL;
- Output_def * od = $1;
+ Output_def * od = unsmob<Output_def> ($1);
- if ($1->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if ($1->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if ($1->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
- THIS->lexer_->set_identifier (id, od->self_scm ());
- scm_gc_unprotect_object (od->self_scm ());
+ parser->lexer_->set_identifier (id, $1);
}
;
-toplevel_music:
- Composite_music {
+lookup:
+ LOOKUP_IDENTIFIER
+ | LOOKUP_IDENTIFIER '.' symbol_list_rev
+ {
+ $$ = loc_on_copy (parser, @$,
+ nested_property ($1, scm_reverse_x ($3, SCM_EOL)));
}
;
-embedded_scm:
- SCM_T
+embedded_scm_bare:
+ SCM_TOKEN
+ {
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
+ }
| SCM_IDENTIFIER
;
+embedded_scm_active:
+ SCM_IDENTIFIER
+ | scm_function_call
+ | lookup
+ ;
-lilypond_header_body:
+embedded_scm_bare_arg:
+ SCM_ARG
+ | SCM_TOKEN
+ {
+ $$ = parser->lexer_->eval_scm_token ($1, @1);
+ }
+ | FRACTION
+ | partial_markup
+ | full_markup_list
+ | context_modification
+ | header_block
+ | score_block
+ | context_def_spec_block
+ | book_block
+ | bookpart_block
+ | output_def
+ | lookup
+ ;
+
+/* The generic version may end in music, or not */
+
+embedded_scm:
+ embedded_scm_bare
+ | scm_function_call
+ | lookup
+ ;
+
+/* embedded_scm_arg is _not_ casting pitches to music by default, this
+ * has to be done by the function itself. Note that this may cause
+ * the results of scm_function_call or embedded_scm_bare_arg to be
+ * turned into music from pitches as well. Note that this creates a
+ * distinctly awkward situation for calculated drum pitches. Those
+ * are at the current point of time rejected as music constituents as
+ * they can't be distinguished from "proper" symbols.
+ */
+
+embedded_scm_arg:
+ embedded_scm_bare_arg
+ | scm_function_call
+ | music_assign
+ ;
+
+scm_function_call:
+ SCM_FUNCTION function_arglist {
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
+ }
+ ;
+
+embedded_lilypond_number:
+ '-' embedded_lilypond_number
+ {
+ $$ = scm_difference ($2, SCM_UNDEFINED);
+ }
+ | bare_number_common
+ | UNSIGNED NUMBER_IDENTIFIER
+ {
+ $$ = scm_product ($1, $2);
+ }
+ ;
+
+embedded_lilypond:
+ /* empty */
+ {
+ // FIXME: @$ does not contain a useful source location
+ // for empty rules, and the only token in the whole
+ // production, EMBEDDED_LILY, is synthetic and also
+ // contains no source location.
+ $$ = MAKE_SYNTAX (void_music, @$);
+ }
+ | identifier_init_nonumber
+ | embedded_lilypond_number
+ | post_event post_events
{
- $$ = ly_make_anonymous_module (be_safe_global);
- THIS->lexer_->add_scope ($$);
+ $$ = 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 ();
+ }
+ }
+ | multiplied_duration
+ | 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;
+ $$ = SCM_UNSPECIFIED;
}
+ | INVALID embedded_lilypond {
+ parser->error_level_ = 1;
+ $$ = $2;
+ }
+ ;
+
+
+lilypond_header_body:
+ /* empty */ { $$ = SCM_UNSPECIFIED; }
| lilypond_header_body assignment {
-
+
+ }
+ | lilypond_header_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | lilypond_header_body embedded_scm_active {
+ if (ly_is_module ($2))
+ ly_module_copy (scm_current_module (), $2);
+ else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
}
;
lilypond_header:
HEADER '{' lilypond_header_body '}' {
- $$ = THIS->lexer_->remove_scope ();
+ $$ = parser->lexer_->remove_scope ();
}
;
+header_block:
+ {
+ parser->lexer_->add_scope (get_header (parser));
+ } lilypond_header {
+ $$ = $2;
+ }
+ ;
/*
DECLARATIONS
*/
assignment_id:
- STRING { $$ = $1; }
- | LYRICS_STRING { $$ = $1; }
+ STRING
+ {
+ $$ = scm_string_to_symbol ($1);
+ }
+ | SYMBOL
+ {
+ $$ = scm_string_to_symbol ($1);
+ }
;
assignment:
assignment_id '=' identifier_init {
- if (! is_regular_identifier ($1))
+ parser->lexer_->set_identifier ($1, $3);
+ $$ = SCM_UNSPECIFIED;
+ }
+ | assignment_id '.' property_path '=' identifier_init {
+ SCM path = scm_cons ($1, $3);
+ parser->lexer_->set_identifier (path, $5);
+ $$ = SCM_UNSPECIFIED;
+ }
+ | assignment_id ',' property_path '=' identifier_init {
+ SCM path = scm_cons ($1, $3);
+ parser->lexer_->set_identifier (path, $5);
+ $$ = SCM_UNSPECIFIED;
+ }
+ | markup_mode_word '=' identifier_init
+ {
+ if (scm_is_false (Lily::markup_function_p ($3)))
{
- @1.warning (_ ("Identifier should have alphabetic characters only"));
+ parser->parser_error (@3, _ ("Not a markup function"));
+ } else {
+ scm_primitive_eval
+ (scm_list_3
+ (Lily::define_markup_command,
+ scm_string_to_symbol ($1),
+ ly_quote_scm ($3)));
}
+ $$ = SCM_UNSPECIFIED;
+ }
+ ;
- THIS->lexer_->set_identifier ($1, $3);
-
-/*
- TODO: devise standard for protection in parser.
-
- The parser stack lives on the C-stack, which means that
-all objects can be unprotected as soon as they're here.
-*/
+identifier_init:
+ identifier_init_nonumber
+ | number_expression
+ | symbol_list_part_bare '.' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
+ | symbol_list_part_bare ',' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
+ }
+ | post_event_nofinger post_events
+ {
+ $$ = scm_reverse_x ($2, SCM_EOL);
+ if (Music *m = 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 ();
+ }
}
- | embedded_scm { }
;
+identifier_init_nonumber:
+ header_block
+ | score_block
+ | book_block
+ | bookpart_block
+ | output_def
+ | context_def_spec_block
+ | music_assign
+ | pitch_or_music
+ | FRACTION
+ | string
+ | embedded_scm
+ | partial_markup
+ | full_markup_list
+ | context_modification
+ | partial_function ETC
+ {
+ $$ = MAKE_SYNTAX (partial_music_function, @$,
+ scm_reverse_x ($1, SCM_EOL));
+ }
+ ;
-identifier_init:
- score_block {
- $$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+// Partial functions
+partial_function:
+ MUSIC_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
}
- | output_def {
- $$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ | EVENT_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
}
- | context_def_spec_block {
- $$ = $1;
+ | SCM_FUNCTION function_arglist_partial
+ {
+ $$ = scm_acons ($1, $2, SCM_EOL);
}
- | Music {
- $$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ | OVERRIDE grob_prop_path '='
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_override_function,
+ scm_cdr ($2), scm_car ($2)),
+ SCM_EOL);
}
- | post_event {
- $$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ | SET context_prop_spec '='
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_set_function,
+ scm_cadr ($2), scm_car ($2)),
+ SCM_EOL);
}
- | number_expression {
- $$ = $1;
+ | MUSIC_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
}
- | string {
- $$ = $1;
+ | EVENT_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
}
- | embedded_scm {
- $$ = $1;
+ | SCM_FUNCTION EXPECT_SCM function_arglist_optional partial_function
+ {
+ $$ = scm_acons ($1, $3, $4);
}
- | full_markup {
- $$ = $1;
+ | OVERRIDE grob_prop_path '=' partial_function
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_override_function,
+ scm_cdr ($2), scm_car ($2)),
+ $4);
+ }
+ | SET context_prop_spec '=' partial_function
+ {
+ if (SCM_UNBNDP ($2))
+ $$ = scm_list_1 (SCM_BOOL_F);
+ else
+ $$ = scm_cons
+ (scm_list_3 (Syntax::property_set_function,
+ scm_cadr ($2), scm_car ($2)),
+ $4);
}
- | DIGIT {
- $$ = scm_int2num ($1);
+ | MUSIC_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
+ }
+ | EVENT_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
+ }
+ | SCM_FUNCTION EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup partial_function
+ {
+ $$ = scm_acons ($1, $4, $5);
}
;
context_def_spec_block:
CONTEXT '{' context_def_spec_body '}'
- {
+ {
$$ = $3;
+ Context_def *td = unsmob<Context_def> ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob<Context_def> ($$);
+ }
+ td->origin ()->set_spot (@$);
}
;
-context_def_spec_body:
- /**/ {
- $$ = Context_def::make_scm ();
- unsmob_context_def ($$)->set_spot (@$);
+context_mod_arg:
+ embedded_scm
+ |
+ {
+ parser->lexer_->push_note_state (Lily::pitchnames);
}
- | CONTEXT_DEF_IDENTIFIER {
- $$ = $1;
- unsmob_context_def ($$)->set_spot (@$);
+ composite_music
+ {
+ parser->lexer_->pop_state ();
+ $$ = $2;
}
- | 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:
+ /**/ {
+ $$ = SCM_UNSPECIFIED;
}
| context_def_spec_body context_mod {
- unsmob_context_def ($$)->add_context_mod ($2);
+ if (!SCM_UNBNDP ($2)) {
+ Context_def *td = unsmob<Context_def> ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob<Context_def> ($$);
+ }
+ unsmob<Context_def> ($$)->add_context_mod ($2);
+ }
+ }
+ | context_def_spec_body context_modification {
+ Context_def *td = unsmob<Context_def> ($$);
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob<Context_def> ($$);
+ }
+ SCM new_mods = unsmob<Context_mod> ($2)->get_mods ();
+ for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
+ td->add_context_mod (scm_car (m));
+ }
+ }
+ | context_def_spec_body context_mod_arg {
+ Context_def *td = unsmob<Context_def> ($1);
+ if (scm_is_eq ($2, SCM_UNSPECIFIED))
+ ;
+ else if (!td && unsmob<Context_def> ($2))
+ $$ = $2;
+ else {
+ if (!td) {
+ $$ = Context_def::make_scm ();
+ td = unsmob<Context_def> ($$);
+ }
+ if (unsmob<Music> ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_1 (proc, $2);
+ }
+ if (Context_mod *cm = unsmob<Context_mod> ($2)) {
+ for (SCM m = cm->get_mods (); scm_is_pair (m); m = scm_cdr (m)) {
+ td->add_context_mod (scm_car (m));
+ }
+ } else
+ parser->parser_error (@2, _ ("not a context mod"));
+ }
}
;
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);
}
;
* grok \layout and \midi? */
book_body:
{
- $$ = new Book;
- $$->set_spot (@$);
- $$->paper_ = dynamic_cast<Output_def*> (unsmob_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
- scm_gc_unprotect_object ($$->paper_->self_scm ());
- $$->header_ = THIS->lexer_->lookup_identifier ("$globalheader");
+ Book *book = new Book;
+ init_papers (parser);
+ book->paper_ = dynamic_cast<Output_def*> (unsmob<Output_def> (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
+ book->paper_->unprotect ();
+ push_paper (parser, book->paper_);
+ book->header_ = get_header (parser);
+ $$ = book->unprotect ();
+ parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $$);
+ }
+ | BOOK_IDENTIFIER {
+ parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1);
}
| book_body paper_block {
- $$->paper_ = $2;
- scm_gc_unprotect_object ($2->self_scm ());
+ unsmob<Book> ($1)->paper_ = unsmob<Output_def> ($2);
+ set_paper (parser, unsmob<Output_def> ($2));
+ }
+ | book_body bookpart_block {
+ SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler");
+ scm_call_2 (proc, $1, $2);
}
| book_body score_block {
- Score *score = $2;
- $$->add_score (score);
+ SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
+ scm_call_2 (proc, $1, $2);
}
- | book_body lilypond_header {
- $$->header_ = $2;
+ | book_body composite_music {
+ SCM proc = parser->lexer_->lookup_identifier ("book-music-handler");
+ scm_call_2 (proc, $1, $2);
}
- | book_body error {
- $$->paper_ = 0;
- $$->scores_.clear();
+ | book_body full_markup {
+ SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
+ scm_call_2 (proc, $1, scm_list_1 ($2));
+ }
+ | book_body full_markup_list {
+ SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
+ scm_call_2 (proc, $1, $2);
}
- | book_body object_id_setting {
- $$->user_key_ = ly_scm2string ($2);
+ | book_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | book_body embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($2))
+ out = scm_list_1 ($2);
+ else if (Text_interface::is_markup_list ($2))
+ out = $2;
+ if (scm_is_pair (out))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
+ scm_call_2 (proc, $1, out);
+ } else if (unsmob<Score> ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
+ scm_call_2 (proc, $1, $2);
+ } else if (Output_def *od = unsmob<Output_def> ($2)) {
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper")))) {
+ unsmob<Book> ($1)->paper_ = od;
+ set_paper (parser, od);
+ } else {
+ parser->parser_error (@2, _ ("need \\paper for paper block"));
+ }
+ } else if (ly_is_module ($2))
+ {
+ ly_module_copy (unsmob<Book> ($1)->header_, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ }
+ | book_body
+ {
+ parser->lexer_->add_scope (unsmob<Book> ($1)->header_);
+ } lilypond_header
+ | book_body error {
+ Book *book = unsmob<Book> ($1);
+ book->paper_ = 0;
+ book->scores_ = SCM_EOL;
+ book->bookparts_ = SCM_EOL;
}
;
-score_block:
- SCORE '{' score_body '}' {
+bookpart_block:
+ BOOKPART '{' bookpart_body '}' {
$$ = $3;
+ unsmob<Book> ($$)->origin ()->set_spot (@$);
+ parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
}
;
-score_body:
- /**/ {
- $$ = new Score;
- $$->set_spot (@$);
+bookpart_body:
+ {
+ Book *book = new Book;
+ $$ = book->unprotect ();
+ parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $$);
+ }
+ | BOOK_IDENTIFIER {
+ parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1);
}
- | SCORE_IDENTIFIER {
- $$ = new Score ( *unsmob_score ($1));
- $$->set_spot (@$);
+ | bookpart_body paper_block {
+ unsmob<Book> ($$)->paper_ = unsmob<Output_def> ($2);
}
- | score_body object_id_setting {
- $$->user_key_ = ly_scm2string ($2);
+ | bookpart_body score_block {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
+ scm_call_2 (proc, $1, $2);
}
- | score_body Music {
- SCM m = $2->self_scm ();
- scm_gc_unprotect_object (m);
- $$->set_music (m, THIS->self_scm ());
+ | bookpart_body composite_music {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-music-handler");
+ scm_call_2 (proc, $1, $2);
}
- | score_body lilypond_header {
- $$->header_ = $2;
+ | bookpart_body full_markup {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
+ scm_call_2 (proc, $1, scm_list_1 ($2));
}
- | score_body output_def {
- if ($2->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+ | bookpart_body full_markup_list {
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
+ scm_call_2 (proc, $1, $2);
+ }
+ | bookpart_body SCM_TOKEN {
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | bookpart_body embedded_scm_active
+ {
+ SCM out = SCM_UNDEFINED;
+ if (Text_interface::is_markup ($2))
+ out = scm_list_1 ($2);
+ else if (Text_interface::is_markup_list ($2))
+ out = $2;
+ if (scm_is_pair (out))
{
- THIS->parser_error (@2, _("\\paper cannot be in \\score. Use \\layout instead"));
-
- }
- else
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
+ scm_call_2 (proc, $1, out);
+ } else if (unsmob<Score> ($2))
{
- $$->defs_.push ($2);
+ SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
+ scm_call_2 (proc, $1, $2);
+ } else if (Output_def *od = unsmob<Output_def> ($2)) {
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper")))) {
+ unsmob<Book> ($1)->paper_ = od;
+ } else {
+ parser->parser_error (@2, _ ("need \\paper for paper block"));
+ }
+ } else if (ly_is_module ($2)) {
+ Book *book = unsmob<Book> ($1);
+ if (!ly_is_module (book->header_))
+ book->header_ = ly_make_module (false);
+ ly_module_copy (book->header_, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ }
+ | bookpart_body
+ {
+ Book *book = unsmob<Book> ($1);
+ if (!ly_is_module (book->header_))
+ book->header_ = ly_make_module (false);
+ parser->lexer_->add_scope (book->header_);
+ } lilypond_header
+ | bookpart_body error {
+ Book *book = unsmob<Book> ($1);
+ book->paper_ = 0;
+ book->scores_ = SCM_EOL;
+ }
+ ;
+
+score_block:
+ SCORE '{' score_body '}' {
+ unsmob<Score> ($3)->origin ()->set_spot (@$);
+ $$ = $3;
+ }
+ ;
+
+score_body:
+ score_items {
+ if (!unsmob<Score> ($1)) {
+ parser->parser_error (@1, _("Missing music in \\score"));
+ $$ = (new Score)->unprotect ();
+ if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
+ {
+ unsmob<Score> ($$)->set_header (scm_car ($1));
+ $1 = scm_cdr ($1);
+ }
+ for (SCM p = scm_reverse_x ($1, SCM_EOL);
+ scm_is_pair (p); p = scm_cdr (p))
+ {
+ unsmob<Score> ($$)->
+ add_output_def (unsmob<Output_def> (scm_car (p)));
+ }
}
- scm_gc_unprotect_object ($2->self_scm ());
}
| score_body error {
- $$->error_found_ = true;
+ unsmob<Score> ($$)->error_found_ = true;
+ }
+ ;
+
+score_item:
+ embedded_scm
+ | music
+ | output_def
+ ;
+
+score_items:
+ /* empty */
+ {
+ $$ = SCM_EOL;
+ }
+ | score_items score_item
+ {
+ Output_def *od = unsmob<Output_def> ($2);
+ if (od) {
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
+ {
+ parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
+ od = 0;
+ $2 = SCM_UNSPECIFIED;
+ }
+ } else if (!unsmob<Score> ($$)) {
+ if (unsmob<Music> ($2)) {
+ $2 = Lily::scorify_music ($2);
+ }
+ if (unsmob<Score> ($2))
+ {
+ $$ = $2;
+ $2 = SCM_UNSPECIFIED;
+ }
+ }
+ Score *score = unsmob<Score> ($$);
+ if (score && scm_is_pair ($1)) {
+ if (ly_is_module (scm_car ($1)))
+ {
+ score->set_header (scm_car ($1));
+ $1 = scm_cdr ($1);
+ }
+ for (SCM p = scm_reverse_x ($1, SCM_EOL);
+ scm_is_pair (p); p = scm_cdr (p))
+ {
+ score->add_output_def (unsmob<Output_def> (scm_car (p)));
+ }
+ }
+ if (od) {
+ if (score)
+ score->add_output_def (od);
+ else if (scm_is_pair ($$) && ly_is_module (scm_car ($$)))
+ scm_set_cdr_x ($$, scm_cons ($2, scm_cdr ($$)));
+ else
+ $$ = scm_cons ($2, $$);
+ } else if (ly_is_module ($2)) {
+ SCM module = SCM_UNSPECIFIED;
+ if (score) {
+ module = score->get_header ();
+ if (!ly_is_module (module))
+ {
+ module = ly_make_module (false);
+ score->set_header (module);
+ }
+ } else if (scm_is_pair ($$) && ly_is_module (scm_car ($$)))
+ module = scm_car ($$);
+ else {
+ module = ly_make_module (false);
+ $$ = scm_cons (module, $$);
+ }
+ ly_module_copy (module, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("Spurious expression in \\score"));
+ }
+ | score_items
+ {
+ if (Score *score = unsmob<Score> ($1)) {
+ if (!ly_is_module (score->get_header ()))
+ score->set_header (ly_make_module (false));
+ parser->lexer_->add_scope (score->get_header ());
+ } else {
+ if (!scm_is_pair ($1) || !ly_is_module (scm_car ($1)))
+ $1 = scm_cons (ly_make_module (false), $1);
+ parser->lexer_->add_scope (scm_car ($1));
+ }
+ } lilypond_header
+ {
+ $$ = $1;
}
;
paper_block:
output_def {
- $$ = $1;
- if ($$->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T)
+ Output_def *od = unsmob<Output_def> ($1);
+
+ if (!to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
- THIS->parser_error (@1, _("Need \\paper for paper block."));
- $$ = get_paper (THIS);
+ parser->parser_error (@1, _ ("need \\paper for paper block"));
+ $$ = get_paper (parser)->unprotect ();
}
}
;
output_def:
output_def_body '}' {
- $$ = $1;
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
- THIS->lexer_->remove_scope ();
- THIS->lexer_->pop_state ();
+ parser->lexer_->remove_scope ();
+ parser->lexer_->pop_state ();
}
;
output_def_head:
PAPER {
- $$ = get_paper (THIS);
- $$->input_origin_ = @$;
- THIS->lexer_->add_scope ($$->scope_);
+ Output_def *p = get_paper (parser);
+ p->input_origin_ = @$;
+ parser->lexer_->add_scope (p->scope_);
+ $$ = p->unprotect ();
}
| MIDI {
- Output_def *p = get_midi (THIS);
- $$ = p;
- THIS->lexer_->add_scope (p->scope_);
+ Output_def *p = get_midi (parser);
+ $$ = p->unprotect ();
+ parser->lexer_->add_scope (p->scope_);
+ }
+ | LAYOUT {
+ Output_def *p = get_layout (parser);
+
+ parser->lexer_->add_scope (p->scope_);
+ $$ = p->unprotect ();
+ }
+ ;
+
+output_def_head_with_mode_switch:
+ output_def_head {
+ 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_assign
+ | context_def_spec_block
+ ;
+
+output_def_body:
+ output_def_head_with_mode_switch '{' {
+ unsmob<Output_def> ($1)->input_origin_.set_spot (@$);
+ // This is a stupid trick to mark the beginning of the
+ // body for deciding whether to allow
+ // embedded_scm_active to have an output definition
+ $$ = scm_list_1 ($1);
+ }
+ | output_def_body assignment {
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
+ }
+ | output_def_body embedded_scm_active
+ {
+ // We don't switch into note mode for Scheme functions
+ // here. Does not seem warranted/required in output
+ // definitions.
+ if (scm_is_pair ($1))
+ {
+ Output_def *o = unsmob<Output_def> ($2);
+ if (o) {
+ o->input_origin_.set_spot (@$);
+ $1 = o->self_scm ();
+ parser->lexer_->remove_scope ();
+ parser->lexer_->add_scope (o->scope_);
+ $2 = SCM_UNSPECIFIED;
+ } else
+ $1 = scm_car ($1);
+ }
+ if (unsmob<Context_def> ($2))
+ assign_context_def (unsmob<Output_def> ($1), $2);
+ // Seems unlikely, but let's be complete:
+ else if (unsmob<Music> ($2))
+ {
+ SCM proc = parser->lexer_->lookup_identifier
+ ("output-def-music-handler");
+ scm_call_2 (proc, $1, $2);
+ } else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _("bad expression type"));
+ $$ = $1;
+ }
+ | output_def_body SCM_TOKEN {
+ if (scm_is_pair ($1))
+ $$ = scm_car ($1);
+ // Evaluate and ignore #xxx, as opposed to \xxx
+ parser->lexer_->eval_scm_token ($2, @2);
+ }
+ | output_def_body
+ {
+ if (scm_is_pair ($1))
+ $1 = scm_car ($1);
+ parser->lexer_->push_note_state (Lily::pitchnames);
+ } music_or_context_def
+ {
+ parser->lexer_->pop_state ();
+ if (unsmob<Context_def> ($3))
+ assign_context_def (unsmob<Output_def> ($1), $3);
+ else {
+
+ SCM proc = parser->lexer_->lookup_identifier
+ ("output-def-music-handler");
+ scm_call_2 (proc, $1, $3);
+ }
+ $$ = $1;
+ }
+ | output_def_body error {
+
+ }
+ ;
+
+tempo_event:
+ TEMPO steno_duration '=' tempo_range {
+ $$ = MAKE_SYNTAX (tempo, @$, SCM_EOL, $2, $4);
+ }
+ | TEMPO text steno_duration '=' tempo_range {
+ $$ = MAKE_SYNTAX (tempo, @$, $2, $3, $5);
+ }
+ | TEMPO text {
+ $$ = MAKE_SYNTAX (tempo, @$, $2);
+ } %prec ':'
+ ;
+
+/*
+The representation of a list is reversed to have efficient append. */
+
+music_list:
+ /* empty */ {
+ $$ = SCM_EOL;
+ }
+ | 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_cons (m->self_scm (), $1);
+ m->unprotect (); /* UGH */
+ }
+ ;
+
+braced_music_list:
+ '{' music_list '}'
+ {
+ $$ = scm_reverse_x ($2, SCM_EOL);
+ }
+ ;
+
+music: music_assign
+ | lyric_element_music
+ | pitch_as_music
+ ;
+
+pitch_as_music:
+ pitch_or_music
+ {
+ $$ = make_music_from_simple (parser, @1, $1);
+ if (!unsmob<Music> ($$))
+ {
+ parser->parser_error (@1, _ ("music expected"));
+ $$ = MAKE_SYNTAX (void_music, @$);
+ }
+ }
+ ;
+
+music_embedded:
+ music
+ {
+ 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;
+ }
+ | multiplied_duration post_events
+ {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
+
+ parser->default_duration_ = *unsmob<Duration> ($1);
+ n->set_property ("duration", $1);
+
+ if (scm_is_pair ($2))
+ n->set_property ("articulations",
+ scm_reverse_x ($2, SCM_EOL));
+ $$ = n->unprotect ();
+ }
+ ;
+
+music_embedded_backup:
+ embedded_scm
+ {
+ if (scm_is_eq ($1, SCM_UNSPECIFIED))
+ $$ = $1;
+ 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"));
+ $$ = $1;
+ }
+ }
+ ;
+
+// music_assign does not need to contain lyrics: there are no
+// assignments in lyricmode.
+music_assign:
+ simple_music
+ | composite_music %prec COMPOSITE
+ ;
+
+repeated_music:
+ REPEAT simple_string unsigned_number music
+ {
+ $$ = 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 braced_music_list {
+ $$ = MAKE_SYNTAX (sequential_music, @$, $2);
+ }
+ | braced_music_list {
+ $$ = MAKE_SYNTAX (sequential_music, @$, $1);
+ }
+ ;
+
+simultaneous_music:
+ SIMULTANEOUS braced_music_list {
+ $$ = MAKE_SYNTAX (simultaneous_music, @$, $2);
+ }
+ | DOUBLE_ANGLE_OPEN music_list DOUBLE_ANGLE_CLOSE {
+ $$ = MAKE_SYNTAX (simultaneous_music, @$, scm_reverse_x ($2, SCM_EOL));
+ }
+ ;
+
+simple_music:
+ event_chord
+ | music_property_def
+ | context_change
+ ;
+
+context_modification:
+ WITH
+ {
+ parser->lexer_->push_note_state (Lily::pitchnames);
+ } '{' context_mod_list '}'
+ {
+ parser->lexer_->pop_state ();
+ $$ = $4;
+ }
+ | WITH context_modification_arg
+ {
+ if (unsmob<Music> ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_1 (proc, $2);
+ }
+ if (unsmob<Context_mod> ($2))
+ $$ = $2;
+ else {
+ // let's permit \with #*unspecified* to go for
+ // an empty context mod
+ if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _ ("not a context mod"));
+ $$ = Context_mod ().smobbed_copy ();
+ }
+ }
+ ;
+
+context_modification_arg:
+ embedded_scm
+ | MUSIC_IDENTIFIER
+ ;
+
+/* A list of single mods collected from a (possibly empty) sequence of
+ * context modifications, usually written as \with ... \with ...
+ */
+
+optional_context_mods:
+ context_modification_mods_list
+ {
+ if (scm_is_pair ($1))
+ $$ = scm_append_x (scm_reverse_x ($1, SCM_EOL));
+ }
+ ;
+
+/* The worker for optional_context_mods conses a (reversed) list where
+ * each element contains the list of single context mods from one
+ * context modification block. Context_mod::get_mods creates fresh
+ * copies, so it's okay to use append! on them.
+ */
+
+context_modification_mods_list:
+ /**/ {
+ $$ = SCM_EOL;
+ }
+ | context_modification_mods_list context_modification
+ {
+ if (Context_mod *m = unsmob<Context_mod> ($2))
+ $$ = scm_cons (m->get_mods (), $1);
+ }
+ ;
+
+/* A Context_mod is a container for a list of context mods like
+ * \consists ... \override ... . context_mod_list produces a
+ * Context_mod from the inside of a \with { ... } statement.
+ */
+
+context_mod_list:
+ /**/ {
+ $$ = Context_mod ().smobbed_copy ();
+ }
+ | context_mod_list context_mod {
+ if (!SCM_UNBNDP ($2))
+ unsmob<Context_mod> ($1)->add_context_mod ($2);
+ }
+ | context_mod_list context_mod_arg {
+ if (unsmob<Music> ($2)) {
+ SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
+ $2 = scm_call_1 (proc, $2);
+ }
+ if (unsmob<Context_mod> ($2))
+ unsmob<Context_mod> ($$)->add_context_mods
+ (unsmob<Context_mod> ($2)->get_mods ());
+ else if (!scm_is_eq ($2, SCM_UNSPECIFIED))
+ parser->parser_error (@2, _ ("not a context mod"));
+ }
+ ;
+
+context_prefix:
+ CONTEXT symbol optional_id optional_context_mods {
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, $4, SCM_BOOL_F);
+ }
+ | NEWCONTEXT symbol optional_id optional_context_mods {
+ $$ = START_MAKE_SYNTAX (context_specification, $2, $3, $4, SCM_BOOL_T);
+ }
+ ;
+
+new_lyrics:
+ ADDLYRICS optional_context_mods lyric_mode_music {
+ $$ = scm_acons ($3, $2, SCM_EOL);
+ }
+ | new_lyrics ADDLYRICS optional_context_mods lyric_mode_music {
+ $$ = scm_acons ($4, $3, $1);
+ }
+ ;
+
+/* basic_music is basically the same as composite_music but with
+ * context-prefixed music and lyricized music explicitly removed. The
+ * reason is that in a sequence
+ *
+ * \new Staff \new Voice { ... } \addlyrics { ... } \addlyrics { ... }
+ *
+ * we need to group both \addlyrics together (as they go with the same
+ * voice) but then combine them with \new Voice { ... }, meaning that
+ * combining \new Voice { ... } needs higher priority than
+ * { ... } \addlyrics, and *not* have \new Staff \new Voice { ... }
+ * combine before combining \new Voice { ... } \addlyrics: only one
+ * layer of context-prefixed music should assemble before \addlyrics
+ * is integrated. Total mess, and we sort this mess out with explicit
+ * rules preferring a single context-prefix.
+ */
+
+basic_music:
+ music_function_call
+ | repeated_music
+ | music_bare
+ | LYRICSTO simple_string lyric_mode_music {
+ $$ = MAKE_SYNTAX (lyric_combine, @$, $2, SCM_EOL, $3);
+ }
+ | LYRICSTO symbol '=' simple_string lyric_mode_music
+ {
+ $$ = MAKE_SYNTAX (lyric_combine, @$, $4, $2, $5);
+ }
+ ;
+
+contextable_music:
+ basic_music
+ | pitch_as_music
+ | event_chord
+ ;
+
+contexted_basic_music:
+ context_prefix contextable_music new_lyrics
+ {
+ Input i;
+ i.set_location (@1, @2);
+ $$ = FINISH_MAKE_SYNTAX ($1, i, $2);
+ $$ = MAKE_SYNTAX (add_lyrics, @$, $$, scm_reverse_x ($3, SCM_EOL));
+ } %prec COMPOSITE
+ | context_prefix contextable_music
+ {
+ $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
+ } %prec COMPOSITE
+ | context_prefix contexted_basic_music
+ {
+ $$ = FINISH_MAKE_SYNTAX ($1, @$, $2);
+ }
+ ;
+
+composite_music:
+ basic_music %prec COMPOSITE
+ | contexted_basic_music
+ | basic_music new_lyrics
+ {
+ $$ = MAKE_SYNTAX (add_lyrics, @$, $1, scm_reverse_x ($2, SCM_EOL));
+ } %prec COMPOSITE
+ ;
+
+music_bare:
+ mode_changed_music
+ | MUSIC_IDENTIFIER
+ | grouped_music_list
+ ;
+
+grouped_music_list:
+ simultaneous_music { $$ = $1; }
+ | sequential_music { $$ = $1; }
+ ;
+
+/* Function argument lists are arguably the most complex part in the
+ * parser. They are pretty tricky to understand because of the way
+ * they are processed, and because of optional arguments that can be
+ * omitted. When there are several optional arguments in a row,
+ * omitting one automatically omits all following arguments. Optional
+ * arguments can only be omitted when either
+ *
+ * a) the omission is explicitly started with \default
+ * b) the omission is implicitly started by an argument not matching
+ * its predicate, and there is a mandatory argument later that can
+ * "catch" the argument that does not fit.
+ *
+ * When argument parsing starts, the lexer pushes EXPECT_SCM tokens
+ * (corresponding to mandatory arguments and having a predicate
+ * function as semantic value) or EXPECT_OPTIONAL EXPECT_SCM (where
+ * the semantic value of the EXPECT_OPTIONAL token is the default to
+ * use when the optional argument is omitted, and EXPECT_SCM again has
+ * the argument predicate as semantic value) in reverse order to the
+ * parser, followed by EXPECT_NO_MORE_ARGS. The argument list is then
+ * processed inside-out while actual tokens are consumed.
+ *
+ * This means that the argument list tokens determine the actions
+ * taken as they arrive. The structure of the argument list is known
+ * to the parser and stored in its parse stack when the first argument
+ * is being parsed. What the parser does not know is which predicates
+ * will match and whether or not \default will be appearing in the
+ * argument list, and where.
+ *
+ * Sequences of 0 or more optional arguments are scanned using either
+ * function_arglist_backup or function_arglist_nonbackup. The first
+ * is used when optional arguments are followed by at least one
+ * mandatory argument: in that case optional arguments may be skipped
+ * by either a false predicate (in which case the expression will be
+ * pushed back as one or more tokens, preceded by a BACKUP token) or
+ * by using \default.
+ *
+ * If optional arguments are at the end of the argument list, they are
+ * instead scanned using function_arglist_nonbackup: here the only
+ * manner to enter into skipping of optional arguments is the use of
+ * \default.
+ *
+ * The argument list of a normal function call is parsed using
+ * function_arglist. The part of an argument list before a mandatory
+ * argument is parsed using function_arglist_optional.
+ *
+ * The difference is that leading optional arguments are scanned using
+ * function_arglist_nonbackup and function_arglist_backup,
+ * respectively.
+ *
+ * Most other details are obvious in the rules themselves.
+ *
+ */
+
+symbol_list_arg:
+ SYMBOL_LIST
+ | SYMBOL_LIST '.' symbol_list_rev
+ {
+ $$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
+ }
+ | SYMBOL_LIST ',' symbol_list_rev
+ {
+ $$ = scm_append (scm_list_2 ($1, scm_reverse_x ($3, SCM_EOL)));
+ }
+ ;
+
+symbol_list_rev:
+ symbol_list_part
+ | symbol_list_rev '.' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($3, $1));
+ }
+ | symbol_list_rev ',' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($3, $1));
+ }
+ ;
+
+// symbol_list_part delivers elements in reverse copy, no lookahead
+
+symbol_list_part:
+ symbol_list_part_bare
+ | embedded_scm_bare
+ {
+ $$ = make_reverse_key_list ($1);
+ if (SCM_UNBNDP ($$)) {
+ parser->parser_error (@1, _("not a key"));
+ $$ = SCM_EOL;
+ }
+ }
+ ;
+
+
+symbol_list_element:
+ STRING
+ {
+ $$ = scm_string_to_symbol ($1);
+ }
+ | UNSIGNED
+ ;
+
+
+symbol_list_part_bare:
+ SYMBOL
+ {
+ $$ = try_word_variants (Lily::key_list_p, $1);
+ if (SCM_UNBNDP ($$)) {
+ parser->parser_error (@1, _("not a key"));
+ $$ = SCM_EOL;
+ } else
+ $$ = scm_reverse ($$);
+ }
+ | symbol_list_element
+ {
+ $$ = scm_list_1 ($1);
+ }
+ ;
+
+function_arglist_nonbackup:
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
+ {
+ $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' 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);
+ $$ = check_scheme_arg (parser, @4, t->unprotect (),
+ $3, $2, n);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
+ {
+ $$ = check_scheme_arg (parser, @4,
+ scm_difference ($5, SCM_UNDEFINED),
+ $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
+ {
+ $$ = check_scheme_arg (parser, @4,
+ scm_difference ($5, SCM_UNDEFINED),
+ $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else
+ $$ = check_scheme_arg (parser, @4,
+ make_music_from_simple
+ (parser, @4, $4),
+ $3, $2);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
+ {
+ $$ = check_scheme_arg (parser, @4, $4, $3, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE pitch_or_music
+ {
+ if (scm_is_true (scm_call_1 ($2, $3)))
+ $$ = scm_cons ($3, $1);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE reparsed_rhythm
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE bare_number_common
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE SCM_ARG
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE lyric_element_music
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ | function_arglist_nonbackup_reparse REPARSE symbol_list_arg
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
+ }
+ ;
+
+
+reparsed_rhythm:
+ DURATION_ARG dots multipliers post_events
+ {
+ $$ = make_music_from_simple (parser, @$,
+ make_duration ($1, scm_to_int ($2), $3));
+ Music *m = unsmob<Music> ($$);
+ assert (m);
+ if (scm_is_pair ($4))
+ m->set_property ("articulations",
+ scm_reverse_x ($4, SCM_EOL));
+ } %prec ':'
+ ;
+
+function_arglist_nonbackup_reparse:
+ EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SCM_IDENTIFIER
+ {
+ $$ = $3;
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup pitch
+ {
+ $$ = $3;
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup steno_tonic_pitch
+ {
+ $$ = $3;
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup STRING
+ {
+ $$ = $3;
+ SCM res = try_string_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup SYMBOL
+ {
+ $$ = $3;
+ SCM res = try_word_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup full_markup
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ MYREPARSE (@4, $2, STRING, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4);
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup UNSIGNED
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ // May be 3 \cm or similar
+ MYREPARSE (@4, $2, REAL, $4);
+ else if (scm_is_true (scm_call_1 ($2, scm_list_1 ($4))))
+ MYREPARSE (@4, $2, SYMBOL_LIST, scm_list_1 ($4));
+ else {
+ SCM d = make_duration ($4);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($2, d)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, d))))
+ MYREPARSE (@4, $2, DURATION_ARG, d);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
+ } else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup DURATION_IDENTIFIER
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, $4))))
+ MYREPARSE (@4, $2, DURATION_ARG, $4);
+ else
+ MYREPARSE (@4, $2, SCM_ARG, $4); // trigger error
+ }
+ ;
+
+
+// function_arglist_backup can't occur at the end of an argument
+// list.
+function_arglist_backup:
+ function_arglist_common
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup embedded_scm_arg
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
+ $$ = make_music_from_simple (parser, @4, $4);
+ if (scm_is_true (scm_call_1 ($2, $$)))
+ $$ = scm_cons ($$, $3);
+ else
+ {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (SCM_ARG, $4, @4);
+ }
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup post_event_nofinger
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ $$ = scm_cons ($4, $3);
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (EVENT_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup pitch
+ {
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ {
+ $$ = $3;
+ MYREPARSE (@4, $2, PITCH_IDENTIFIER, $4);
+ } else if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (PITCH_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup steno_tonic_pitch
+ {
+ if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple
+ (parser, @4, $4))))
+ {
+ $$ = $3;
+ MYREPARSE (@4, $2, TONICNAME_PITCH, $4);
+ } else if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (TONICNAME_PITCH, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup full_markup
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ $$ = scm_cons ($4, $3);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (SCM_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup UNSIGNED
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ // May be 3 \cm or similar
+ MYREPARSE (@4, $2, REAL, $4);
+ else if (scm_is_true (scm_call_1 ($2, scm_list_1 ($4))))
+ MYREPARSE (@4, $2, SYMBOL_LIST, scm_list_1 ($4));
+ else {
+ SCM d = make_duration ($4);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($2, d)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, d))))
+ MYREPARSE (@4, $2, DURATION_ARG, d);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (UNSIGNED, $4, @4);
+ }
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (UNSIGNED, $4, @4);
+ }
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup REAL
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ $$ = $3;
+ MYREPARSE (@4, $2, REAL, $4);
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (REAL, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup NUMBER_IDENTIFIER
+ {
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ {
+ $$ = scm_cons ($4, $3);
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (NUMBER_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' 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_copy (parser, @3, $1), $3);
+ MYBACKUP (UNSIGNED, $5, @5);
+ parser->lexer_->push_extra_token (@4, '-');
+ }
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' REAL
+ {
+ SCM n = scm_difference ($5, SCM_UNDEFINED);
+ if (scm_is_true (scm_call_1 ($2, n))) {
+ MYREPARSE (@5, $2, REAL, n);
+ $$ = $3;
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (REAL, n, @5);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup '-' NUMBER_IDENTIFIER
+ {
+ SCM n = scm_difference ($5, SCM_UNDEFINED);
+ if (scm_is_true (scm_call_1 ($2, n))) {
+ $$ = scm_cons (n, $3);
+ } else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (NUMBER_IDENTIFIER, n, @5);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup DURATION_IDENTIFIER
+ {
+ $$ = $3;
+ if (scm_is_true (scm_call_1 ($2, $4)))
+ MYREPARSE (@4, $2, DURATION_IDENTIFIER, $4);
+ else if (scm_is_true
+ (scm_call_1
+ ($2, make_music_from_simple (parser, @4, $4))))
+ MYREPARSE (@4, $2, DURATION_ARG, $4);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (DURATION_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup 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_copy (parser, @3, $1), $3);
+ MYBACKUP (SCM_IDENTIFIER, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup 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_copy (parser, @3, $1), $3);
+ MYBACKUP (STRING, $4, @4);
+ }
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup SYMBOL
+ {
+ SCM res = try_word_variants ($2, $4);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res)) {
+ $$ = $3;
+ MYREPARSE (@4, $2, SYMBOL_LIST, res);
+ }
+ else
+ $$ = scm_cons (res, $3);
+ else {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
+ MYBACKUP (STRING, $4, @4);
+ }
}
- | LAYOUT {
- Output_def *p = get_layout (THIS);
-
- THIS->lexer_->add_scope (p->scope_);
- $$ = p;
+ | function_arglist_backup REPARSE pitch_or_music
+ {
+ if (scm_is_true (scm_call_1 ($2, $3)))
+ $$ = scm_cons ($3, $1);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $1, $2);
}
- ;
-
-
-output_def_body:
- output_def_head '{' {
- $$ = $1;
- $$->input_origin_.set_spot (@$);
- THIS->lexer_->push_initial_state ();
- }
- | output_def_head '{' OUTPUT_DEF_IDENTIFIER {
- scm_gc_unprotect_object ($1->self_scm ());
- Output_def *o = unsmob_output_def ($3);
- o->input_origin_.set_spot (@$);
- $$ = o;
- THIS->lexer_->remove_scope ();
- THIS->lexer_->add_scope (o->scope_);
- THIS->lexer_->push_initial_state ();
+ | function_arglist_backup REPARSE bare_number_common
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | output_def_body assignment {
-
+ | function_arglist_backup REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | output_def_body context_def_spec_block {
- assign_context_def ($$, $2);
+ | function_arglist_backup REPARSE reparsed_rhythm
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | output_def_body tempo_event {
- /*
- junk this ? there already is tempo stuff in
- music.
- */
- int m = scm_to_int ($2->get_property ("metronome-count"));
- Duration *d = unsmob_duration ($2->get_property ("tempo-unit"));
- set_tempo ($$, d->get_length (), m);
- scm_gc_unprotect_object ($2->self_scm ());
+ | function_arglist_backup REPARSE symbol_list_arg
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
}
- | output_def_body error {
+ ;
+function_arglist:
+ function_arglist_nonbackup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
+ {
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
;
-tempo_event:
- TEMPO steno_duration '=' bare_unsigned {
- $$ = MY_MAKE_MUSIC ("MetronomeChangeEvent");
- $$->set_property ("tempo-unit", $2);
- $$->set_property ("metronome-count", scm_int2num ( $4));
+function_arglist_skip_nonbackup:
+ function_arglist_nonbackup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup
+ {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
}
;
-/*
-The representation of a list is the
-
- (LIST . LAST-CONS)
-
- to have efficient append. */
-
-Music_list:
- /* empty */ {
- $$ = scm_cons (SCM_EOL, SCM_EOL);
+// Partial function arglists are returned just in their incomplete
+// state: when combined with the music function, the missing parts of
+// the signature can be reconstructed
+//
+// To serve as a partial arglist, the argument list must absolutely
+// _not_ be in "skipping optional arguments" mode since then there is
+// some backup token that has nowhere to go before \etc.
+//
+// So we can skim off an arbitrary number of arguments from the end of
+// the argument list. The argument list remaining afterwards has to
+// be in not-skipping-optional-arguments mode.
+
+function_arglist_partial:
+ EXPECT_SCM function_arglist_optional
+ {
+ $$ = $2;
}
- | Music_list Music {
- SCM s = $$;
- SCM c = scm_cons ($2->self_scm (), SCM_EOL);
- scm_gc_unprotect_object ($2->self_scm ()); /* 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 */
+ | EXPECT_SCM function_arglist_partial_optional
+ {
+ $$ = $2;
}
- | Music_list embedded_scm {
-
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup
+ {
+ $$ = $3;
}
- | 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_gc_unprotect_object (m->self_scm ()); /* 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 */
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_partial
+ {
+ $$ = $3;
}
;
-Music:
- Simple_music
- | Composite_music
- ;
-
-Alternative_music:
- /* empty */ {
- $$ = SCM_EOL;
+function_arglist_partial_optional:
+ EXPECT_SCM function_arglist_optional
+ {
+ $$ = $2;
}
- | ALTERNATIVE '{' Music_list '}' {
+ | EXPECT_SCM function_arglist_partial_optional
+ {
+ $$ = $2;
+ }
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_backup
+ {
$$ = $3;
}
- ;
-
-
-Repeated_music:
- REPEAT simple_string bare_unsigned Music Alternative_music
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_partial_optional
{
- Music *beg = $4;
- int times = $3;
- SCM alts = scm_is_pair ($5) ? scm_car ($5) : SCM_EOL;
- if (times < scm_ilength (alts)) {
- unsmob_music (scm_car (alts))
- ->origin ()->warning (
- _ ("More alternatives than repeats. Junking excess alternatives."));
- alts = ly_truncate_list (times, alts);
- }
-
-
- SCM proc = ly_lily_module_constant ("make-repeated-music");
-
- SCM mus = scm_call_1 (proc, $2);
- scm_gc_protect_object (mus); // UGH.
- Music *r = unsmob_music (mus);
- if (beg)
- {
- r-> set_property ("element", beg->self_scm ());
- scm_gc_unprotect_object (beg->self_scm ());
- }
- r->set_property ("repeat-count", scm_int2num (times >? 1));
-
- r-> set_property ("elements",alts);
- if (ly_c_equal_p ($2, scm_makfrom0str ("tremolo"))) {
- /*
- TODO: move this code to Scheme.
- */
-
- /*
- we can not get durations and other stuff correct down the line, so we have to
- add to the duration log here.
- */
- SCM func = ly_lily_module_constant ("shift-duration-log");
-
- int dots = ($3 % 3) ? 0 : 1;
- int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
-
-
- if ($4->is_mus_type ("sequential-music"))
- {
- int list_len = scm_ilength ($4->get_property ("elements"));
- if (list_len != 2)
- $4->origin ()->warning ("Chord tremolo must have 2 elements.");
- shift -= 1;
- r->compress (Moment (Rational (1, list_len)));
- }
- scm_call_3 (func, r->self_scm (), scm_int2num (shift), scm_int2num (dots));
-
- }
- r->set_spot (*$4->origin ());
-
- $$ = r;
+ $$ = $3;
}
;
-Sequential_music:
- SEQUENTIAL '{' Music_list '}' {
- $$ = MY_MAKE_MUSIC ("SequentialMusic");
- $$->set_property ("elements", scm_car ($3));
- $$->set_spot (@$);
- }
- | '{' Music_list '}' {
- $$ = MY_MAKE_MUSIC ("SequentialMusic");
- $$->set_property ("elements", scm_car ($2));
- $$->set_spot (@$);
+function_arglist_common:
+ EXPECT_NO_MORE_ARGS {
+ $$ = SCM_EOL;
}
- ;
-
-Simultaneous_music:
- SIMULTANEOUS '{' Music_list '}'{
- $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
- $$->set_property ("elements", scm_car ($3));
- $$->set_spot (@$);
-
+ | EXPECT_SCM function_arglist_optional embedded_scm_arg
+ {
+ if (scm_is_true (scm_call_1 ($1, $3)))
+ $$ = scm_cons ($3, $2);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $2, $1);
}
- | simul_open Music_list simul_close {
- $$ = MY_MAKE_MUSIC ("SimultaneousMusic");
- $$->set_property ("elements", scm_car ($2));
- $$->set_spot (@$);
+ | EXPECT_SCM function_arglist_optional bare_number_common
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $2, $1);
}
- ;
-
-Simple_music:
- event_chord { $$ = $1; }
- | MUSIC_IDENTIFIER {
- $$ = unsmob_music ($1);
+ | EXPECT_SCM function_arglist_optional post_event_nofinger
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $2, $1);
}
- | music_property_def
- | context_change
- ;
-
-
-optional_context_mod:
- /**/ { $$ = SCM_EOL; }
- | WITH { THIS->lexer_->push_initial_state (); }
- '{' context_mod_list '}'
+ | EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
{
- THIS->lexer_->pop_state ();
- $$ = $4;
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ $$ = check_scheme_arg (parser, @4, n, $2, $1);
}
- ;
-
-context_mod_list:
- /* */ { $$ = SCM_EOL; }
- | context_mod_list context_mod {
- $$ = scm_cons ($2, $1);
+ | function_arglist_common_reparse REPARSE SCM_ARG
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- ;
-
-
-Composite_music:
- Prefix_composite_music { $$ = $1; }
- | Grouped_music_list { $$ = $1; }
- ;
-
-Grouped_music_list:
- Simultaneous_music { $$ = $1; }
- | Sequential_music { $$ = $1; }
- ;
-
-Generic_prefix_music_scm:
- MUSIC_FUNCTION {
- $$ = scm_list_2 ($1, make_input (@$));
+ | function_arglist_common_reparse REPARSE lyric_element_music
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | MUSIC_FUNCTION_SCM embedded_scm {
- $$ = scm_list_3 ($1, make_input (@$), $2);
+ | function_arglist_common_reparse REPARSE pitch_or_music
+ {
+ if (scm_is_true (scm_call_1 ($2, $3)))
+ $$ = scm_cons ($3, $1);
+ else
+ $$ = check_scheme_arg (parser, @3,
+ make_music_from_simple
+ (parser, @3, $3),
+ $1, $2);
}
- | MUSIC_FUNCTION_MARKUP full_markup {
- $$ = scm_list_3 ($1, make_input (@$), $2);
+ | function_arglist_common_reparse REPARSE bare_number_common
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | MUSIC_FUNCTION_MUSIC Music {
- $$ = scm_list_3 ($1, make_input (@$), $2->self_scm ());
- scm_gc_unprotect_object ($2->self_scm ());
+ | function_arglist_common_reparse REPARSE multiplied_duration
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | MUSIC_FUNCTION_SCM_MUSIC embedded_scm Music {
- $$ = scm_list_4 ($1, make_input (@$), $2, $3->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ | function_arglist_common_reparse REPARSE reparsed_rhythm
+ {
+ $$ = check_scheme_arg (parser, @3,
+ $3, $1, $2);
}
- | MUSIC_FUNCTION_SCM_SCM embedded_scm embedded_scm {
- $$ = scm_list_4 ($1, make_input (@$), $2, $3);
+ | function_arglist_common_reparse REPARSE symbol_list_arg
+ {
+ $$ = check_scheme_arg (parser, @3, $3, $1, $2);
}
- | MUSIC_FUNCTION_SCM_SCM_MUSIC embedded_scm embedded_scm Music {
- $$ = scm_list_5 ($1, make_input (@$), $2, $3, $4->self_scm ());
+ ;
+
+function_arglist_common_reparse:
+ EXPECT_SCM function_arglist_optional SCM_IDENTIFIER
+ {
+ $$ = $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);
}
- | MUSIC_FUNCTION_MARKUP_MUSIC full_markup Music {
- $$ = scm_list_4 ($1, make_input (@$), $2, $3->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ | EXPECT_SCM function_arglist_optional pitch
+ {
+ $$ = $2;
+ if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple
+ (parser, @3, $3))))
+ MYREPARSE (@3, $1, PITCH_IDENTIFIER, $3);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | MUSIC_FUNCTION_MARKUP_MARKUP full_markup full_markup {
- $$ = scm_list_4 ($1, make_input (@$), $2, $3);
+ | EXPECT_SCM function_arglist_optional steno_tonic_pitch
+ {
+ $$ = $2;
+ if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple
+ (parser, @3, $3))))
+ MYREPARSE (@3, $1, TONICNAME_PITCH, $3);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | MUSIC_FUNCTION_MUSIC_MUSIC Music Music {
- $$ = scm_list_4 ($1, make_input (@$), $2->self_scm (), $3->self_scm ());
- scm_gc_unprotect_object ($2->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ | EXPECT_SCM function_arglist_optional STRING
+ {
+ $$ = $2;
+ SCM res = try_string_variants ($1, $3);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@3, $1, SYMBOL_LIST, res);
+ else
+ 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);
}
- | MUSIC_FUNCTION_SCM_MUSIC_MUSIC embedded_scm Music Music {
- $$ = scm_list_5 ($1, make_input (@$), $2, $3->self_scm (), $4->self_scm ());
- scm_gc_unprotect_object ($4->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ | EXPECT_SCM function_arglist_optional SYMBOL
+ {
+ $$ = $2;
+ SCM res = try_word_variants ($1, $3);
+ if (!SCM_UNBNDP (res))
+ if (scm_is_pair (res))
+ MYREPARSE (@3, $1, SYMBOL_LIST, res);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, res);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, LYRIC_ELEMENT, $3);
+ else
+ // This is going to flag a syntax error, we
+ // know the predicate to be false.
+ MYREPARSE (@3, $1, SCM_ARG, $3);
}
- | MUSIC_FUNCTION_MARKUP_MUSIC_MUSIC full_markup Music Music {
- $$ = scm_list_5 ($1, make_input (@$), $2, $3->self_scm (), $4->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
- scm_gc_unprotect_object ($4->self_scm ());
+ | 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);
}
- ;
-
-Generic_prefix_music:
- Generic_prefix_music_scm {
- SCM func = scm_car ($1);
- Input *loc = unsmob_input (scm_cadr ($1));
- SCM args = scm_cddr ($1);
- SCM sig = scm_object_property (func, ly_symbol2scm ("music-function-signature"));
-
- SCM type_check_proc = ly_lily_module_constant ("type-check-list");
- bool ok = true;
-
- if (!to_boolean (scm_call_3 (type_check_proc, scm_cadr ($1), sig, args)))
- {
- THIS->error_level_ = 1;
- ok = false;
+ | EXPECT_SCM function_arglist_optional UNSIGNED
+ {
+ $$ = $2;
+ if (scm_is_true (scm_call_1 ($1, $3)))
+ // May be 3 \cm or similar
+ MYREPARSE (@3, $1, REAL, $3);
+ else if (scm_is_true (scm_call_1 ($1, scm_list_1 ($3))))
+ MYREPARSE (@3, $1, SYMBOL_LIST, scm_list_1 ($3));
+ else {
+ SCM d = make_duration ($3);
+ if (!SCM_UNBNDP (d)) {
+ if (scm_is_true (scm_call_1 ($1, d)))
+ MYREPARSE (@3, $1, DURATION_IDENTIFIER, d);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, d))))
+ MYREPARSE (@3, $1, DURATION_ARG, d);
+ else
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
+ } else
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
}
-
- SCM m = SCM_EOL;
- if (ok)
- m = scm_apply_0 (func, scm_cons (THIS->self_scm(),
- scm_cdr ($1)));
-
- if (unsmob_music (m))
- {
- $$ = unsmob_music (m);
- scm_gc_protect_object (m);
- }
+ }
+ | EXPECT_SCM function_arglist_optional DURATION_IDENTIFIER
+ {
+ $$ = $2;
+ if (scm_is_true (scm_call_1 ($1, $3)))
+ MYREPARSE (@3, $1, DURATION_IDENTIFIER, $3);
+ else if (scm_is_true
+ (scm_call_1
+ ($1, make_music_from_simple (parser, @3, $3))))
+ MYREPARSE (@3, $1, DURATION_ARG, $3);
else
- {
- if (ok)
- loc->error (_ ("Music head function should return Music object."));
- $$ = MY_MAKE_MUSIC ("Music");
- }
- $$->set_spot (*loc);
+ MYREPARSE (@3, $1, SCM_ARG, $3); // trigger error
+ }
+ | EXPECT_SCM function_arglist_optional '-' UNSIGNED
+ {
+ $$ = $2;
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ if (scm_is_true (scm_call_1 ($1, n)))
+ MYREPARSE (@4, $1, REAL, n);
+ else {
+ Music *t = MY_MAKE_MUSIC ("FingeringEvent", @4);
+ t->set_property ("digit", $4);
+ SCM m = t->unprotect ();
+ if (scm_is_true (scm_call_1 ($1, m)))
+ MYREPARSE (@4, $1, SCM_ARG, m);
+ else
+ MYREPARSE (@4, $1, SCM_ARG, $4);
+ }
+ }
+ | EXPECT_SCM function_arglist_optional '-' REAL
+ {
+ $$ = $2;
+ SCM n = scm_difference ($4, SCM_UNDEFINED);
+ MYREPARSE (@4, $1, REAL, n);
}
;
-
-Prefix_composite_music:
- Generic_prefix_music {
- $$ = $1;
+function_arglist_optional:
+ function_arglist_backup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup DEFAULT
+ {
+ $$ = scm_cons (loc_on_copy (parser, @4, $1), $3);
}
- | CONTEXT simple_string '=' simple_string optional_context_mod Music {
- $$ = context_spec_music ($2, $4, $6, $5);
+ | function_arglist_skip_backup BACKUP
+ ;
+function_arglist_skip_backup:
+ function_arglist_backup
+ | EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_backup
+ {
+ $$ = scm_cons (loc_on_copy (parser, @3, $1), $3);
}
- | CONTEXT simple_string optional_context_mod Music {
- $$ = context_spec_music ($2, SCM_UNDEFINED, $4, $3);
- }
- | NEWCONTEXT simple_string optional_context_mod Music {
- $$ = context_spec_music ($2, get_next_unique_context_id (), $4,
- $3);
- }
+ ;
- | TIMES fraction Music
+music_function_call:
+ MUSIC_FUNCTION function_arglist {
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
+ }
+ ;
- {
- int n = scm_to_int (scm_car ($2)); int d = scm_to_int (scm_cdr ($2));
- Music *mp = $3;
- $$= MY_MAKE_MUSIC ("TimeScaledMusic");
- $$->set_spot (@$);
+optional_id:
+ /**/ { $$ = SCM_EOL; }
+ | '=' simple_string {
+ $$ = $2;
+ }
+ ;
- $$->set_property ("element", mp->self_scm ());
- scm_gc_unprotect_object (mp->self_scm ());
- $$->set_property ("numerator", scm_int2num (n));
- $$->set_property ("denominator", scm_int2num (d));
- $$->compress (Moment (Rational (n,d)));
+// We must not have lookahead tokens parsed in lyric mode. In order
+// to save confusion, we take almost the same set as permitted with
+// \lyricmode and/or \lyrics. However, music identifiers are also
+// allowed, and they obviously do not require switching into lyrics
+// mode for parsing.
+lyric_mode_music:
+ {
+ parser->lexer_->push_lyric_state ();
+ } grouped_music_list
+ {
+ parser->lexer_->pop_state ();
+ $$ = $2;
}
- | Repeated_music { $$ = $1; }
- | TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
- $$ = MY_MAKE_MUSIC ("TransposedMusic");
- Music *p = $4;
- Pitch from = *unsmob_pitch ($2);
- Pitch to = *unsmob_pitch ($3);
+ | MUSIC_IDENTIFIER
+ ;
- p->transpose (pitch_interval (from, to));
- $$->set_property ("element", p->self_scm ());
- scm_gc_unprotect_object (p->self_scm ());
- }
- | mode_changing_head Grouped_music_list {
- if ($1 == ly_symbol2scm ("chords"))
+mode_changed_music:
+ mode_changing_head grouped_music_list {
+ if (scm_is_eq ($1, ly_symbol2scm ("chords")))
{
- Music *chm = MY_MAKE_MUSIC ("UnrelativableMusic");
- chm->set_property ("element", $2->self_scm ());
- $$ = chm;
- scm_gc_unprotect_object ($2->self_scm ());
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $2);
}
else
{
$$ = $2;
}
- THIS->lexer_->pop_state ();
+ parser->lexer_->pop_state ();
}
- | mode_changing_head_with_context optional_context_mod Grouped_music_list {
- $$ = context_spec_music ($1, get_next_unique_context_id (),
- $3, $2);
- if ($1 == ly_symbol2scm ("ChordNames"))
+ | mode_changing_head_with_context optional_context_mods grouped_music_list {
+ $$ = MAKE_SYNTAX (context_specification, @$, $1, SCM_EOL, $2, SCM_BOOL_T, $3);
+ if (scm_is_eq ($1, ly_symbol2scm ("ChordNames")))
{
- Music *chm = MY_MAKE_MUSIC ("UnrelativableMusic");
- chm->set_property ("element", $$->self_scm ());
- scm_gc_unprotect_object ($$->self_scm ());
- $$ = chm;
+ $$ = MAKE_SYNTAX (unrelativable_music, @$, $$);
}
- THIS->lexer_->pop_state ();
- }
- | relative_music { $$ = $1; }
- | re_rhythmed_music { $$ = $1; }
- | TAG embedded_scm Music {
- tag_music ($3, $2, @$);
- $$ = $3;
+ parser->lexer_->pop_state ();
}
;
-mode_changing_head:
+mode_changing_head:
NOTEMODE {
- SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
- THIS->lexer_->push_note_state (alist_to_hashq (nn));
+ parser->lexer_->push_note_state (Lily::pitchnames);
$$ = ly_symbol2scm ("notes");
}
- | DRUMMODE
+ | DRUMMODE
{
- SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
- THIS->lexer_->push_note_state (alist_to_hashq (nn));
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("drums");
}
| FIGUREMODE {
- THIS->lexer_->push_figuredbass_state ();
+ parser->lexer_->push_figuredbass_state ();
$$ = ly_symbol2scm ("figures");
}
| CHORDMODE {
- SCM nn = THIS->lexer_->lookup_identifier ("chordmodifiers");
- THIS->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = THIS->lexer_->lookup_identifier ("pitchnames");
- THIS->lexer_->push_chord_state (alist_to_hashq (nn));
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("chords");
}
| LYRICMODE
- { THIS->lexer_->push_lyric_state ();
+ { parser->lexer_->push_lyric_state ();
$$ = ly_symbol2scm ("lyrics");
}
;
-mode_changing_head_with_context:
+mode_changing_head_with_context:
DRUMS {
- SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
- THIS->lexer_->push_note_state (alist_to_hashq (nn));
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("DrumStaff");
}
| FIGURES {
- THIS->lexer_->push_figuredbass_state ();
+ parser->lexer_->push_figuredbass_state ();
$$ = ly_symbol2scm ("FiguredBass");
}
| CHORDS {
- SCM nn = THIS->lexer_->lookup_identifier ("chordmodifiers");
- THIS->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = THIS->lexer_->lookup_identifier ("pitchnames");
- THIS->lexer_->push_chord_state (alist_to_hashq (nn));
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("ChordNames");
}
| LYRICS
- { THIS->lexer_->push_lyric_state ();
+ { parser->lexer_->push_lyric_state ();
$$ = ly_symbol2scm ("Lyrics");
}
;
-
-relative_music:
- RELATIVE absolute_pitch Music {
- Music *m = $3;
- Pitch start = *unsmob_pitch ($2);
- $$ = make_music_relative (start, m);
- scm_gc_unprotect_object (m->self_scm ());
- }
- | RELATIVE Composite_music {
- Music *m = $2;
-
- Pitch middle_c (0, 0, 0);
- $$ = make_music_relative (middle_c, m);
- scm_gc_unprotect_object (m->self_scm ());
+context_change:
+ CHANGE symbol '=' simple_string {
+ $$ = MAKE_SYNTAX (context_change, @$, $2, $4);
}
;
-new_lyrics:
- ADDLYRICS { THIS->lexer_->push_lyric_state (); }
- /*cont */
- Grouped_music_list {
- /* Can also use Music at the expensive of two S/Rs similar to
- \repeat \alternative */
- THIS->lexer_->pop_state ();
- $$ = scm_cons ($3->self_scm (), SCM_EOL);
- }
- | new_lyrics ADDLYRICS {
- THIS->lexer_->push_lyric_state ();
- } Grouped_music_list {
- THIS->lexer_->pop_state ();
- $$ = scm_cons ($4->self_scm (), $1);
+property_path:
+ symbol_list_rev {
+ $$ = scm_reverse_x ($1, SCM_EOL);
}
;
-re_rhythmed_music:
- Grouped_music_list new_lyrics {
- Music * voice = $1;
- SCM name = get_first_context_id (scm_makfrom0str ("Voice"), voice);
- if (!scm_is_string (name))
- {
- name = get_next_unique_lyrics_context_id ();
- voice = context_spec_music (scm_makfrom0str ("Voice"),
- name,
- voice, SCM_EOL);
- }
-
- SCM context = scm_makfrom0str ("Lyrics");
- Music *all = MY_MAKE_MUSIC ("SimultaneousMusic");
-
- SCM lst = SCM_EOL;
- for (SCM s = $2; scm_is_pair (s); s = scm_cdr (s))
- {
- Music *music = unsmob_music (scm_car (s));
- Music *com = make_lyric_combine_music (name, music);
- Music *csm = context_spec_music (context,
- get_next_unique_context_id (), com, SCM_EOL);
- lst = scm_cons (csm->self_scm (), lst);
+property_operation:
+ symbol '=' scalar {
+ $$ = scm_list_3 (ly_symbol2scm ("assign"), $1, $3);
+ }
+ | UNSET symbol {
+ $$ = scm_list_2 (ly_symbol2scm ("unset"), $2);
+ }
+ | OVERRIDE revert_arg '=' 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)));
}
- all->set_property ("elements", scm_cons (voice->self_scm (),
- lst));
- $$ = all;
- scm_gc_unprotect_object (voice->self_scm ());
}
- | LYRICSTO simple_string {
- THIS->lexer_->push_lyric_state ();
- } Music {
- THIS->lexer_->pop_state ();
- Music *music = $4;
- SCM name = $2;
- $$ = make_lyric_combine_music (name, music);
- scm_gc_unprotect_object (music->self_scm ());
+ | REVERT revert_arg {
+ $$ = scm_cons (ly_symbol2scm ("pop"), $2);
}
;
-context_change:
- CHANGE STRING '=' STRING {
- Music*t = MY_MAKE_MUSIC ("ContextChange");
- t-> set_property ("change-to-type", scm_string_to_symbol ($2));
- t-> set_property ("change-to-id", $4);
-
- $$ = t;
- $$->set_spot (@$);
+// This is all quite awkward for the sake of substantial backward
+// compatibility while at the same time allowing a more "natural" form
+// of specification not separating grob specification from grob
+// property path. The purpose of this definition of revert_arg is to
+// allow the symbol list which specifies grob and property to revert
+// to be optionally be split into two parts after the grob (which in
+// this case is just the first element of the list). symbol_list_part
+// is only one path component, but it can be parsed without lookahead,
+// so we can follow it with a synthetic BACKUP token when needed. If
+// the first symbol_list_part already contains multiple elements (only
+// possible if a Scheme expression provides them), we just parse for
+// additional elements introduced by '.', which is what the
+// SYMBOL_LIST backup in connection with the immediately following
+// rule using symbol_list_arg does.
+//
+// As long as we don't have our coffers filled with both grob and at
+// least one grob property specification, the rest of the required
+// symbol list chain may be provided either with or without a leading
+// dot. This is for both allowing the traditional
+// \revert Accidental #'color
+// as well as well as the "naive" form
+// \revert Accidental.color
+
+revert_arg:
+ revert_arg_backup BACKUP symbol_list_arg
+ {
+ $$ = $3;
}
;
-property_operation:
- STRING '=' scalar {
- $$ = scm_list_3 (ly_symbol2scm ("assign"),
- scm_string_to_symbol ($1), $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);
}
- | UNSET simple_string {
- $$ = scm_list_2 (ly_symbol2scm ("unset"),
- scm_string_to_symbol ($2));
+ ;
+
+// 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));
}
- | OVERRIDE simple_string embedded_scm '=' embedded_scm {
- $$ = scm_list_4 (ly_symbol2scm ("push"),
- scm_string_to_symbol ($2), $3, $5);
+ | revert_arg_backup BACKUP SCM_ARG ',' symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($5, $3));
}
- | REVERT simple_string embedded_scm {
- $$ = scm_list_3 (ly_symbol2scm ("pop"),
- scm_string_to_symbol ($2), $3);
+ | revert_arg_backup BACKUP SCM_ARG symbol_list_part
+ {
+ $$ = scm_append_x (scm_list_2 ($4, $3));
}
;
| REMOVE { $$ = ly_symbol2scm ("remove"); }
| ACCEPTS { $$ = ly_symbol2scm ("accepts"); }
+ | DEFAULTCHILD { $$ = ly_symbol2scm ("default-child"); }
| DENIES { $$ = ly_symbol2scm ("denies"); }
| ALIAS { $$ = ly_symbol2scm ("alias"); }
| context_def_mod STRING {
$$ = scm_list_2 ($1, $2);
}
+ | context_def_mod SYMBOL {
+ $$ = scm_list_2 ($1, $2);
+ }
+ | context_def_mod embedded_scm
+ {
+ if (!scm_is_string ($2)
+ && !scm_is_eq ($1, ly_symbol2scm ("consists"))
+ && !scm_is_eq ($1, ly_symbol2scm ("remove")))
+ {
+ $$ = SCM_EOL;
+ parser->parser_error (@1, _ ("only \\consists and \\remove take non-string argument."));
+ }
+ else
+ {
+ $$ = scm_list_2 ($1, $2);
+ }
+ }
;
-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;
+ }
+ ;
+
+
+// This is all quite awkward for the sake of substantial backward
+// compatibility while at the same time allowing a more "natural" form
+// of specification not separating grob specification from grob
+// property path. The purpose of this definition of
+// simple_revert_context is to allow the symbol list which specifies
+// grob and property to revert to be optionally be split into two
+// parts after the grob (which may be preceded by a context
+// specification, a case which we distinguish by checking whether the
+// first symbol is a valid grob symbol instead).
+//
+// See revert_arg above for the main work horse of this arrangement.
+// simple_revert_context just caters for the context and delegates the
+// rest of the job to revert_arg.
+
+simple_revert_context:
+ symbol_list_part
+ {
+ $1 = scm_reverse_x ($1, SCM_EOL);
+ if (scm_is_null ($1)
+ || to_boolean
+ (scm_object_property (scm_car ($1),
+ ly_symbol2scm ("is-grob?")))) {
+ $$ = ly_symbol2scm ("Bottom");
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER, $1);
+ } else {
+ $$ = scm_car ($1);
+ parser->lexer_->push_extra_token (@1, SCM_IDENTIFIER,
+ scm_cdr ($1));
+ }
}
;
music_property_def:
- OVERRIDE context_prop_spec embedded_scm '=' scalar {
- $$ = property_op_to_music (scm_list_4 (
- ly_symbol2scm ("poppush"),
- scm_cadr ($2),
- $3, $5));
- $$= context_spec_music (scm_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+ OVERRIDE grob_prop_path '=' scalar {
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_override, @$,
+ scm_car ($2),
+ scm_cdr ($2),
+ $4);
}
- | REVERT context_prop_spec embedded_scm {
- $$ = property_op_to_music (scm_list_3 (
- ly_symbol2scm ("pop"),
- scm_cadr ($2),
- $3));
-
- $$= context_spec_music (scm_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+ | REVERT simple_revert_context revert_arg {
+ $$ = MAKE_SYNTAX (property_revert, @$, $2, $3);
}
| SET context_prop_spec '=' scalar {
- $$ = property_op_to_music (scm_list_3 (
- ly_symbol2scm ("assign"),
- scm_cadr ($2),
- $4));
- $$= context_spec_music (scm_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_set, @$,
+ scm_car ($2),
+ scm_cadr ($2),
+ $4);
}
| UNSET context_prop_spec {
- $$ = property_op_to_music (scm_list_2 (
- ly_symbol2scm ("unset"),
- scm_cadr ($2)));
- $$= context_spec_music (scm_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
- }
- | ONCE music_property_def {
- SCM e = $2->get_property ("element");
- unsmob_music (e)->set_property ("once", SCM_BOOL_T);
- $$ = $2;
-
+ if (SCM_UNBNDP ($2))
+ $$ = MAKE_SYNTAX (void_music, @$);
+ else
+ $$ = MAKE_SYNTAX (property_unset, @$,
+ scm_car ($2),
+ scm_cadr ($2));
}
;
-
string:
- STRING {
- $$ = $1;
- }
- | STRING_IDENTIFIER {
- $$ = $1;
- }
- | string '+' string {
- $$ = scm_string_append (scm_list_2 ($1, $3));
- }
+ STRING
+ | SYMBOL
+ | full_markup
;
-simple_string: STRING {
- $$ = $1;
+text:
+ STRING
+ | SYMBOL
+ | full_markup
+ | embedded_scm_bare
+ {
+ if (Text_interface::is_markup ($1)) {
+ $$ = $1;
+ } else {
+ parser->parser_error (@1, (_ ("markup expected")));
+ $$ = scm_string (SCM_EOL);
+ }
}
- | LYRICS_STRING {
- $$ = $1;
+ ;
+
+simple_string: STRING
+ | SYMBOL
+ | embedded_scm_bare
+ {
+ if (scm_is_string ($1)) {
+ $$ = $1;
+ } else {
+ parser->parser_error (@1, (_ ("simple string expected")));
+ $$ = scm_string (SCM_EOL);
+ }
}
;
-scalar: string {
- $$ = $1;
+symbol:
+ STRING {
+ $$ = scm_string_to_symbol ($1);
}
- | LYRICS_STRING {
- $$ = $1;
+ | SYMBOL
+ {
+ if (!is_regular_identifier ($1, false))
+ parser->parser_error (@1, (_ ("symbol expected")));
+ $$ = scm_string_to_symbol ($1);
}
- | bare_int {
- $$ = scm_int2num ($1);
+ | embedded_scm_bare
+ {
+ // This is a bit of overkill but makes the same
+ // routine responsible for all symbol interpretations.
+ $$ = try_string_variants (Guile_user::symbol_p, $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"));
+ }
}
- | embedded_scm {
- $$ = $1;
+ ;
+
+scalar:
+ embedded_scm_arg
+ | pitch_or_music
+ | 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);
}
- | full_markup {
- $$ = $1;
+ | string
+ | symbol_list_part_bare '.' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
}
- | DIGIT {
- $$ = scm_int2num ($1);
+ | symbol_list_part_bare ',' property_path
+ {
+ $$ = scm_reverse_x ($1, $3);
}
;
-/*
-
-pre_events doesn't contain anything. It is a trick:
-
-Adding pre_events to the simple_element
-makes the choice between
-
- string: STRING
-
-and
-
- simple_element: STRING
-
-a single shift/reduction conflict.
-
-nevertheless, this is not very clean, and we should find a different
-solution.
-
-*/
-pre_events: /* empty */
- ;
-
event_chord:
- pre_events simple_element post_events {
- SCM elts = $2-> get_property ("elements");
-
- elts = ly_append2 (elts, scm_reverse_x ($3, SCM_EOL));
-
- $2->set_property ("elements", elts);
- /* why is this giving wrong start location? -ns
- * $2->set_spot (@$); */
- Input i;
- i.set_location (@2, @3);
- $2->set_spot (i);
- $$ = $2;
- }
- | command_element
+ simple_element post_events {
+ // Let the rhythmic music iterator sort this mess out.
+ if (scm_is_pair ($2)) {
+ unsmob<Music> ($$)->set_property ("articulations",
+ scm_reverse_x ($2, SCM_EOL));
+ }
+ } %prec ':'
+ | CHORD_REPETITION optional_notemode_duration post_events {
+ $$ = MAKE_SYNTAX (repetition_chord, @$,
+ $2, scm_reverse_x ($3, SCM_EOL));
+ } %prec ':'
+ | MULTI_MEASURE_REST optional_notemode_duration post_events {
+ $$ = MAKE_SYNTAX (multi_measure_rest, @$, $2,
+ scm_reverse_x ($3, SCM_EOL));
+ } %prec ':'
+ | tempo_event
| note_chord_element
;
note_chord_element:
chord_body optional_notemode_duration post_events
{
- SCM dur = unsmob_duration ($2)->smobbed_copy ();
- SCM es = $1->get_property ("elements");
+ Music *m = unsmob<Music> ($1);
+ SCM dur = unsmob<Duration> ($2)->smobbed_copy ();
+ SCM es = m->get_property ("elements");
SCM postevs = scm_reverse_x ($3, SCM_EOL);
for (SCM s = es; scm_is_pair (s); s = scm_cdr (s))
- unsmob_music (scm_car (s))->set_property ("duration", dur);
+ unsmob<Music> (scm_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
- $1-> set_property ("elements", es);
- $1->set_spot (@$);
- $$ = $1;
- }
- ;
-
-chord_open: '<'
- ;
-
-chord_close: '>'
- ;
-
-simul_open: DOUBLE_ANGLE_OPEN
- ;
-
-simul_close: DOUBLE_ANGLE_CLOSE
+ m->set_property ("elements", es);
+ m->set_spot (parser->lexer_->override_input (@$));
+ $$ = m->self_scm ();
+ } %prec ':'
;
chord_body:
- chord_open chord_body_elements chord_close
+ ANGLE_OPEN chord_body_elements ANGLE_CLOSE
+ {
+ $$ = MAKE_SYNTAX (event_chord, @$, scm_reverse_x ($2, SCM_EOL));
+ }
+ | FIGURE_OPEN figure_list FIGURE_CLOSE
{
- $$ = MY_MAKE_MUSIC ("EventChord");
- $$->set_spot (@$);
- $$->set_property ("elements",
- scm_reverse_x ($2, SCM_EOL));
+ $$ = MAKE_SYNTAX (event_chord, @$, scm_reverse_x ($2, SCM_EOL));
}
;
chord_body_elements:
/* empty */ { $$ = SCM_EOL; }
| chord_body_elements chord_body_element {
- $$ = scm_cons ($2->self_scm (), $1);
- scm_gc_unprotect_object ($2->self_scm ());
+ if (!SCM_UNBNDP ($2))
+ $$ = scm_cons ($2, $1);
}
;
chord_body_element:
- pitch exclamations questions octave_check post_events
+ pitch_or_tonic_pitch exclamations questions octave_check post_events
{
- int q = $3;
- int ex = $2;
+ bool q = to_boolean ($3);
+ bool ex = to_boolean ($2);
SCM check = $4;
SCM post = $5;
- Music *n = MY_MAKE_MUSIC ("NoteEvent");
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
n->set_property ("pitch", $1);
- n->set_spot (@$);
- if (q % 2)
+ if (q)
n->set_property ("cautionary", SCM_BOOL_T);
- if (ex % 2 || q % 2)
+ if (ex || q)
n->set_property ("force-accidental", SCM_BOOL_T);
if (scm_is_pair (post)) {
if (scm_is_number (check))
{
int q = scm_to_int (check);
- n->set_property ("absolute-octave", scm_int2num (q-1));
+ n->set_property ("absolute-octave", scm_from_int (q-1));
}
-
- $$ = n;
+ $$ = n->unprotect ();
}
| DRUM_PITCH post_events {
- Music *n = MY_MAKE_MUSIC ("NoteEvent");
- n->set_property ("duration", $2);
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
n->set_property ("drum-type", $1);
- n->set_spot (@$);
if (scm_is_pair ($2)) {
SCM arts = scm_reverse_x ($2, SCM_EOL);
n->set_property ("articulations", arts);
}
- $$ = n;
- }
- ;
-
-add_quote:
- ADDQUOTE string Music {
- SCM adder = ly_lily_module_constant ("add-quotable");
-
- scm_call_2 (adder, $2, $3->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
- }
- ;
-
-command_element:
- command_req {
- $$ = MY_MAKE_MUSIC ("EventChord");
- $$->set_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
- scm_gc_unprotect_object ($1->self_scm ());
-
- $$-> set_spot (@$);
- $1-> set_spot (@$);
- }
- | SKIP duration_length {
- Music *skip = MY_MAKE_MUSIC ("SkipMusic");
- skip->set_property ("duration", $2);
- skip->set_spot (@$);
- $$ = skip;
- }
- | OCTAVE pitch {
- Music *m = MY_MAKE_MUSIC ("RelativeOctaveCheck");
- $$ = m;
- $$->set_spot (@$);
- $$->set_property ("pitch", $2);
- }
- | E_LEFTSQUARE {
- Music *m = MY_MAKE_MUSIC ("LigatureEvent");
- m->set_property ("span-direction", scm_int2num (START));
- m->set_spot (@$);
-
- $$ = MY_MAKE_MUSIC ("EventChord");
- $$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
- scm_gc_unprotect_object (m->self_scm ());
- $$->set_spot (@$);
+ $$ = n->unprotect ();
}
- | E_RIGHTSQUARE {
- Music *m = MY_MAKE_MUSIC ("LigatureEvent");
- m->set_property ("span-direction", scm_int2num (STOP));
- m->set_spot (@$);
-
- $$ = MY_MAKE_MUSIC ("EventChord");
- $$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
- $$->set_spot (@$);
- scm_gc_unprotect_object (m->self_scm ());
- }
- | E_BACKSLASH {
- $$ = MY_MAKE_MUSIC ("VoiceSeparator");
- $$->set_spot (@$);
- }
- | '|' {
- SCM pipe = THIS->lexer_->lookup_identifier ("pipeSymbol");
-
- if (Music * m = unsmob_music (pipe))
- $$ = m->clone ();
- else
- $$ = MY_MAKE_MUSIC ("BarCheck");
-
- $$->set_spot (@$);
- }
- | TRANSPOSITION pitch {
- Pitch middle_c;
- Pitch sounds_as_c = pitch_interval (*unsmob_pitch ($2), middle_c);
- $$ = set_property_music (ly_symbol2scm ("instrumentTransposition"),
- sounds_as_c.smobbed_copy());
- $$->set_spot (@$);
- $$ = context_spec_music (ly_symbol2scm ("Staff"), SCM_UNDEFINED,
- $$, SCM_EOL);
- }
- | BAR STRING {
- Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
-
- Music *csm = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
- t, SCM_EOL);
- $$ = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED, csm, SCM_EOL);
- $$->set_spot (@$);
- t->set_spot (@$);
- }
- | PARTIAL duration_length {
- Moment m = - unsmob_duration ($2)->get_length ();
- Music *p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
- p->set_spot (@$);
- p = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
- p, SCM_EOL);
- p = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED,
- p, SCM_EOL);
- $$ = p;
- }
- | CLEF STRING {
- SCM proc = ly_lily_module_constant ("make-clef-set");
-
- SCM result = scm_call_1 (proc, $2);
- scm_gc_protect_object (result);
- $$ = unsmob_music (result);
- }
- | TIME_T fraction {
- SCM proc = ly_lily_module_constant ("make-time-signature-set");
+ | music_function_chord_body
+ {
+ Music *m = unsmob<Music> ($1);
- SCM result = scm_apply_2 (proc, scm_car ($2), scm_cdr ($2), SCM_EOL);
- scm_gc_protect_object (result);
- $$ = unsmob_music (result);
- }
- | MARK scalar {
- SCM proc = ly_lily_module_constant ("make-mark-set");
+ while (m && m->is_mus_type ("music-wrapper-music")) {
+ $$ = m->get_property ("element");
+ m = unsmob<Music> ($$);
+ }
- SCM result = scm_call_1 (proc, $2);
- scm_gc_protect_object (result);
- $$ = unsmob_music (result);
+ if (!(m && m->is_mus_type ("rhythmic-event"))) {
+ parser->parser_error (@$, _ ("not a rhythmic event"));
+ $$ = SCM_UNDEFINED;
+ }
}
;
-command_req:
- E_TILDE {
- $$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
- }
- | MARK DEFAULT {
- Music *m = MY_MAKE_MUSIC ("MarkEvent");
- $$ = m;
- }
- | tempo_event {
- $$ = $1;
- }
- | KEY DEFAULT {
- Music *key = MY_MAKE_MUSIC ("KeyChangeEvent");
- $$ = key;
- }
- | 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 {
- THIS->parser_error (@3, _ ("Second argument must be pitch list."));
- }
+music_function_chord_body:
+ music_function_call
+ | MUSIC_IDENTIFIER
+ | embedded_scm
+ ;
- $$ = key;
+event_function_event:
+ EVENT_FUNCTION function_arglist {
+ $$ = MAKE_SYNTAX (music_function, @$,
+ $1, $2);
}
;
-
post_events:
/* empty */ {
$$ = SCM_EOL;
}
| post_events post_event {
- $2->set_spot (@2);
- $$ = scm_cons ($2->self_scm (), $$);
- scm_gc_unprotect_object ($2->self_scm ());
- }
- | post_events tagged_post_event {
- $2 -> set_spot (@2);
- $$ = scm_cons ($2->self_scm (), $$);
- scm_gc_unprotect_object ($2->self_scm ());
- }
- ;
-
-
-tagged_post_event:
- '-' TAG embedded_scm post_event {
- tag_music ($4, $3, @$);
- $$ = $4;
+ $$ = $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 (parser->lexer_->override_input (@2));
+ $$ = scm_cons ($2, $$);
+ }
+ }
}
;
-
-post_event:
+post_event_nofinger:
direction_less_event {
$$ = $1;
}
+ | script_dir music_function_call {
+ Music *m = unsmob<Music> ($2);
+ if (!m->is_mus_type ("post-event")) {
+ parser->parser_error (@2, _ ("post-event expected"));
+ $$ = SCM_UNSPECIFIED;
+ } else {
+ m->set_spot (parser->lexer_->override_input (@$));
+ if (!SCM_UNBNDP ($1))
+ m->set_property ("direction", $1);
+ $$ = $2;
+ }
+ }
| HYPHEN {
- if (!THIS->lexer_->is_lyric_state ())
- THIS->parser_error (@1, _ ("Have to be in Lyric mode for lyrics"));
- $$ = MY_MAKE_MUSIC ("HyphenEvent");
+ 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 (!THIS->lexer_->is_lyric_state ())
- THIS->parser_error (@1, _ ("Have to be in Lyric mode for lyrics"));
- $$ = MY_MAKE_MUSIC ("ExtenderEvent");
+ 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 {
- if ($1)
- $2->set_property ("direction", scm_int2num ($1));
+ if (Music *m = unsmob<Music> ($2)) {
+ m->set_spot (parser->lexer_->override_input (@$));
+ if (!SCM_UNBNDP ($1))
+ {
+ m->set_property ("direction", $1);
+ }
+ }
$$ = $2;
}
| script_dir direction_less_event {
- if ($1)
- $2->set_property ("direction", scm_int2num ($1));
+ Music *m = unsmob<Music> ($2);
+ m->set_spot (parser->lexer_->override_input (@$));
+ if (!SCM_UNBNDP ($1))
+ m->set_property ("direction", $1);
+ $$ = $2;
+ }
+ | '^' fingering
+ {
+ Music *m = unsmob<Music> ($2);
+ m->set_spot (parser->lexer_->override_input (@$));
+ m->set_property ("direction", scm_from_int (UP));
+ $$ = $2;
+ }
+ | '_' fingering
+ {
+ Music *m = unsmob<Music> ($2);
+ m->set_spot (parser->lexer_->override_input (@$));
+ m->set_property ("direction", scm_from_int (DOWN));
$$ = $2;
}
- | string_number_event
;
-string_number_event:
- E_UNSIGNED {
- Music *s = MY_MAKE_MUSIC ("StringNumberEvent");
- s->set_property ("string-number", scm_int2num ($1));
- s->set_spot (@$);
- $$ = s;
+post_event:
+ post_event_nofinger
+ | '-' fingering {
+ unsmob<Music> ($2)->set_spot (parser->lexer_->override_input (@$));
+ $$ = $2;
}
;
-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_BIGGER {
- $$ = ly_symbol2scm ("escapedBiggerSymbol");
- }
- | E_SMALLER {
- $$ = ly_symbol2scm ("escapedSmallerSymbol");
+string_number_event:
+ E_UNSIGNED {
+ Music *s = MY_MAKE_MUSIC ("StringNumberEvent", @$);
+ s->set_property ("string-number", $1);
+ $$ = s->unprotect ();
}
;
direction_less_event:
- direction_less_char {
- SCM predefd = THIS->lexer_->lookup_identifier_symbol ($1);
- Music * m = 0;
- if (unsmob_music (predefd))
- {
- m = unsmob_music (predefd)->clone ();
- }
- else
- {
- m = MY_MAKE_MUSIC ("Music");
- }
- m->set_spot (@$);
- $$ = m;
- }
+ string_number_event
| EVENT_IDENTIFIER {
- $$ = unsmob_music ($1);
+ $$ = $1;
}
| tremolo_type {
- Music *a = MY_MAKE_MUSIC ("TremoloEvent");
- a->set_spot (@$);
- a->set_property ("tremolo-type", scm_int2num ($1));
- $$ = a;
+ Music *a = MY_MAKE_MUSIC ("TremoloEvent", @$);
+ a->set_property ("tremolo-type", $1);
+ $$ = a->unprotect ();
}
- ;
-
+ | event_function_event
+ ;
+
direction_reqd_event:
gen_text_def {
$$ = $1;
}
| script_abbreviation {
- SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
- Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
- if (scm_is_string (s))
+ SCM s = parser->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
+ if (scm_is_string (s)) {
+ Music *a = MY_MAKE_MUSIC ("ArticulationEvent", @$);
a->set_property ("articulation-type", s);
- else THIS->parser_error (@1, _ ("Expecting string as script definition"));
- $$ = a;
+ $$ = a->unprotect ();
+ } else {
+ Music *original = unsmob<Music> (s);
+ if (original && original->is_mus_type ("post-event")) {
+ Music *a = original->clone ();
+ // origin will be set by post_event_nofinger
+ $$ = a->unprotect ();
+ } else {
+ parser->parser_error (@1, _ ("expecting string or post-event as script definition"));
+ $$ = SCM_UNSPECIFIED;
+ }
+ }
}
;
octave_check:
/**/ { $$ = SCM_EOL; }
- | '=' { $$ = scm_int2num (0); }
- | '=' sub_quotes { $$ = scm_int2num ($2); }
- | '=' sup_quotes { $$ = scm_int2num ($2); }
+ | '=' quotes { $$ = $2; }
;
+quotes:
+ /* empty */
+ {
+ $$ = SCM_INUM0;
+ }
+ | sub_quotes
+ | sup_quotes
+ ;
+
sup_quotes:
'\'' {
- $$ = 1;
+ $$ = scm_from_int (1);
}
| sup_quotes '\'' {
- $$ ++;
+ $$ = scm_oneplus ($1);
}
;
sub_quotes:
',' {
- $$ = 1;
+ $$ = scm_from_int (-1);
}
| sub_quotes ',' {
- $$++;
+ $$ = scm_oneminus ($1);
}
;
steno_pitch:
- NOTENAME_PITCH {
- $$ = $1;
- }
- | NOTENAME_PITCH sup_quotes {
- Pitch p = *unsmob_pitch ($1);
- p = p.transposed (Pitch ($2,0,0));
- $$ = p.smobbed_copy ();
- }
- | NOTENAME_PITCH sub_quotes {
- Pitch p =* unsmob_pitch ($1);
- p = p.transposed (Pitch (-$2,0,0));
- $$ = p.smobbed_copy ();
+ NOTENAME_PITCH quotes {
+ if (!scm_is_eq (SCM_INUM0, $2))
+ {
+ Pitch p = *unsmob<Pitch> ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
+ $$ = p.smobbed_copy ();
+ }
}
;
*/
steno_tonic_pitch:
- TONICNAME_PITCH {
- $$ = $1;
- }
- | TONICNAME_PITCH sup_quotes {
- Pitch p = *unsmob_pitch ($1);
- p = p.transposed (Pitch ($2,0,0));
- $$ = p.smobbed_copy ();
- }
- | TONICNAME_PITCH sub_quotes {
- Pitch p =* unsmob_pitch ($1);
-
- p = p.transposed (Pitch (-$2,0,0));
- $$ = p.smobbed_copy ();
+ TONICNAME_PITCH quotes {
+ if (!scm_is_eq (SCM_INUM0, $2))
+ {
+ Pitch p = *unsmob<Pitch> ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
+ $$ = p.smobbed_copy ();
+ }
}
;
pitch:
- steno_pitch {
- $$ = $1;
+ steno_pitch
+ | PITCH_IDENTIFIER quotes {
+ if (!scm_is_eq (SCM_INUM0, $2))
+ {
+ Pitch p = *unsmob<Pitch> ($1);
+ p = p.transposed (Pitch (scm_to_int ($2), 0));
+ $$ = p.smobbed_copy ();
+ }
}
;
-pitch_also_in_chords:
+pitch_or_tonic_pitch:
pitch
| steno_tonic_pitch
;
gen_text_def:
full_markup {
- Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
+ Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
t->set_property ("text", $1);
- t->set_spot (@$);
- $$ = t;
+ $$ = t->unprotect ();
+ }
+ | STRING {
+ Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
+ t->set_property ("text",
+ make_simple_markup ($1));
+ $$ = t->unprotect ();
}
- | string {
- Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
+ | SYMBOL {
+ // Flag a warning? could be unintentional
+ Music *t = MY_MAKE_MUSIC ("TextScriptEvent", @$);
t->set_property ("text",
make_simple_markup ($1));
- t->set_spot (@$);
- $$ = t;
-
+ $$ = t->unprotect ();
+ }
+ | embedded_scm
+ {
+ 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"));
+ $$ = SCM_UNSPECIFIED;
+ }
}
- | DIGIT {
- Music *t = MY_MAKE_MUSIC ("FingerEvent");
- t->set_property ("digit", scm_int2num ($1));
- t->set_spot (@$);
- $$ = t;
+ ;
+
+fingering:
+ UNSIGNED {
+ Music *t = MY_MAKE_MUSIC ("FingeringEvent", @$);
+ t->set_property ("digit", $1);
+ $$ = t->unprotect ();
}
;
script_abbreviation:
'^' {
- $$ = scm_makfrom0str ("Hat");
+ $$ = scm_from_ascii_string ("Hat");
}
| '+' {
- $$ = scm_makfrom0str ("Plus");
+ $$ = scm_from_ascii_string ("Plus");
}
| '-' {
- $$ = scm_makfrom0str ("Dash");
+ $$ = scm_from_ascii_string ("Dash");
}
- | '|' {
- $$ = scm_makfrom0str ("Bar");
+ | '!' {
+ $$ = scm_from_ascii_string ("Bang");
}
- | '>' {
- $$ = scm_makfrom0str ("Larger");
+ | ANGLE_CLOSE {
+ $$ = scm_from_ascii_string ("Larger");
}
| '.' {
- $$ = scm_makfrom0str ("Dot");
+ $$ = scm_from_ascii_string ("Dot");
}
| '_' {
- $$ = scm_makfrom0str ("Underscore");
+ $$ = scm_from_ascii_string ("Underscore");
}
;
script_dir:
- '_' { $$ = DOWN; }
- | '^' { $$ = UP; }
- | '-' { $$ = CENTER; }
+ '_' { $$ = scm_from_int (DOWN); }
+ | '^' { $$ = scm_from_int (UP); }
+ | '-' { $$ = SCM_UNDEFINED; }
;
-
-absolute_pitch:
- steno_pitch {
+maybe_notemode_duration:
+ {
+ $$ = SCM_UNDEFINED;
+ } %prec ':'
+ | multiplied_duration {
$$ = $1;
+ parser->default_duration_ = *unsmob<Duration> ($$);
}
- ;
+;
-duration_length:
- multiplied_duration {
- $$ = $1;
- }
- ;
optional_notemode_duration:
+ maybe_notemode_duration
{
- Duration dd = THIS->default_duration_;
- $$ = dd.smobbed_copy ();
-
- THIS->beam_check ($$);
- }
- | multiplied_duration {
- $$ = $1;
- THIS->default_duration_ = *unsmob_duration ($$);
-
- THIS->beam_check ($$);
+ if (SCM_UNBNDP ($$))
+ $$ = parser->default_duration_.smobbed_copy ();
}
;
steno_duration:
- bare_unsigned dots {
- int len = 0;
- if (!is_duration ($1))
- THIS->parser_error (@1, _f ("not a duration: %d", $1));
- else
- len = intlog2 ($1);
-
- $$ = Duration (len, $2).smobbed_copy ();
+ UNSIGNED dots {
+ $$ = make_duration ($1, scm_to_int ($2));
+ if (SCM_UNBNDP ($$))
+ {
+ parser->parser_error (@1, _ ("not a duration"));
+ $$ = Duration ().smobbed_copy ();
+ }
}
| DURATION_IDENTIFIER dots {
- Duration *d = unsmob_duration ($1);
- Duration k (d->duration_log (), d->dot_count () + $2);
- *d = k;
- $$ = $1;
+ $$ = make_duration ($1, scm_to_int ($2));
}
;
multiplied_duration:
- steno_duration {
- $$ = $1;
- }
- | multiplied_duration '*' bare_unsigned {
- $$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
- }
- | multiplied_duration '*' FRACTION {
- Rational m (scm_to_int (scm_car ($3)), scm_to_int (scm_cdr ($3)));
-
- $$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
- }
- ;
-
-fraction:
- FRACTION { $$ = $1; }
- | UNSIGNED '/' UNSIGNED {
- $$ = scm_cons (scm_int2num ($1), scm_int2num ($3));
+ steno_duration multipliers {
+ $$ = make_duration ($1, 0, $2);
}
;
dots:
/* empty */ {
- $$ = 0;
+ $$ = SCM_INUM0;
}
| dots '.' {
- $$ ++;
+ $$ = scm_oneplus ($1);
+ }
+ ;
+
+multipliers:
+ /* empty */
+ {
+ $$ = SCM_UNDEFINED;
+ }
+ | multipliers '*' UNSIGNED
+ {
+ if (!SCM_UNBNDP ($1))
+ $$ = scm_product ($1, $3);
+ else
+ $$ = $3;
+ }
+ | multipliers '*' FRACTION
+ {
+ if (!SCM_UNBNDP ($1))
+ $$ = scm_product ($1, scm_divide (scm_car ($3),
+ scm_cdr ($3)));
+ else
+ $$ = scm_divide (scm_car ($3), scm_cdr ($3));
}
;
tremolo_type:
':' {
- $$ = 0;
+ $$ = scm_from_int (parser->default_tremolo_type_);
}
- | ':' bare_unsigned {
- if (!is_duration ($2))
- THIS->parser_error (@2, _f ("not a duration: %d", $2));
- $$ = $2;
+ | ':' UNSIGNED {
+ if (SCM_UNBNDP (make_duration ($2))) {
+ parser->parser_error (@2, _ ("not a duration"));
+ $$ = scm_from_int (parser->default_tremolo_type_);
+ } else {
+ $$ = $2;
+ parser->default_tremolo_type_ = scm_to_int ($2);
+ }
}
;
bass_number:
- DIGIT {
- $$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
- $$ = scm_list_2 (ly_lily_module_constant ("number-markup"),
- $$);
- }
- | UNSIGNED {
- $$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
- $$ = scm_list_2 (ly_lily_module_constant ("number-markup"),
- $$);
+ UNSIGNED
+ | STRING
+ | SYMBOL
+ | full_markup
+ | 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;
+ }
}
- | STRING { $$ = $1; }
;
-bass_mod:
- '-' { $$ = -2; }
- | '+' { $$ = 2; }
- | '!' { $$ = 0; }
+figured_bass_alteration:
+ '-' { $$ = ly_rational2scm (FLAT_ALTERATION); }
+ | '+' { $$ = ly_rational2scm (SHARP_ALTERATION); }
+ | '!' { $$ = scm_from_int (0); }
;
bass_figure:
FIGURE_SPACE {
- Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
- $$ = bfr->self_scm ();
- scm_gc_unprotect_object ($$);
+ Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent", @$);
+ $$ = bfr->unprotect ();
}
| bass_number {
- Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
+ Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent", @$);
$$ = bfr->self_scm ();
- bfr->set_property ("figure", $1);
+ if (scm_is_number ($1))
+ bfr->set_property ("figure", $1);
+ else if (Text_interface::is_markup ($1))
+ bfr->set_property ("text", $1);
- scm_gc_unprotect_object ($$);
+ bfr->unprotect ();
+ }
+ | bass_figure ']' {
+ $$ = $1;
+ unsmob<Music> ($1)->set_property ("bracket-stop", SCM_BOOL_T);
}
- | bass_figure bass_mod {
- Music *m = unsmob_music ($1);
- if ($2) {
+ | bass_figure figured_bass_alteration {
+ Music *m = unsmob<Music> ($1);
+ if (scm_to_double ($2)) {
SCM salter = m->get_property ("alteration");
- int alter = scm_is_number (salter) ? scm_to_int (salter) : 0;
+ SCM alter = scm_is_number (salter) ? salter : scm_from_int (0);
m->set_property ("alteration",
- scm_int2num (alter + $2));
+ scm_sum (alter, $2));
} else {
- m->set_property ("alteration", scm_int2num (0));
+ m->set_property ("alteration", scm_from_int (0));
}
}
+ | bass_figure figured_bass_modification {
+ Music *m = unsmob<Music> ($1);
+ m->set_property ($2, SCM_BOOL_T);
+ }
;
-br_bass_figure:
- '[' bass_figure {
- $$ = $2;
- unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
+
+figured_bass_modification:
+ E_PLUS {
+ $$ = ly_symbol2scm ("augmented");
}
- | bass_figure {
- $$ = $1;
+ | E_EXCLAMATION {
+ $$ = ly_symbol2scm ("no-continuation");
+ }
+ | '/' {
+ $$ = ly_symbol2scm ("diminished");
+ }
+ | E_BACKSLASH {
+ $$ = ly_symbol2scm ("augmented-slash");
}
- | br_bass_figure ']' {
+ ;
+
+br_bass_figure:
+ bass_figure {
$$ = $1;
- unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
+ }
+ | '[' bass_figure {
+ $$ = $2;
+ unsmob<Music> ($$)->set_property ("bracket-start", SCM_BOOL_T);
}
;
}
;
-figure_spec:
- FIGURE_OPEN figure_list FIGURE_CLOSE {
- Music *m = MY_MAKE_MUSIC ("EventChord");
- $2 = scm_reverse_x ($2, SCM_EOL);
- m->set_property ("elements", $2);
- $$ = m->self_scm ();
- }
- ;
-
-
optional_rest:
- /**/ { $$ = 0; }
- | REST { $$ = 1; }
+ /**/ { $$ = SCM_BOOL_F; }
+ | REST { $$ = SCM_BOOL_T; }
;
-simple_element:
- pitch exclamations questions octave_check optional_notemode_duration optional_rest {
- if (!THIS->lexer_->is_note_state ())
- THIS->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_or_music:
+ pitch exclamations questions octave_check maybe_notemode_duration optional_rest post_events {
+ if (!parser->lexer_->is_note_state ())
+ parser->parser_error (@1, _ ("have to be in Note mode for notes"));
+ if (!SCM_UNBNDP ($2)
+ || !SCM_UNBNDP ($3)
+ || scm_is_number ($4)
+ || !SCM_UNBNDP ($5)
+ || scm_is_true ($6)
+ || scm_is_pair ($7))
{
- int q = scm_to_int ($4);
- n->set_property ("absolute-octave", scm_int2num (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);
+ Music *n = 0;
+ if (scm_is_true ($6))
+ n = MY_MAKE_MUSIC ("RestEvent", @$);
+ else
+ n = MY_MAKE_MUSIC ("NoteEvent", @$);
+
+ n->set_property ("pitch", $1);
+ if (SCM_UNBNDP ($5))
+ n->set_property ("duration",
+ parser->default_duration_.smobbed_copy ());
+ else
+ n->set_property ("duration", $5);
+
+ if (scm_is_number ($4))
+ {
+ int q = scm_to_int ($4);
+ n->set_property ("absolute-octave", scm_from_int (q-1));
+ }
- Music *v = MY_MAKE_MUSIC ("EventChord");
- v->set_property ("elements", scm_list_1 (n->self_scm ()));
- scm_gc_unprotect_object (n->self_scm ());
+ if (to_boolean ($3))
+ n->set_property ("cautionary", SCM_BOOL_T);
+ if (to_boolean ($2) || to_boolean ($3))
+ n->set_property ("force-accidental", SCM_BOOL_T);
+ if (scm_is_pair ($7))
+ n->set_property ("articulations",
+ scm_reverse_x ($7, SCM_EOL));
+ $$ = n->unprotect ();
+ }
+ } %prec ':'
+ | new_chord post_events {
+ if (!parser->lexer_->is_chord_state ())
+ parser->parser_error (@1, _ ("have to be in Chord mode for chords"));
+ if (scm_is_pair ($2)) {
+ if (unsmob<Pitch> ($1))
+ $1 = make_chord_elements (@1,
+ $1,
+ parser->default_duration_.smobbed_copy (),
+ SCM_EOL);
+
+ SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
+
+ $$ = MAKE_SYNTAX (event_chord, @1, elts);
+ } else if (!unsmob<Pitch> ($1))
+ $$ = MAKE_SYNTAX (event_chord, @1, $1);
+ // A mere pitch drops through.
+ } %prec ':'
+ ;
- v->set_spot (@$);
- n->set_spot (@$);
- $$ = v;
- }
- | DRUM_PITCH optional_notemode_duration {
- Music *n = MY_MAKE_MUSIC ("NoteEvent");
+simple_element:
+ DRUM_PITCH optional_notemode_duration {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
n->set_property ("duration", $2);
n->set_property ("drum-type", $1);
- Music *v = MY_MAKE_MUSIC ("EventChord");
- v->set_property ("elements", scm_list_1 (n->self_scm ()));
- scm_gc_unprotect_object (n->self_scm ());
- v->set_spot (@$);
- n->set_spot (@$);
- $$ = v;
-
- }
- | figure_spec optional_notemode_duration {
- Music *m = unsmob_music ($1);
- m->set_spot (@$);
- for (SCM s = m->get_property ("elements"); scm_is_pair (s); s = scm_cdr (s))
- {
- unsmob_music (scm_car (s))->set_property ("duration", $2);
- }
- $$ = m;
- }
+ $$ = n->unprotect ();
+ }
| RESTNAME optional_notemode_duration {
Music *ev = 0;
if (ly_scm2string ($1) == "s") {
/* Space */
- ev = MY_MAKE_MUSIC ("SkipEvent");
+ ev = MY_MAKE_MUSIC ("SkipEvent", @$);
}
else {
- ev = MY_MAKE_MUSIC ("RestEvent");
-
+ ev = MY_MAKE_MUSIC ("RestEvent", @$);
+
}
ev->set_property ("duration", $2);
- ev->set_spot (@$);
- Music *velt = MY_MAKE_MUSIC ("EventChord");
- velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
- velt->set_spot (@$);
-
- scm_gc_unprotect_object (ev->self_scm ());
-
- $$ = velt;
- }
- | MULTI_MEASURE_REST optional_notemode_duration {
- SCM proc = ly_lily_module_constant ("make-multi-measure-rest");
- SCM mus = scm_call_2 (proc, $2, make_input (@$));
- scm_gc_protect_object (mus);
- $$ = unsmob_music (mus);
- }
-
- | lyric_element optional_notemode_duration {
- if (!THIS->lexer_->is_lyric_state ())
- THIS->parser_error (@1, _ ("Have to be in Lyric mode for lyrics"));
-
- Music *lreq = MY_MAKE_MUSIC ("LyricEvent");
- lreq->set_property ("text", $1);
- lreq->set_property ("duration",$2);
- lreq->set_spot (@$);
- Music *velt = MY_MAKE_MUSIC ("EventChord");
- velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
-
- $$= velt;
- }
- | new_chord {
- if (!THIS->lexer_->is_chord_state ())
- THIS->parser_error (@1, _ ("Have to be in Chord mode for chords"));
- $$ = unsmob_music ($1);
+ $$ = ev->unprotect ();
}
;
lyric_element:
- /* FIXME: lyric flavoured markup would be better */
full_markup {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _ ("markup outside of text script or \\lyricmode"));
+ $$ = $1;
+ }
+ | SYMBOL {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _f ("not a note name: %s", ly_scm2string ($1)));
$$ = $1;
}
- | LYRICS_STRING {
- $$ = make_simple_markup ($1);
+ | STRING {
+ if (!parser->lexer_->is_lyric_state ())
+ parser->parser_error (@1, _ ("string outside of text script or \\lyricmode"));
+ $$ = $1;
}
+ | LYRIC_ELEMENT
+ ;
+
+lyric_element_music:
+ lyric_element optional_notemode_duration post_events {
+ $$ = MAKE_SYNTAX (lyric_event, @$, $1, $2);
+ if (scm_is_pair ($3))
+ unsmob<Music> ($$)->set_property
+ ("articulations", scm_reverse_x ($3, SCM_EOL));
+ } %prec ':'
;
+// Can return a single pitch rather than a list.
new_chord:
- steno_tonic_pitch optional_notemode_duration {
- $$ = make_chord ($1, $2, SCM_EOL);
+ steno_tonic_pitch maybe_notemode_duration {
+ if (SCM_UNBNDP ($2))
+ $$ = $1;
+ else
+ $$ = make_chord_elements (@$, $1, $2, SCM_EOL);
}
| steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
SCM its = scm_reverse_x ($4, SCM_EOL);
- $$ = make_chord ($1, $2, scm_cons ($3, its));
- }
+ $$ = make_chord_elements (@$, $1, $2, scm_cons ($3, its));
+ } %prec ':'
;
chord_items:
/**/ {
- $$ = SCM_EOL;
+ $$ = SCM_EOL;
}
| chord_items chord_item {
$$ = scm_cons ($2, $$);
;
step_number:
- bare_unsigned {
+ UNSIGNED {
$$ = make_chord_step ($1, 0);
}
- | bare_unsigned '+' {
- $$ = make_chord_step ($1, SHARP);
+ | UNSIGNED '+' {
+ $$ = make_chord_step ($1, SHARP_ALTERATION);
+ }
+ | UNSIGNED CHORD_MINUS {
+ $$ = make_chord_step ($1, FLAT_ALTERATION);
}
- | bare_unsigned CHORD_MINUS {
- $$ = make_chord_step ($1, FLAT);
+ ;
+
+tempo_range:
+ unsigned_number {
+ $$ = $1;
+ } %prec ':'
+ | unsigned_number '-' unsigned_number {
+ $$ = scm_cons ($1, $3);
}
- ;
+ ;
/*
UTILITIES
| bare_number
;
-
-bare_number:
- UNSIGNED {
- $$ = scm_int2num ($1);
- }
- | REAL {
- $$ = $1;
- }
- | NUMBER_IDENTIFIER {
- $$ = $1;
- }
- | REAL NUMBER_IDENTIFIER {
- $$ = scm_make_real (scm_to_double ($1) *scm_to_double ($2));
- }
- | UNSIGNED NUMBER_IDENTIFIER {
- $$ = scm_make_real ($1 *scm_to_double ($2));
+bare_number_common:
+ REAL
+ | NUMBER_IDENTIFIER
+ | REAL NUMBER_IDENTIFIER
+ {
+ $$ = scm_product ($1, $2);
}
;
-
-bare_unsigned:
- UNSIGNED {
- $$ = $1;
- }
- | DIGIT {
- $$ = $1;
+bare_number:
+ bare_number_common
+ | UNSIGNED
+ | UNSIGNED NUMBER_IDENTIFIER {
+ $$ = scm_product ($1, $2);
}
;
-bare_int:
- bare_number {
- if (scm_integer_p ($1) == SCM_BOOL_T)
- {
- int k = scm_to_int ($1);
- $$ = k;
- } else
+unsigned_number:
+ UNSIGNED
+ | NUMBER_IDENTIFIER
+ {
+ if (!scm_is_integer ($1)
+ || scm_is_true (scm_negative_p ($1)))
{
- THIS->parser_error (@1, _ ("need integer number arg"));
- $$ = 0;
+ parser->parser_error (@1, _("not an unsigned integer"));
+ $$ = SCM_INUM0;
}
}
- | '-' bare_int {
- $$ = -$2;
+ | embedded_scm
+ {
+ if (!scm_is_integer ($1)
+ || scm_is_true (scm_negative_p ($1)))
+ {
+ parser->parser_error (@1, _("not an unsigned integer"));
+ $$ = SCM_INUM0;
+ }
}
;
exclamations:
- { $$ = 0; }
- | exclamations '!' { $$ ++; }
+ { $$ = SCM_UNDEFINED; }
+ | exclamations '!'
+ {
+ if (SCM_UNBNDP ($1))
+ $$ = SCM_BOOL_T;
+ else
+ $$ = scm_not ($1);
+ }
;
questions:
- { $$ = 0; }
- | questions '?' { $$ ++; }
+// This precedence rule is rather weird. It triggers when '!' is
+// encountered after a pitch, and is used for deciding whether to save
+// this instead for a figure modification. This should not actually
+// occur in practice as pitches and figures are generated in different
+// modes. Using a greedy (%right) precedence makes sure that we don't
+// get stuck in a wrong interpretation.
+ { $$ = SCM_UNDEFINED; } %prec ':'
+ | questions '?'
+ {
+ if (SCM_UNBNDP ($1))
+ $$ = SCM_BOOL_T;
+ else
+ $$ = scm_not ($1);
+ }
+ ;
+
+full_markup_list:
+ MARKUPLIST
+ { parser->lexer_->push_markup_state (); }
+ markup_list {
+ $$ = $3;
+ parser->lexer_->pop_state ();
+ }
+ ;
+
+markup_mode:
+ MARKUP
+ {
+ parser->lexer_->push_markup_state ();
+ }
+ ;
+
+// Sort-of ugly: We need this as markup of its own as well as in
+// markup function assignments, without triggering lookahead or the
+// '=' for assignments will be parsed in markup mode and not
+// recognized. Worse: the next token following something like
+// \markup "string" would be parsed in markup mode as well.
+//
+// So we make a single production here that's used either in markup or
+// in assignment.
+
+markup_mode_word:
+ markup_mode markup_word
+ {
+ $$ = $2;
+ parser->lexer_->pop_state ();
+ }
;
-/*
-This should be done more dynamically if possible.
-*/
full_markup:
- MARKUP_IDENTIFIER {
- $$ = $1;
+ markup_mode markup_top {
+ $$ = $2;
+ parser->lexer_->pop_state ();
}
- | MARKUP
- { THIS->lexer_->push_markup_state (); }
- markup_top {
- $$ = $3;
- THIS->lexer_->pop_state ();
+ | markup_mode_word
+ {
+ $$ = make_simple_markup ($1);
+ }
+ ;
+
+partial_markup:
+ markup_mode markup_partial_function ETC
+ {
+ $$ = MAKE_SYNTAX (partial_markup, @2, $2);
+ parser->lexer_->pop_state ();
}
;
markup_top:
- markup_list {
- $$ = scm_list_2 (ly_lily_module_constant ("line-markup"), $1);
+ markup_list {
+ $$ = scm_list_2 (Lily::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 {
+ | simple_markup_noword {
$$ = $1;
}
;
+markup_scm:
+ embedded_scm
+ {
+ 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:
markup_composed_list {
$$ = $1;
}
- | markup_braced_list {
+ | markup_uncomposed_list
+ ;
+
+markup_uncomposed_list:
+ markup_braced_list {
$$ = $1;
}
+ | markup_command_list {
+ $$ = scm_list_1 ($1);
+ }
+ | markup_scm MARKUPLIST_IDENTIFIER
+ {
+ $$ = $2;
+ }
+ | SCORELINES {
+ parser->lexer_->push_note_state (Lily::pitchnames);
+ } '{' score_body '}' {
+ Score *sc = unsmob<Score> ($4);
+ sc->origin ()->set_spot (@$);
+ if (sc->defs_.empty ()) {
+ Output_def *od = get_layout (parser);
+ sc->add_output_def (od);
+ od->unprotect ();
+ }
+ $$ = scm_list_1 (scm_list_2 (Lily::score_lines_markup_list, $4));
+ parser->lexer_->pop_state ();
+ }
;
markup_composed_list:
- markup_head_1_list markup_braced_list {
- $$ = scm_call_2 (ly_lily_module_constant ("map-markup-command-list"), $1, $2);
-
+ markup_head_1_list markup_uncomposed_list {
+ $$ = MAKE_SYNTAX (composed_markup_list,
+ @2, $1, $2);
}
;
;
markup_braced_list_body:
- /* empty */ { $$ = scm_list (SCM_EOL); }
+ /* empty */ { $$ = SCM_EOL; }
| markup_braced_list_body markup {
$$ = scm_cons ($2, $1);
}
| markup_braced_list_body markup_list {
- $$ = scm_append_x (scm_list_2 (scm_reverse_x ($2, SCM_EOL), $1));
+ $$ = scm_reverse_x ($2, $1);
}
;
-markup_head_1_item:
- MARKUP_HEAD_MARKUP0 {
- $$ = scm_list_1 ($1);
+markup_command_list:
+ MARKUP_LIST_FUNCTION markup_command_list_arguments {
+ $$ = scm_cons ($1, scm_reverse_x($2, SCM_EOL));
}
- | MARKUP_HEAD_SCM0_MARKUP1 embedded_scm {
- $$ = scm_list_2 ($1, $2);
+ ;
+
+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 {
+ $$ = check_scheme_arg (parser, @3, $3, $2, $1);
+ }
+ | EXPECT_NO_MORE_ARGS {
+ $$ = SCM_EOL;
+ }
+ ;
+
+markup_command_list_arguments:
+ markup_command_basic_arguments { $$ = $1; }
+ | EXPECT_MARKUP markup_command_list_arguments markup {
+ $$ = scm_cons ($3, $2);
+ }
+ ;
+
+markup_partial_function:
+ MARKUP_FUNCTION markup_arglist_partial
+ {
+ $$ = scm_list_1 (scm_cons ($1, scm_reverse_x ($2, SCM_EOL)));
+ }
+ | markup_head_1_list MARKUP_FUNCTION markup_arglist_partial
+ {
+ $$ = scm_cons (scm_cons ($2, scm_reverse_x ($3, SCM_EOL)),
+ $1);
+ }
+ ;
+
+markup_arglist_partial:
+ EXPECT_MARKUP markup_arglist_partial
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM markup_arglist_partial
+ {
+ $$= $2;
}
- | MARKUP_HEAD_SCM0_SCM1_MARKUP2 embedded_scm embedded_scm {
- $$ = scm_list_3 ($1, $2, $3);
+ | EXPECT_MARKUP markup_command_list_arguments
+ {
+ $$ = $2;
+ }
+ | EXPECT_SCM markup_command_list_arguments
+ {
+ $$ = $2;
+ }
+ ;
+
+markup_head_1_item:
+ MARKUP_FUNCTION EXPECT_MARKUP markup_command_list_arguments {
+ $$ = scm_cons ($1, scm_reverse_x ($3, SCM_EOL));
}
;
}
;
+markup_word:
+ STRING
+ | SYMBOL
+ ;
+
simple_markup:
- STRING {
+ markup_word
+ {
$$ = make_simple_markup ($1);
}
- | MARKUP_IDENTIFIER {
- $$ = $1;
- }
- | STRING_IDENTIFIER {
- $$ = $1;
- }
- | SCORE {
- SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
- THIS->lexer_->push_note_state (alist_to_hashq (nn));
+ | simple_markup_noword
+ ;
+
+simple_markup_noword:
+ SCORE {
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' score_body '}' {
- Score * sc = $4;
- $$ = scm_list_2 (ly_lily_module_constant ("score-markup"), sc->self_scm ());
- scm_gc_unprotect_object (sc->self_scm ());
- THIS->lexer_->pop_state ();
- }
- | MARKUP_HEAD_SCM0 embedded_scm {
- $$ = scm_list_2 ($1, $2);
- }
- | MARKUP_HEAD_SCM0_SCM1_SCM2 embedded_scm embedded_scm embedded_scm {
- $$ = scm_list_4 ($1, $2, $3, $4);
- }
- | MARKUP_HEAD_SCM0_SCM1 embedded_scm embedded_scm {
- $$ = scm_list_3 ($1, $2, $3);
- }
- | MARKUP_HEAD_EMPTY {
- $$ = scm_list_1 ($1);
+ Score *sc = unsmob<Score> ($4);
+ sc->origin ()->set_spot (@$);
+ if (sc->defs_.empty ()) {
+ Output_def *od = get_layout (parser);
+ sc->add_output_def (od);
+ od->unprotect ();
+ }
+ $$ = scm_list_2 (Lily::score_markup, $4);
+ parser->lexer_->pop_state ();
}
- | MARKUP_HEAD_LIST0 markup_list {
- $$ = scm_list_2 ($1,$2);
+ | MARKUP_FUNCTION markup_command_basic_arguments {
+ $$ = scm_cons ($1, scm_reverse_x ($2, SCM_EOL));
}
- | MARKUP_HEAD_MARKUP0_MARKUP1 markup markup {
- $$ = scm_list_3 ($1, $2, $3);
+ | markup_scm MARKUP_IDENTIFIER
+ {
+ $$ = $2;
}
;
-
+
markup:
- 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;
%%
void
-Lily_parser::set_yydebug (bool )
+Lily_parser::set_yydebug (bool x)
{
-#if 0
- yydebug = 1;
-#endif
+ yydebug = x;
}
-void
+SCM
Lily_parser::do_yyparse ()
{
- yyparse ((void*)this);
+ return scm_c_with_fluid (Lily::f_parser,
+ self_scm (),
+ do_yyparse_trampoline,
+ static_cast <void *>(this));
}
-
-/*
-Should make this optional? It will also complain when you do
-
- [s4]
-
-which is entirely legitimate.
-
-Or we can scrap it. Barchecks should detect wrong durations, and
-skipTypesetting speeds it up a lot.
-*/
-
-void
-Lily_parser::beam_check (SCM dur)
+SCM
+Lily_parser::do_yyparse_trampoline (void *parser)
{
- Duration *d = unsmob_duration (dur);
- if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
- {
- Music *m = unsmob_music (last_beam_start_);
- m->origin ()->warning (_ ("Suspect duration found following this beam"));
- }
- last_beam_start_ = SCM_EOL;
+ SCM retval = SCM_UNDEFINED;
+ yyparse (static_cast <Lily_parser *>(parser), &retval);
+ return retval;
}
-
/*
It is a little strange to have this function in this file, but
int
Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
{
- if (scm_is_string (sid)) {
- *destination = sid;
- return STRING_IDENTIFIER;
+ if (unsmob<Book> (sid)) {
+ Book *book = unsmob<Book> (sid)->clone ();
+ *destination = book->self_scm ();
+ book->unprotect ();
+
+ return BOOK_IDENTIFIER;
} else if (scm_is_number (sid)) {
*destination = sid;
return NUMBER_IDENTIFIER;
- } else if (unsmob_context_def (sid)) {
- *destination = unsmob_context_def (sid)->clone_scm ();
- return CONTEXT_DEF_IDENTIFIER;
- } else if (unsmob_score (sid)) {
- Score *score = new Score (*unsmob_score (sid));
- *destination = score->self_scm ();
- return SCORE_IDENTIFIER;
- } else if (Music *mus = unsmob_music (sid)) {
+ } else if (unsmob<Context_def> (sid))
+ {
+ *destination = unsmob<Context_def> (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (unsmob<Context_mod> (sid)) {
+ *destination = unsmob<Context_mod> (sid)->smobbed_copy ();
+ return SCM_IDENTIFIER;
+ } else if (Music *mus = unsmob<Music> (sid)) {
mus = mus->clone ();
*destination = mus->self_scm ();
- unsmob_music (*destination)->
- set_property ("origin", make_input (last_input_));
- return dynamic_cast<Event*> (mus)
- ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
- } else if (unsmob_duration (sid)) {
- *destination = unsmob_duration (sid)->smobbed_copy ();
+ 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;
- } else if (unsmob_output_def (sid)) {
- Output_def *p = unsmob_output_def (sid);
- p = p->clone ();
-
- *destination = p->self_scm ();
- return OUTPUT_DEF_IDENTIFIER;
- } else if (Text_interface::markup_p (sid)) {
+ } else if (unsmob<Output_def> (sid)) {
+ *destination = unsmob<Output_def> (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (unsmob<Score> (sid)) {
+ *destination = unsmob<Score> (sid)->clone ()->unprotect ();
+ return SCM_IDENTIFIER;
+ } else if (scm_is_pair (sid)
+ && scm_is_pair (scm_car (sid))
+ && scm_is_true (Lily::key_p (scm_caar (sid)))) {
*destination = sid;
- return MARKUP_IDENTIFIER;
+ return LOOKUP_IDENTIFIER;
}
+ return -1;
+}
- return -1;
+SCM
+get_next_unique_context_id ()
+{
+ return scm_from_ascii_string ("$uniqueContextId");
}
-Music *
-property_op_to_music (SCM op)
+
+SCM
+get_next_unique_lyrics_context_id ()
{
- Music *m = 0;
- SCM tag = scm_car (op);
- SCM symbol = scm_cadr (op);
- SCM args = scm_cddr (op);
- SCM grob_val = SCM_UNDEFINED;
- SCM grob_sym = SCM_UNDEFINED;
- SCM val = SCM_UNDEFINED;
-
- if (tag == ly_symbol2scm ("assign"))
- {
- m = MY_MAKE_MUSIC ("PropertySet");
- val = scm_car (args);
- }
- else if (tag == ly_symbol2scm ("unset"))
- m = MY_MAKE_MUSIC ("PropertyUnset");
- else if (tag == ly_symbol2scm ("poppush")
- || tag == ly_symbol2scm ("push"))
- {
- m = MY_MAKE_MUSIC ("OverrideProperty");
- grob_sym = scm_car (args);
- grob_val = scm_cadr (args);
- }
- else if (tag == ly_symbol2scm ("pop")) {
- m = MY_MAKE_MUSIC ("RevertProperty");
- grob_sym = scm_car (args);
- }
+ static int new_context_count;
+ char s[128];
+ snprintf (s, sizeof (s)-1, "uniqueContext%d", new_context_count++);
+ return scm_from_ascii_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 disp)
+{
+ 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,
+ SCM_UNBNDP (disp) ? arg : disp);
+ scm_set_cdr_x (scm_last_pair (args), SCM_BOOL_F);
+ return args;
+}
+
+SCM loc_on_copy (Lily_parser *parser, Input loc, SCM arg)
+{
+ if (Music *m = unsmob<Music> (arg))
+ {
+ m = m->clone ();
+ m->set_spot (parser->lexer_->override_input (loc));
+ return m->unprotect ();
+ }
+ if (Book *b = unsmob<Book> (arg))
+ {
+ b = b->clone ();
+ b->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return b->unprotect ();
+ }
+ if (Context_def *cd = unsmob<Context_def> (arg))
+ {
+ cd = cd->clone ();
+ cd->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return cd->unprotect ();
+ }
+ if (Output_def *od = unsmob<Output_def> (arg))
+ {
+ od = od->clone ();
+ od->input_origin_ = parser->lexer_->override_input (loc);
+ return od->unprotect ();
+ }
+ if (Score *s = unsmob<Score> (arg))
+ {
+ s = s->clone ();
+ s->origin ()->set_spot (parser->lexer_->override_input (loc));
+ return s->unprotect ();
+ }
+ if (Context_mod *cm = unsmob<Context_mod> (arg))
+ {
+ return cm->smobbed_copy ();
+ }
+ return arg;
+}
+
+SCM
+make_reverse_key_list (SCM keys)
+{
+ if (scm_is_true (Lily::key_p (keys)))
+ return scm_list_1 (keys);
+ if (scm_is_string (keys))
+ return scm_list_1 (scm_string_to_symbol (keys));
+ if (!ly_is_list (keys))
+ return SCM_UNDEFINED;
+ SCM res = SCM_EOL;
+ for (; scm_is_pair (keys); keys = scm_cdr (keys))
+ {
+ SCM elt = scm_car (keys);
+ if (scm_is_true (Lily::key_p (elt)))
+ res = scm_cons (elt, res);
+ else if (scm_is_string (elt))
+ res = scm_cons (scm_string_to_symbol (elt), res);
+ else return SCM_UNDEFINED;
+ }
+ return res;
+}
+
+SCM
+try_string_variants (SCM pred, SCM str)
+{
+ // a matching predicate is always ok
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+ // a key may be interpreted as a list of keys if it helps
+ if (scm_is_true (Lily::key_p (str))) {
+ str = scm_list_1 (str);
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+ return SCM_UNDEFINED;
+ }
+
+ if (!scm_is_string (str))
+ return SCM_UNDEFINED;
+
+ // Let's attempt the symbol list interpretation first.
+
+ str = scm_string_to_symbol (str);
+
+ SCM lst = scm_list_1 (str);
+
+ if (scm_is_true (scm_call_1 (pred, lst)))
+ return lst;
+
+ // Try the single symbol interpretation
+
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+
+ return SCM_UNDEFINED;
+}
+
+SCM
+try_word_variants (SCM pred, SCM str)
+{
+ // str is always a string when we come here
+
+ if (scm_is_true (scm_call_1 (pred, str)))
+ return str;
+
+ // If this cannot be a string representation of a symbol list,
+ // we are through.
- m->set_property ("symbol", symbol);
+ if (!is_regular_identifier (str, true))
+ return SCM_UNDEFINED;
- if (val != SCM_UNDEFINED)
- m->set_property ("value", val);
- if (grob_val != SCM_UNDEFINED)
- m->set_property ("grob-value", grob_val);
+ str = scm_string_split (str, SCM_MAKE_CHAR ('.'));
+ for (SCM p = str; scm_is_pair (p); p = scm_cdr (p))
+ scm_set_car_x (p, scm_string_split (scm_car (p),
+ SCM_MAKE_CHAR (',')));
+ str = scm_append_x (str);
+ for (SCM p = str; scm_is_pair (p); p = scm_cdr (p))
+ scm_set_car_x (p, scm_string_to_symbol (scm_car (p)));
- if (grob_sym != SCM_UNDEFINED)
+ // 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, bool multiple)
+{
+ if (!scm_is_string (id))
+ return false;
+
+ string str = ly_scm2string (id);
+
+ 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 == '.' || 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 (scm_is_symbol (simple))
+ {
+ SCM out = SCM_UNDEFINED;
+ switch (parser->lexer_->scan_word (out, simple))
{
- bool itc = do_internal_type_checking_global;
- /* UGH.
- */
- bool autobeam = ly_c_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
- if (autobeam)
- do_internal_type_checking_global = false;
- m->set_property ("grob-property", grob_sym);
- if (autobeam)
- do_internal_type_checking_global = itc;
+ case DRUM_PITCH:
+ {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", parser->default_duration_.smobbed_copy ());
+ n->set_property ("drum-type", out);
+ return n->unprotect ();
}
+ case NOTENAME_PITCH:
+ case TONICNAME_PITCH:
+ // Take the parsed pitch
+ simple = out;
+ break;
+ // Don't scan CHORD_MODIFIER etc.
+ }
+ }
- if (tag == ly_symbol2scm ("poppush"))
- m->set_property ("pop-first", SCM_BOOL_T);
-
+ if (parser->lexer_->is_note_state ()) {
+ if (unsmob<Pitch> (simple)) {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", parser->default_duration_.smobbed_copy ());
+ n->set_property ("pitch", simple);
+ return n->unprotect ();
+ }
+ SCM d = simple;
+ if (scm_is_integer (simple))
+ d = make_duration (simple);
+ if (unsmob<Duration> (d)) {
+ Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
+ n->set_property ("duration", d);
+ return n->unprotect ();
+ }
+ return simple;
+ } else if (parser->lexer_->is_lyric_state ()) {
+ if (Text_interface::is_markup (simple))
+ return MAKE_SYNTAX (lyric_event, loc, simple,
+ parser->default_duration_.smobbed_copy ());
+ } else if (parser->lexer_->is_chord_state ()) {
+ if (unsmob<Pitch> (simple))
+ return MAKE_SYNTAX
+ (event_chord,
+ loc,
+ make_chord_elements (loc, simple,
+ parser->default_duration_.smobbed_copy (),
+ SCM_EOL));
+ }
+ return simple;
+}
- return m;
+Music *
+make_music_with_input (SCM name, Input where)
+{
+ Music *m = make_music_by_name (name);
+ m->set_spot (where);
+ return m;
}
-Music*
-context_spec_music (SCM type, SCM id, Music *m, SCM ops)
+SCM
+make_simple_markup (SCM a)
{
- Music *csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
+ return a;
+}
- csm->set_property ("element", m->self_scm ());
- scm_gc_unprotect_object (m->self_scm ());
+SCM
+make_duration (SCM d, int dots, SCM factor)
+{
+ Duration k;
+
+ if (Duration *dur = unsmob<Duration> (d)) {
+ if (!dots && SCM_UNBNDP (factor))
+ return d;
+ k = *dur;
+ if (dots)
+ k = Duration (k.duration_log (), k.dot_count () + dots)
+ .compressed (k.factor ());
+ } else {
+ int t = scm_to_int (d);
+ if (t > 0 && (t & (t-1)) == 0)
+ k = Duration (intlog2 (t), dots);
+ else
+ return SCM_UNDEFINED;
+ }
- csm->set_property ("context-type",
- scm_is_symbol (type) ? type : scm_string_to_symbol (type));
- csm->set_property ("property-operations", ops);
+ if (!SCM_UNBNDP (factor))
+ k = k.compressed (ly_scm2rational (factor));
- if (scm_is_string (id))
- csm->set_property ("context-id", id);
- return csm;
+ return k.smobbed_copy ();
}
SCM
-get_next_unique_context_id ()
+make_chord_step (SCM step_scm, Rational alter)
{
- return scm_makfrom0str ("$uniqueContextId");
+ Pitch m (0, scm_to_int (step_scm) - 1, alter);
+
+ // Notename/octave are normalized
+ if (m.get_notename () == 6)
+ m = m.transposed (Pitch (0, 0, FLAT_ALTERATION));
+
+ return m.smobbed_copy ();
}
SCM
-get_next_unique_lyrics_context_id ()
+make_chord_elements (Input loc, SCM pitch, SCM dur, SCM modification_list)
{
- static int new_context_count;
- char s[128];
- snprintf (s, 1024, "uniqueContext%d", new_context_count++);
- return scm_makfrom0str (s);
+ SCM res = Lily::construct_chord_elements (pitch, dur, modification_list);
+ for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
+ {
+ unsmob<Music> (scm_car (s))->set_spot (loc);
+ }
+ return res;
+}
+
+int
+yylex (YYSTYPE *s, YYLTYPE *loc, Lily_parser *parser)
+{
+ Lily_lexer *lex = parser->lexer_;
+
+ lex->lexval_ = s;
+ lex->lexloc_ = loc;
+ int tok = lex->pop_extra_token ();
+ if (tok >= 0)
+ return tok;
+ lex->prepare_for_next_token ();
+ return lex->yylex ();
}
projects / lilypond.git / blobdiff