#include "scm-hash.hh"
#include "warn.hh"
-const char * const All_font_metrics::type_p_name_ = 0;
-
Index_to_charcode_map const *
All_font_metrics::get_index_to_charcode_map (const string &filename,
int face_index,
}
-const char Book::type_p_name_[] = "ly:book?";
+const char * const Book::type_p_name_ = "ly:book?";
/****************************************************************/
-const char Box::type_p_name_[] = "ly:box?";
+const char * const Box::type_p_name_ = "ly:box?";
+++ /dev/null
-/*
- This file is part of LilyPond, the GNU music typesetter.
-
- Copyright (C) 2016 David Kastrup <dak@gnu.org>
-
- 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.
-
- 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 "callback.hh"
-
-const char * const Callback_wrapper::type_p_name_ = 0;
-const char * const Callback2_wrapper::type_p_name_ = 0;
-const char * const Callback0_wrapper::type_p_name_ = 0;
-const char * const Method_instance::type_p_name_ = 0;
{
}
-const char Context_def::type_p_name_[] = "ly:context-def?";
+const char * const Context_def::type_p_name_ = "ly:context-def?";
int
Context_def::print_smob (SCM port, scm_print_state *) const
mods_ = scm_reverse (mod_list);
}
-const char Context_mod::type_p_name_[] = "ly:context-mod?";
+const char * const Context_mod::type_p_name_ = "ly:context-mod?";
int
Context_mod::print_smob (SCM port, scm_print_state *) const
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
friend class Grob_property_info;
friend SCM ly_make_grob_properties (SCM);
cooked_ (alist), cooked_from_ (alist), nested_ (0) { }
};
-const char Grob_properties::type_p_name_[] = "ly:grob-properties?";
+const char * const Grob_properties::type_p_name_ = "ly:grob-properties?";
SCM
Grob_properties::mark_smob () const
return properties_scm_;
}
-const char Context::type_p_name_[] = "ly:context?";
+const char * const Context::type_p_name_ = "ly:context?";
Global_context *
Context::get_global_context () const
#include "warn.hh"
#include "lily-imports.hh"
-const char Dispatcher::type_p_name_[] = "ly:dispatcher?";
+const char * const Dispatcher::type_p_name_ = "ly:dispatcher?";
Dispatcher::~Dispatcher ()
{
return s;
}
-const char Duration::type_p_name_[] = "ly:duration?";
+const char * const Duration::type_p_name_ = "ly:duration?";
int
return 1;
}
-const char Font_metric::type_p_name_[] = "ly:font-metric?";
+const char * const Font_metric::type_p_name_ = "ly:font-metric?";
SCM
Font_metric::font_file_name () const
filter_map (map_fun);
}
-const char Grob_array::type_p_name_[] = "ly:grob-array?";
+const char * const Grob_array::type_p_name_ = "ly:grob-array?";
SCM
#include "warn.hh"
-const char Grob::type_p_name_[] = "ly:grob?";
+const char * const Grob::type_p_name_ = "ly:grob?";
SCM
Grob::mark_smob () const
All_font_metrics (All_font_metrics const &);
public:
- static const char * const type_p_name_; // = 0
SCM mark_smob () const;
Index_to_charcode_map const *get_index_to_charcode_map (const string &filename,
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Book ();
SCM header_;
Output_def *paper_;
class Box : public Simple_smob<Box>
{
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
Interval interval_a_[NO_AXES];
public:
: trampoline_ (trampoline)
{ } // Private constructor, use only in make_smob
public:
- static const char * const type_p_name_; // = 0
LY_DECLARE_SMOB_PROC (&Callback_wrapper::call, 2, 0, 0)
SCM call (SCM target, SCM arg)
{
: trampoline_ (trampoline)
{ } // Private constructor, use only in make_smob
public:
- static const char * const type_p_name_; // = 0
LY_DECLARE_SMOB_PROC (&Callback2_wrapper::call, 3, 0, 0)
SCM call (SCM target, SCM arg1, SCM arg2)
{
: trampoline_ (trampoline)
{ } // Private constructor, use only in make_smob
public:
- static const char * const type_p_name_; // = 0
LY_DECLARE_SMOB_PROC (&Callback0_wrapper::call, 1, 0, 0)
SCM call (SCM target)
{
{
SCM method_, instance_;
public:
- static const char * const type_p_name_; // = 0
LY_DECLARE_SMOB_PROC (&Method_instance::call, 0, 0, 1)
SCM call (SCM rest)
{
{
SCM mark_smob () const;
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Context_def ();
private:
/*
{
SCM mark_smob () const;
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
SCM mods_;
public:
public:
SCM mark_smob () const;
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Context ();
private:
Scheme_hash_table *properties_dict () const;
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Dispatcher ();
private:
/* Hash table. Each event-class maps to a list of listeners. */
{
static SCM equal_p (SCM, SCM);
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
Duration ();
Duration (int, int);
Duration (Rational, bool scale);
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Font_metric ();
private:
DECLARE_CLASSNAME (Font_metric);
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
vector<Grob *> grobs_;
bool ordered_;
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Grob ();
private:
DECLARE_CLASSNAME (Grob);
char const *end_;
Source_file *source_file_;
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
int print_smob (SCM, scm_print_state *) const;
static SCM equal_p (SCM, SCM);
SCM mark_smob () const;
extern Variable beat_structure;
extern Variable calc_repeat_slash_count;
extern Variable car_less;
+ extern Variable chordmodifiers;
extern Variable construct_chord_elements;
extern Variable default_time_signature_settings;
+ extern Variable drum_pitch_names;
extern Variable grob_compose_function;
extern Variable grob_offset_function;
extern Variable hash_table_to_alist;
#endif
extern Variable f_parser;
extern Variable percussion_p;
+ extern Variable pitchnames;
extern Variable pure_chain_offset_callback;
extern Variable remove_stencil_warnings;
extern Variable scale_layout;
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Lily_lexer ();
private:
int lookup_keyword (const string&);
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Lily_parser ();
Lily_lexer *lexer_;
Sources *sources_;
SCM callback_;
SCM target_;
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
Listener (SCM callback, SCM target)
: callback_ (callback), target_ (target) { }
public:
static SCM equal_p (SCM, SCM);
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
Moment ();
Moment (int m);
class Music_function : public Smob2<Music_function>
{
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
int print_smob (SCM, scm_print_state *) const;
SCM get_signature () const { return scm1 (); }
SCM get_function () const { return scm2 (); }
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Music_iterator ();
protected:
Moment music_length_;
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Music_output ();
private:
DECLARE_CLASSNAME (Music_output);
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Output_def ();
VIRTUAL_COPY_CONSTRUCTOR (Output_def, Output_def);
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Page_marker ();
private:
SCM symbol_; /* either 'page-turn-permission or 'page-break-permission */
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Paper_book ();
private:
SCM systems_;
class Paper_outputter : public Smob<Paper_outputter>
{
public:
- static const char * const type_p_name_; // = 0
SCM mark_smob () const;
virtual ~Paper_outputter ();
private:
static SCM equal_p (SCM, SCM);
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
int octave_;
int notename_;
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
static SCM equal_p (SCM, SCM);
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Prob ();
private:
DECLARE_CLASSNAME (Prob);
struct Scale : public Smob<Scale>
{
- static const char * const type_p_name_; // = 0
virtual ~Scale ();
Scale (vector<Rational> const &);
Scale (Scale const &);
class Scheme_hash_table : public Smob1<Scheme_hash_table>
{
public:
- static const char * const type_p_name_; // = 0
int print_smob (SCM, scm_print_state *) const;
bool try_retrieve (SCM key, SCM *val);
bool contains (SCM key) const;
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Score ();
private:
SCM music_;
class Skyline_pair : public Simple_smob<Skyline_pair>
{
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
Drul_array<Skyline> skylines_;
class Skyline : public Simple_smob<Skyline>
{
public:
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
list<Building> buildings_;
Direction sky_;
debugging purposes. If the class does not define this function,
the output will be #<Classname> when printing.
- - a static const type_p_name_[] string set to something like
+ - a static const * const type_p_name_ string set to something like
"ly:grob?". When provided, an accordingly named function for
checking for the given smob type will be available in Scheme.
// Most default functions are do-nothings. void init() will
// recognize their address when not overriden and will then refrain
// altogether from passing the the respective callbacks to GUILE.
+
SCM mark_smob (void) const;
static SCM mark_trampoline (SCM); // Used for calling mark_smob
static size_t free_smob (SCM obj);
static int print_trampoline (SCM, SCM, scm_print_state *);
static void smob_proc_init (scm_t_bits) { };
- // type_p_name_ has to be defined in the Super class, either with a
- // static const char [] string or as a null pointer of type const
- // char *. We used to provide a default here for convenience, but
- // battling the various conflicting C++ standards was too much of a
- // hassle.
+ // Define type_p_name_ in the Super class as a const char * const.
+ // Without such definition it defaults to 0, producing no predicate.
+
+ static const char * const type_p_name_; // = 0
// LY_DECLARE_SMOB_PROC is used in the Super class definition for
// making a smob callable like a function. Its first argument is a
template <class Super>
string Smob_base<Super>::smob_name_;
+template <class Super>
+const char * const Smob_base<Super>::type_p_name_ = 0;
+
template <class Super>
void Smob_base<Super>::init ()
{
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Source_file ();
private:
vector<char const *> newline_locations_;
{
public:
static SCM equal_p (SCM, SCM);
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
Real distance_;
Real min_distance_;
{
public:
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
Box dim_;
SCM expr_;
{
vector<Method_instance> dispatch_entries_;
public:
- static const char * const type_p_name_; // = 0
void apply (Grob_info);
SCM static create (SCM trans_list,
SCM iface_list, Direction);
public:
SCM mark_smob () const;
int print_smob (SCM, scm_print_state *) const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Translator_group ();
private:
void precompute_method_bindings ();
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
virtual ~Translator ();
private:
void init ();
class Unpure_pure_container : public Smob2<Unpure_pure_container>
{
public:
- static const char type_p_name_ [];
+ static const char * const type_p_name_;
SCM unpure_part () const { return scm1 (); }
// A container that has the same callback for both 'pure' and 'unpure' lookups
// and which ignores the 'start' and 'end' columnns.
/* Dummy input location for use if real one is missing. */
Input dummy_input_global;
-const char Input::type_p_name_[] = "ly:input-location?";
+const char * const Input::type_p_name_ = "ly:input-location?";
SCM
Input::mark_smob () const
Variable beat_structure ("beat-structure");
Variable calc_repeat_slash_count ("calc-repeat-slash-count");
Variable car_less ("car<");
+ Variable chordmodifiers ("chordmodifiers");
Variable construct_chord_elements ("construct-chord-elements");
Variable default_time_signature_settings ("default-time-signature-settings");
+ Variable drum_pitch_names ("drumPitchNames");
Variable grob_compose_function ("grob::compose-function");
Variable grob_offset_function ("grob::offset-function");
Variable hash_table_to_alist ("hash-table->alist");
#endif
Variable f_parser ("%parser");
Variable percussion_p ("percussion?");
+ Variable pitchnames ("pitchnames");
Variable pure_chain_offset_callback ("pure-chain-offset-callback");
Variable remove_stencil_warnings ("remove-stencil-warnings");
Variable scale_layout ("scale-layout");
}
-const char Lily_lexer::type_p_name_[] = "ly:lily-lexer?";
+const char * const Lily_lexer::type_p_name_ = "ly:lily-lexer?";
SCM
Lily_lexer::mark_smob () const
error_level_ = 1;
}
-const char Lily_parser::type_p_name_[] = "ly:lily-parser?";
+const char * const Lily_parser::type_p_name_ = "ly:lily-parser?";
/****************************************************************
OUTPUT-DEF
#include "listener.hh"
-const char Listener::type_p_name_[] = "ly:listener?";
+const char * const Listener::type_p_name_ = "ly:listener?";
}
-const char Moment::type_p_name_[] = "ly:moment?";
+const char * const Moment::type_p_name_ = "ly:moment?";
int
#include "fluid.hh"
#include "lily-imports.hh"
-const char Music_function::type_p_name_[] = "ly:music-function?";
+const char * const Music_function::type_p_name_ = "ly:music-function?";
/* Print a textual represenation of the smob to a given port. */
int
/****************************************************************/
-const char Music_iterator::type_p_name_[] = "ly:iterator?";
+const char * const Music_iterator::type_p_name_ = "ly:iterator?";
SCM
Music_iterator::mark_smob () const
{
}
-const char Music_output::type_p_name_[] = "ly:music-output?";
+const char * const Music_output::type_p_name_ = "ly:music-output?";
SCM
Music_output::mark_smob () const
void listen_note (Stream_event *);
void listen_breathing (Stream_event *);
+ void listen_tie (Stream_event *);
+ void listen_articulation (Stream_event *);
private:
- vector<Stream_event *> note_evs_;
+ vector<Stream_event *> note_evs_, script_evs_;
vector<Audio_note *> notes_;
vector<Audio_note *> last_notes_;
Moment last_start_;
-
};
void
Stream_event *tie_event = 0;
Moment len = get_event_length (n, now_mom ());
int velocity = 0;
+
+ for (vsize j = script_evs_.size (); j--;)
+ articulations = scm_cons (script_evs_[j]->self_scm (), articulations);
+
for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s))
{
Stream_event *ev = unsmob<Stream_event> (scm_car (s));
notes_.clear ();
note_evs_.clear ();
+ script_evs_.clear ();
}
void
note_evs_.push_back (ev);
}
+void
+Note_performer::listen_tie (Stream_event *ev)
+{
+ script_evs_.push_back (ev);
+}
+
+void
+Note_performer::listen_articulation (Stream_event *ev)
+{
+ script_evs_.push_back (ev);
+}
+
void
Note_performer::listen_breathing (Stream_event *ev)
{
{
ADD_LISTENER (Note_performer, note);
ADD_LISTENER (Note_performer, breathing);
+ ADD_LISTENER (Note_performer, tie);
+ ADD_LISTENER (Note_performer, articulation);
}
ADD_TRANSLATOR (Note_performer,
}
const char
-Output_def::type_p_name_[] = "ly:output-def?";
+* const Output_def::type_p_name_ = "ly:output-def?";
LY_DEFINE (ly_paper_outputscale, "ly:paper-outputscale",
1, 0, 0, (SCM def),
{
}
-const char Page_marker::type_p_name_[] = "ly:page-marker?";
+const char * const Page_marker::type_p_name_ = "ly:page-marker?";
SCM
Page_marker::mark_smob () const
{
}
-const char Paper_book::type_p_name_[] = "ly:paper-book?";
+const char * const Paper_book::type_p_name_ = "ly:paper-book?";
SCM
Paper_book::mark_smob () const
#include "lily-imports.hh"
-const char * const Paper_outputter::type_p_name_ = 0;
-
Paper_outputter::Paper_outputter (SCM port, const string &format)
{
file_ = port;
start_symbol:
lilypond
| EMBEDDED_LILY {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} embedded_lilypond {
parser->lexer_->pop_state ();
*retval = $3;
embedded_scm
|
{
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
}
composite_music
{
{
if (scm_is_pair ($1))
$1 = scm_car ($1);
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} music_or_context_def
{
parser->lexer_->pop_state ();
context_modification:
WITH
{
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' context_mod_list '}'
{
parser->lexer_->pop_state ();
mode_changing_head:
NOTEMODE {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
$$ = ly_symbol2scm ("notes");
}
| DRUMMODE
{
- SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("drums");
}
$$ = ly_symbol2scm ("figures");
}
| CHORDMODE {
- SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
- parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_chord_state (nn);
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("chords");
}
mode_changing_head_with_context:
DRUMS {
- SCM nn = parser->lexer_->lookup_identifier ("drumPitchNames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::drum_pitch_names);
$$ = ly_symbol2scm ("DrumStaff");
}
$$ = ly_symbol2scm ("FiguredBass");
}
| CHORDS {
- SCM nn = parser->lexer_->lookup_identifier ("chordmodifiers");
- parser->lexer_->chordmodifier_tab_ = alist_to_hashq (nn);
- nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_chord_state (nn);
+ parser->lexer_->chordmodifier_tab_ =
+ alist_to_hashq (Lily::chordmodifiers);
+ parser->lexer_->push_chord_state (Lily::pitchnames);
$$ = ly_symbol2scm ("ChordNames");
}
| LYRICS
$$ = $2;
}
| SCORELINES {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' score_body '}' {
Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
$$ = make_simple_markup ($1);
}
| SCORE {
- SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
- parser->lexer_->push_note_state (nn);
+ parser->lexer_->push_note_state (Lily::pitchnames);
} '{' score_body '}' {
Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
notename_ = notename;
}
-const char Pitch::type_p_name_[] = "ly:pitch?";
+const char * const Pitch::type_p_name_ = "ly:pitch?";
SCM
Pitch::mark_smob () const
#include "profile.hh"
-const char Prob::type_p_name_[] = "ly:prob?";
+const char * const Prob::type_p_name_ = "ly:prob?";
SCM
Prob::equal_p (SCM sa, SCM sb)
return SCM_UNSPECIFIED;
}
-const char * const Scale::type_p_name_ = 0;
-
int
Scale::step_count () const
{
#include <cassert>
-const char * const Scheme_hash_table::type_p_name_ = 0;
-
SCM
Scheme_hash_table::make_smob ()
{
{
}
-const char Score::type_p_name_[] = "ly:score?";
+const char * const Score::type_p_name_ = "ly:score?";
SCM
Score::mark_smob () const
return skylines_[d];
}
-const char Skyline_pair::type_p_name_[] = "ly:skyline-pair?";
+const char * const Skyline_pair::type_p_name_ = "ly:skyline-pair?";
MAKE_SCHEME_CALLBACK (Skyline_pair, skyline, 2);
/****************************************************************/
-const char Skyline::type_p_name_[] = "ly:skyline?";
+const char * const Skyline::type_p_name_ = "ly:skyline?";
MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Skyline, get_touching_point, 3, 1, "")
SCM
/****************************************************************/
-const char Source_file::type_p_name_[] = "ly:source-file?";
+const char * const Source_file::type_p_name_ = "ly:source-file?";
SCM
Source_file::mark_smob () const
return s->smobbed_copy ();
}
-const char Spring::type_p_name_[] = "ly:spring?";
+const char * const Spring::type_p_name_ = "ly:spring?";
return expr_;
}
-const char Stencil::type_p_name_[] = "ly:stencil?";
+const char * const Stencil::type_p_name_ = "ly:stencil?";
Interval
Stencil::extent (Axis a) const
#include "engraver.hh"
-const char * const Engraver_dispatch_list::type_p_name_ = 0;
-
void
Engraver_dispatch_list::apply (Grob_info gi)
{
}
-const char Translator_group::type_p_name_[] = "ly:translator-group?";
+const char * const Translator_group::type_p_name_ = "ly:translator-group?";
int
Translator_group::print_smob (SCM port, scm_print_state *) const
return daddy_context_->get_score_context ();
}
-const char Translator::type_p_name_[] = "ly:translator?";
+const char * const Translator::type_p_name_ = "ly:translator?";
bool
Translator::must_be_last () const
public:
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
- static const char type_p_name_[];
+ static const char * const type_p_name_;
private:
SCM object_;
public:
return 1;
}
-const char Undead::type_p_name_[] = "ly:undead?";
+const char * const Undead::type_p_name_ = "ly:undead?";
LY_DEFINE (ly_make_undead, "ly:make-undead",
1, 0, 0, (SCM object),
class Unpure_pure_call : public Smob1<Unpure_pure_call>
{
public:
- static const char * const type_p_name_; // = 0
// Smob procedures unfortunately can only take at most 3 SCM
// arguments. Otherwise we could use a "3, 0, 1" call signature and
// not require an argument count check of our own.
}
};
-const char * const Unpure_pure_call::type_p_name_ = 0;
-
SCM
Unpure_pure_container::pure_part () const
{
: scm2 ();
}
-const char Unpure_pure_container::type_p_name_[] = "ly:unpure-pure-container?";
+const char * const Unpure_pure_container::type_p_name_ = "ly:unpure-pure-container?";
LY_DEFINE (ly_make_unpure_pure_container, "ly:make-unpure-pure-container",
1, 1, 0, (SCM unpure, SCM pure),
;; for define-safe-public when byte-compiling using Guile V2
(use-modules (scm safe-utility-defs) (ice-9 receive))
+(define-session-public chordmodifiers '())
+
(define-public (construct-chord-elements root duration modifications)
"Build a chord on root using modifiers in @var{modifications}.
@code{NoteEvents} have duration @var{duration}.
(define (pitch= pitch1 pitch2)
(and (= (ly:pitch-notename pitch1) (ly:pitch-notename pitch2))
(= (ly:pitch-alteration pitch1) (ly:pitch-alteration pitch2))))
- (let* ((pitches (ly:parser-lookup 'pitchnames))
- (result (rassoc ly-pitch pitches pitch=)))
+ (let* ((result (rassoc ly-pitch pitchnames pitch=)))
(and result (car result))))
(define-public (octave->lily-string pitch)
num den
(new-line->lily-string))
(format #f
- "\\time #'~a ~a/~a~a"
+ ;; This is silly but the latter will also work for #f
+ ;; and other
+ (if (key-list? structure)
+ "\\time ~{~a~^,~} ~a/~a~a"
+ "\\time #'~a ~a/~a~a")
structure num den
(new-line->lily-string)))))
;;; Variable declaration
-(define-public pitchnames '())
-(define-public default-language "")
-(define-public previous-pitchnames #f)
+(define-session-public pitchnames '())
+(define-session-public default-language "")
+(define-session-public previous-pitchnames #f)
-(define-public language-pitch-names
+;;; A bit out of place, but we don't have a good place elsewhere in
+;;; scm since it is only filled in ly/drumpitch-init.ly and we need it
+;;; in (scm lily) in order to access it in ly/parser.yy.
+(define-session-public drumPitchNames '())
+
+(define-session-public language-pitch-names
`(
;; Language: Nederlands --------------------------------------------;
;; Dutch note names -- LilyPond's default language.
(ly:error (_ "call-after-session used after session start")))
(add-hook! after-session-hook thunk #t))
-(defmacro-public define-session (name value)
+(define (make-session-variable name value)
+ (if (ly:undead? lilypond-declarations)
+ (ly:error (_ "define-session used after session start")))
+ (let ((var (module-make-local-var! (current-module) name)))
+ (if (variable-bound? var)
+ (ly:error (_ "symbol ~S redefined") name))
+ (variable-set! var value)
+ var))
+
+(defmacro define-session (name value)
"This defines a variable @var{name} with the starting value
@var{value} that is reinitialized at the start of each session.
A@tie{}session basically corresponds to one LilyPond file on the
them. It is an error to call @code{define-session} after the first
session has started."
(define (add-session-variable name value)
- (if (ly:undead? lilypond-declarations)
- (ly:error (_ "define-session used after session start")))
- (let ((var (make-variable value)))
- (module-add! (current-module) name var)
- (set! lilypond-declarations (cons var lilypond-declarations))))
+ (set! lilypond-declarations
+ (cons (make-session-variable name value) lilypond-declarations)))
`(,add-session-variable ',name ,value))
-(defmacro-public define-session-public (name value)
+(defmacro define-session-public (name value)
"Like @code{define-session}, but also exports @var{name} into parser modules."
(define (add-session-variable name value)
- (if (ly:undead? lilypond-declarations)
- (ly:error (_ "define-session-public used after session start")))
- (let ((var (make-variable value)))
- (module-add! (current-module) name var)
- (set! lilypond-exports (acons name var lilypond-exports))))
- `(,add-session-variable ',name ,value))
+ (set! lilypond-exports
+ (acons name (make-session-variable name value) lilypond-exports)))
+ `(begin
+ ;; this is a bit icky: we place the variable right into every
+ ;; parser module so that both set! and define will affect the
+ ;; original variable in the (lily) module. However, we _also_
+ ;; export it normally from (lily) for the sake of other modules
+ ;; not sharing the name space of the parser.
+ (,add-session-variable ',name ,value)
+ (export ,name)))
(define (session-terminate)
(if (ly:undead? lilypond-declarations)