protect() and unprotect(). Use throughout.
+2005-07-24 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+ * lily/smobs.cc (protect_smob): experiment: O(1) GC (un)protection.
+
+ * lily/include/smobs.hh (DECLARE_BASE_SMOBS): add methods
+ protect() and unprotect(). Use throughout.
+
2005-07-24 Nicolas Sceaux <nicolas.sceaux@free.fr>
* Documentation/topdocs/NEWS.tely: new item for \displayLilyMusic
All_font_metrics::~All_font_metrics ()
{
- scm_gc_unprotect_object (afm_dict_->self_scm ());
- scm_gc_unprotect_object (tfm_dict_->self_scm ());
- scm_gc_unprotect_object (otf_dict_->self_scm ());
+ afm_dict_->unprotect ();
+ tfm_dict_->unprotect ();
+ otf_dict_->unprotect ();
#if HAVE_PANGO_FT2
- scm_gc_unprotect_object (pango_dict_->self_scm ());
+ pango_dict_->unprotect ();
g_object_unref (pango_ft2_fontmap_);
#endif
}
output_scale);
val = pf->self_scm ();
pango_dict_->set (key, val);
- scm_gc_unprotect_object (val);
+ pf->unprotect ();
if (be_verbose_global)
progress_indication ("]");
progress_indication ("]");
afm_dict_->set (sname, val);
- scm_gc_unprotect_object (val);
+ unsmob_metrics (val)->unprotect ();
Adobe_font_metric *afm
= dynamic_cast<Adobe_font_metric *> (unsmob_metrics (val));
unsmob_metrics (val)->description_ = scm_cons (name_string,
scm_make_real (1.0));
otf_dict_->set (sname, val);
- scm_gc_unprotect_object (val);
+ unsmob_metrics (val)->unprotect ();
}
return dynamic_cast<Open_type_font *> (unsmob_metrics (val));
unsmob_metrics (val)->description_ = scm_cons (name_string,
scm_make_real (1.0));
tfm_dict_->set (sname, val);
- scm_gc_unprotect_object (val);
+ unsmob_metrics (val)->unprotect ();
}
return dynamic_cast<Tex_font_metric *> (unsmob_metrics (val));
if (to_boolean (get_property ("skipTypesetting")))
return 0;
+ for (int i = 0; i < stems_->size (); i++)
+ if (Stem::get_beam ((*stems_)[i]))
+ return 0;
+
Spanner *beam = new Spanner (beam_settings_, context ()->get_grob_key ("Beam"));
for (int i = 0; i < stems_->size (); i++)
{
- /*
- watch out for stem tremolos and abbreviation beams
- */
- if (Stem::get_beam ((*stems_)[i]))
- {
- scm_gc_unprotect_object (beam->self_scm ());
- return 0;
- }
Beam::add_stem (beam, (*stems_)[i]);
}
void
Auto_beam_engraver::acknowledge_beam (Grob_info info)
{
+ (void)info;
check_bar_property ();
if (stems_)
{
void
Auto_beam_engraver::acknowledge_bar_line (Grob_info info)
{
+ (void)info;
check_bar_property ();
if (stems_)
end_beam ();
void
Auto_beam_engraver::acknowledge_rest (Grob_info info)
{
+ (void)info;
check_bar_property ();
if (stems_)
end_beam ();
book->scores_ = scm_append (scm_list_2 (scores, book->scores_));
+
SCM x = book->self_scm ();
- scm_gc_unprotect_object (x);
+ book->unprotect ();
return x;
}
if (pb)
{
pb->output (output);
- scm_gc_unprotect_object (pb->self_scm ());
+ pb->unprotect ();
}
return SCM_UNSPECIFIED;
Output_def *scaled_bookdef = scale_output_def (paper, scale);
Object_key *key = new Lilypond_general_key (0, user_key_, 0);
- SCM scm_key = key->self_scm ();
- scm_gc_unprotect_object (scm_key);
-
+ SCM scm_key = key->unprotect ();
+
paper_book->paper_ = scaled_bookdef;
- scm_gc_unprotect_object (scaled_bookdef->self_scm ());
+ scaled_bookdef->unprotect ();
paper_book->header_ = header_;
for (int i = scratch_note_events_.size (); i--;)
{
- scm_gc_unprotect_object (scratch_note_events_[i]->self_scm ());
+ scratch_note_events_[i]->unprotect ();
}
scratch_note_events_.clear ();
}
tr->daddy_context_ = context;
- scm_gc_unprotect_object (str);
+ tr->unprotect ();
}
}
g->context_ = context;
context->aliases_ = context_aliases_;
- scm_gc_unprotect_object (g->self_scm ());
+ g->unprotect ();
context->accepts_list_ = get_accepted (ops);
Context_def::clone_scm () const
{
Context_def *t = new Context_def (*this);
- SCM x = t->self_scm ();
- scm_gc_unprotect_object (x);
- return x;
+ return t->unprotect ();
}
SCM
Context_def::make_scm ()
{
Context_def *t = new Context_def;
- SCM x = t->self_scm ();
- scm_gc_unprotect_object (x);
- return x;
+ return t->unprotect ();
}
void
{
t->init_ = true;
- scm_gc_unprotect_object (ts);
+ t->unprotect ();
Context_def *td = unsmob_context_def (t->definition_);
/* This cannot move before add_context (), because \override
definition_ = SCM_EOL;
smobify_self ();
- properties_scm_ = (new Scheme_hash_table)->self_scm ();
- scm_gc_unprotect_object (properties_scm_);
+
+ Scheme_hash_table *tab = new Scheme_hash_table;
+ properties_scm_ = tab->unprotect ();
+ /*
+ UGH UGH
+ const correctness.
+ */
if (key_)
- scm_gc_unprotect_object (key_->self_scm ());
+ ((Object_key*)key)->unprotect ();
}
/* TODO: this shares code with find_create_context (). */
alternative_iter_ = s;
alternative_iter_->construct_children ();
- scm_gc_unprotect_object (s->self_scm ());
+ s->unprotect ();
}
}
if (be_verbose_global)
message (_f ("elapsed time: %.2f seconds", timer.read ()));
- return scm_gc_unprotect_object (trans->self_scm ());
+ return trans->unprotect ();
}
We always get a new key object for a new grob.
*/
if (key_)
- scm_gc_unprotect_object (key_->self_scm ());
+ {
+ ((Object_key*)key_)->unprotect ();
+ }
SCM meta = get_property ("meta");
if (scm_is_pair (meta))
{
smobify_self ();
if (key_)
- scm_gc_unprotect_object (key_->self_scm ());
+ {
+ ((Object_key*)key_)->unprotect ();
+ }
}
Grob::~Grob ()
{ \
CL *s = (CL *) SCM_CELL_WORD_1 (ses); \
delete s; \
- scm_gc_unregister_collectable_memory (s, sizeof (CL), #CL " smob"); \
+ /* scm_gc_unregister_collectable_memory (s, sizeof (CL), #CL " smob"); */ \
return SMOB_FREE_RETURN_VAL (CL); \
} \
\
CL *ptr = new CL (*this); \
SCM s; \
s = scm_cons (SCM_PACK (CL::smob_tag_), SCM_PACK (ptr)); \
- scm_gc_register_collectable_memory ((CL *)this, sizeof (CL), #CL " smob"); \
+ /* scm_gc_register_collectable_memory ((CL *)this, sizeof (CL), #CL " smob");*/ \
\
return s; \
}
#define IMPLEMENT_SMOBS(CL) \
IMPLEMENT_BASE_SMOBS (CL) \
- void \
+ void \
CL::smobify_self () \
{ \
- SCM s = unprotected_smobify_self (); \
- scm_gc_protect_object (s); \
+ self_scm_ = unprotected_smobify_self (); \
+ protection_cons_ = SCM_EOL;\
+ protect();\
+ }\
+ void\
+ CL::protect(){ \
+ protect_smob (self_scm_, &protection_cons_);\
+ }\
+ SCM\
+ CL::unprotect ()\
+ {\
+ unprotect_smob (&protection_cons_);\
+ return self_scm_;\
} \
- \
SCM \
CL::unprotected_smobify_self () \
{ \
SCM s; \
SCM_NEWSMOB (s, CL::smob_tag_, this); \
self_scm_ = s; \
- scm_gc_register_collectable_memory (this, sizeof (CL), #CL " smob"); \
+ /* scm_gc_register_collectable_memory (this, sizeof (CL), #CL " smob");*/ \
return s; \
}
(), \
"") \
{ \
- SCM val = (new Class)->self_scm (); \
- scm_gc_unprotect_object (val); \
- return val; \
+ Class *c = (new Class);\
+ return c->unprotect();\
}
DECLARE_UNSMOB (Music_iterator, iterator);
private: \
void smobify_self (); \
SCM self_scm_; \
+ SCM protection_cons_; \
public: \
+ SCM unprotect();\
+ void protect();\
SCM self_scm () const { return self_scm_; } \
private:
#define DECLARE_TYPE_P(CL) extern SCM CL ## _type_p_proc
+void protect_smob (SCM smob, SCM *prot_cons);
+void unprotect_smob (SCM *prot_cons);
+
#endif /* SMOBS_HH */
void
Key_engraver::acknowledge_clef (Grob_info info)
{
+ (void)info;
SCM c = get_property ("createKeyOnClefChange");
if (to_boolean (c))
{
void
Key_engraver::acknowledge_bar_line (Grob_info info)
{
+ (void)info;
if (scm_is_pair (get_property ("keySignature")))
{
create_key (true);
parser->parse_file (init, file_name, out_file);
bool error = parser->error_level_;
- scm_gc_unprotect_object (parser->self_scm ());
+ parser->unprotect ();
parser = 0;
if (error)
/* TODO: pass renamed input file too. */
sources.set_path (&global_path);
Lily_parser *parser = new Lily_parser (&sources);
parser->parse_string (ly_scm2string (ly_code));
- scm_gc_unprotect_object (parser->self_scm ());
+ parser->unprotect ();
parser = 0;
return SCM_UNSPECIFIED;
Lily_parser *parser = unsmob_lily_parser (parser_smob);
Lily_parser *clone = new Lily_parser (*parser);
- return scm_gc_unprotect_object (clone->self_scm ());
+ return clone->unprotect ();
}
LY_DEFINE (ly_parser_define, "ly:parser-define!",
smobify_self ();
lexer_ = new Lily_lexer (sources_);
- scm_gc_unprotect_object (lexer_->self_scm ());
+ lexer_->unprotect ();
}
Lily_parser::Lily_parser (Lily_parser const &src)
if (src.lexer_)
lexer_ = new Lily_lexer (*src.lexer_);
- scm_gc_unprotect_object (lexer_->self_scm ());
+ lexer_->unprotect ();
}
Lily_parser::~Lily_parser ()
p = new Simple_music_iterator;
iter = p->self_scm ();
- scm_gc_unprotect_object (iter);
+ p->unprotect ();
}
p->music_ = m;
"for creating music objects. ")
{
Music *ms = new Music (props);
- SCM s = ms->self_scm ();
- scm_gc_unprotect_object (s);
- return s;
+ return ms->unprotect ();
}
/* todo: property args */
SCM copy = m;
if (unsmob_music (m))
{
- copy = unsmob_music (m)->clone ()->self_scm ();
- scm_gc_unprotect_object (copy);
+ Music * mcopy = unsmob_music (m)->clone ();
+ copy = mcopy->unprotect ();
}
else if (scm_is_pair (m))
copy = scm_cons (ly_music_deep_copy (scm_car (m)),
SCM rv = scm_call_1 (make_music_proc, sym);
/* UGH. */
- scm_gc_protect_object (rv);
- return unsmob_music (rv);
+ Music *m = unsmob_music (rv);
+ m->protect ();
+ return m;
}
"Create a key dumper. ")
{
Object_key_dumper *u = new Object_key_dumper ();
- SCM x = u->self_scm ();
- scm_gc_unprotect_object (x);
- return x;
+ return u->unprotect ();
}
LY_DEFINE (ly_dumper_definitions, "ly:dumper-definitions",
"Create a key undumper. ")
{
Object_key_undumper *u = new Object_key_undumper ();
- SCM x = u->self_scm ();
- scm_gc_unprotect_object (x);
- return x;
+ return u->unprotect ();
}
LY_DEFINE (ly_undumper_lookup, "ly:undumper-lookup",
Object_key *k = Object_key::undump (new_key);
keys_[number] = k;
- scm_gc_unprotect_object (k->self_scm ());
+ k->unprotect ();
}
}
{
Output_def *op = unsmob_output_def (def);
SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition");
- SCM s = op->clone ()->self_scm ();
- scm_gc_unprotect_object (s);
- return s;
+
+ Output_def *clone = op->clone ();
+ return clone->unprotect ();
}
LY_DEFINE (ly_output_description, "ly:output-description",
"Make a output def.")
{
Output_def *bp = new Output_def ;
- return scm_gc_unprotect_object (bp->self_scm ());
+ return bp->unprotect ();
}
LY_DEFINE (ly_paper_get_font, "ly:paper-get-font", 2, 0, 0,
{
Paper_system *ps = new Paper_system (title, true);
systems_ = scm_cons (ps->self_scm (), systems_);
- scm_gc_unprotect_object (ps->self_scm ());
+ ps->unprotect ();
set_system_penalty (ps, header);
}
}
set_system_penalty (ps, header_);
systems_ = scm_cons (ps->self_scm (), systems_);
- scm_gc_unprotect_object (ps->self_scm ());
+ ps->unprotect ();
}
SCM page_properties
// FIXME: title=true?
Paper_system *ps = new Paper_system (*unsmob_stencil (t), true);
systems_ = scm_cons (ps->self_scm (), systems_);
- scm_gc_unprotect_object (ps->self_scm ());
+ ps->unprotect ();
// FIXME: figure out penalty.
//set_system_penalty (ps, scores_[i].header_);
}
SCM val = Modified_font_metric::make_scaled_font_metric (f, lookup_mag);
sizes = scm_acons (scm_make_real (lookup_mag), val, sizes);
- scm_gc_unprotect_object (val);
+ unsmob_metrics (val)->unprotect ();
scm_hashq_set_x (font_table, f->self_scm (), sizes);
return unsmob_metrics (val);
}
{
SCM proc = ly_lily_module_constant ("scale-layout");
SCM new_pap = scm_call_2 (proc, o->self_scm (), scm_double2num (amount));
- scm_gc_protect_object (new_pap);
- return unsmob_output_def (new_pap);
+ o = unsmob_output_def (new_pap);
+ o->protect ();
+ return o;
}
progress_indication ("\n");
Paper_outputter *po = new Paper_outputter (port, f);
- scm_gc_unprotect_object (po->self_scm ());
+ po->unprotect ();
return po->self_scm ();
}
systems_ = scm_cons (system->self_scm (), systems_);
system->pscore_ = this;
- scm_gc_unprotect_object (system->self_scm ());
+ system->unprotect ();
}
Array<Column_x_positions>
{
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);
+
+ unsmob_music (ch)->protect();
return ch;
}
%token HYPHEN "--"
%token CHORDMODIFIERS
-%token COMMANDSPANREQUEST
%token LYRIC_MARKUP
%token MULTI_MEASURE_REST
%token SCM_T
%type <music> chord_body
%type <music> chord_body_element
%type <music> command_element
-%type <music> command_req
+%type <music> command_event
%type <music> context_change
%type <music> direction_less_event
%type <music> direction_reqd_event
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 ());
+ book->unprotect ();
}
| 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 ());
+ score->unprotect ();
}
| 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 ());
+ music->unprotect ();
}
| full_markup {
SCM proc = THIS->lexer_->lookup_identifier ("toplevel-text-handler");
id = ly_symbol2scm ("$defaultlayout");
THIS->lexer_->set_identifier (id, od->self_scm ());
- scm_gc_unprotect_object (od->self_scm ());
+ od->unprotect();
}
;
identifier_init:
score_block {
$$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ $1->unprotect ();
}
| output_def {
$$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ $1->unprotect ();
}
| context_def_spec_block {
$$ = $1;
}
| Music {
$$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ $1->unprotect();
}
| post_event {
$$ = $1->self_scm ();
- scm_gc_unprotect_object ($$);
+ $1->unprotect();
}
| number_expression {
$$ = $1;
$$ = 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 ());
+ $$->paper_->unprotect ();
$$->header_ = THIS->lexer_->lookup_identifier ("$globalheader");
}
| book_body paper_block {
$$->paper_ = $2;
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
| book_body score_block {
SCM s = $2->self_scm ();
$$->add_score (s);
- scm_gc_unprotect_object (s);
+ $2->unprotect();
}
| book_body full_markup {
$$->add_score ($2);
score_body:
Music {
SCM m = $1->self_scm ();
- scm_gc_unprotect_object (m);
+ $1->unprotect();
SCM scorify = ly_lily_module_constant ("scorify-music");
SCM score = scm_call_2 (scorify, m, THIS->self_scm ());
- // pass ownernship to C++ again.
- scm_gc_protect_object (score);
+ // pass ownernship to C++ again.
$$ = unsmob_score (score);
+ $$->protect ();
$$->set_spot (@$);
}
| SCORE_IDENTIFIER {
{
$$->defs_.push ($2);
}
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
| score_body error {
$$->error_found_ = true;
THIS->lexer_->push_initial_state ();
}
| output_def_head '{' OUTPUT_DEF_IDENTIFIER {
- scm_gc_unprotect_object ($1->self_scm ());
+ $1->unprotect ();
Output_def *o = unsmob_output_def ($3);
o->input_origin_.set_spot (@$);
$$ = o;
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 ());
+ $2->unprotect ();
}
| output_def_body error {
| Music_list Music {
SCM s = $$;
SCM c = scm_cons ($2->self_scm (), SCM_EOL);
- scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
+ $2->unprotect (); /* UGH */
if (scm_is_pair (scm_cdr (s)))
scm_set_cdr_x (scm_cdr (s), c); /* append */
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 */
+ m->unprotect (); /* UGH */
if (scm_is_pair (scm_cdr (s)))
scm_set_cdr_x (scm_cdr (s), c); /* append */
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);
+ r->protect ();
if (beg)
{
r-> set_property ("element", beg->self_scm ());
- scm_gc_unprotect_object (beg->self_scm ());
+ beg->unprotect ();
}
r->set_property ("repeat-count", scm_int2num (max (times, 1)));
}
| MUSIC_FUNCTION_MUSIC Music {
$$ = scm_list_3 ($1, make_input (@$), $2->self_scm ());
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
| MUSIC_FUNCTION_SCM_MUSIC embedded_scm Music {
$$ = scm_list_4 ($1, make_input (@$), $2, $3->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ $3->unprotect ();
}
| MUSIC_FUNCTION_SCM_SCM embedded_scm embedded_scm {
$$ = scm_list_4 ($1, make_input (@$), $2, $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 ());
+ $3->unprotect ();
}
| MUSIC_FUNCTION_MARKUP_MARKUP full_markup full_markup {
$$ = scm_list_4 ($1, make_input (@$), $2, $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 ());
+ $2->unprotect ();
+ $3->unprotect ();
}
| 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 ());
+ $4->unprotect ();
+ $3->unprotect ();
}
| 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 ());
+ $3->unprotect ();
+ $4->unprotect ();
}
;
if (unsmob_music (m))
{
$$ = unsmob_music (m);
- scm_gc_protect_object (m);
+ $$->protect ();
}
else
{
$$->set_spot (@$);
$$->set_property ("element", mp->self_scm ());
- scm_gc_unprotect_object (mp->self_scm ());
+ mp->unprotect();
$$->set_property ("numerator", scm_int2num (n));
$$->set_property ("denominator", scm_int2num (d));
$$->compress (Moment (Rational (n,d)));
p->transpose (pitch_interval (from, to));
$$->set_property ("element", p->self_scm ());
- scm_gc_unprotect_object (p->self_scm ());
+ p->unprotect();
}
| mode_changing_head Grouped_music_list {
if ($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 ());
+ $2->unprotect();
}
else
{
{
Music *chm = MY_MAKE_MUSIC ("UnrelativableMusic");
chm->set_property ("element", $$->self_scm ());
- scm_gc_unprotect_object ($$->self_scm ());
+ $$->unprotect();
$$ = chm;
}
THIS->lexer_->pop_state ();
Music *m = $3;
Pitch start = *unsmob_pitch ($2);
$$ = make_music_relative (start, m);
- scm_gc_unprotect_object (m->self_scm ());
+ m->unprotect();
}
| 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 ());
+ m->unprotect();
}
;
all->set_property ("elements", scm_cons (voice->self_scm (),
lst));
$$ = all;
- scm_gc_unprotect_object (voice->self_scm ());
+ voice->unprotect ();
}
| LYRICSTO simple_string {
THIS->lexer_->push_lyric_state ();
Music *music = $4;
SCM name = $2;
$$ = make_lyric_combine_music (name, music);
- scm_gc_unprotect_object (music->self_scm ());
+ music->unprotect();
}
;
/* empty */ { $$ = SCM_EOL; }
| chord_body_elements chord_body_element {
$$ = scm_cons ($2->self_scm (), $1);
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
;
SCM adder = ly_lily_module_constant ("add-quotable");
scm_call_2 (adder, $2, $3->self_scm ());
- scm_gc_unprotect_object ($3->self_scm ());
+ $3->unprotect();
}
;
command_element:
- command_req {
+ command_event {
$$ = MY_MAKE_MUSIC ("EventChord");
$$->set_property ("elements", scm_cons ($1->self_scm (), SCM_EOL));
- scm_gc_unprotect_object ($1->self_scm ());
+ $1->unprotect();
$$-> set_spot (@$);
$1-> set_spot (@$);
$$ = MY_MAKE_MUSIC ("EventChord");
$$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
- scm_gc_unprotect_object (m->self_scm ());
+ m->unprotect();
$$->set_spot (@$);
}
| E_BRACKET_CLOSE {
$$ = MY_MAKE_MUSIC ("EventChord");
$$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
$$->set_spot (@$);
- scm_gc_unprotect_object (m->self_scm ());
+ m->unprotect ();
}
| E_BACKSLASH {
$$ = MY_MAKE_MUSIC ("VoiceSeparator");
SCM proc = ly_lily_module_constant ("make-clef-set");
SCM result = scm_call_1 (proc, $2);
- scm_gc_protect_object (result);
$$ = unsmob_music (result);
+ $$->protect ();
}
| TIME_T fraction {
SCM proc = ly_lily_module_constant ("make-time-signature-set");
SCM result = scm_apply_2 (proc, scm_car ($2), scm_cdr ($2), SCM_EOL);
- scm_gc_protect_object (result);
$$ = unsmob_music (result);
+ $$->protect ();
}
| MARK scalar {
SCM proc = ly_lily_module_constant ("make-mark-set");
SCM result = scm_call_1 (proc, $2);
scm_gc_protect_object (result);
$$ = unsmob_music (result);
+ $$->protect ();
}
;
-command_req:
+command_event:
E_TILDE {
$$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
}
| post_events post_event {
$2->set_spot (@2);
$$ = scm_cons ($2->self_scm (), $$);
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
| post_events tagged_post_event {
$2 -> set_spot (@2);
$$ = scm_cons ($2->self_scm (), $$);
- scm_gc_unprotect_object ($2->self_scm ());
+ $2->unprotect ();
}
;
FIGURE_SPACE {
Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
$$ = bfr->self_scm ();
- scm_gc_unprotect_object ($$);
+ bfr->unprotect ();
}
| bass_number {
Music *bfr = MY_MAKE_MUSIC ("BassFigureEvent");
$$ = bfr->self_scm ();
bfr->set_property ("figure", $1);
-
- scm_gc_unprotect_object ($$);
+ bfr->unprotect ();
}
| bass_figure bass_mod {
Music *m = unsmob_music ($1);
Music *v = MY_MAKE_MUSIC ("EventChord");
v->set_property ("elements", scm_list_1 (n->self_scm ()));
- scm_gc_unprotect_object (n->self_scm ());
+ n->unprotect ();
v->set_spot (@$);
n->set_spot (@$);
Music *v = MY_MAKE_MUSIC ("EventChord");
v->set_property ("elements", scm_list_1 (n->self_scm ()));
- scm_gc_unprotect_object (n->self_scm ());
+ n->unprotect ();
v->set_spot (@$);
n->set_spot (@$);
$$ = v;
velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
velt->set_spot (@$);
- scm_gc_unprotect_object (ev->self_scm ());
+ ev->unprotect();
$$ = 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);
+ $$->protect ();
}
| 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 *levent = MY_MAKE_MUSIC ("LyricEvent");
+ levent->set_property ("text", $1);
+ levent->set_property ("duration",$2);
+ levent->set_spot (@$);
Music *velt = MY_MAKE_MUSIC ("EventChord");
- velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
+ velt->set_property ("elements", scm_list_1 (levent->self_scm ()));
$$= velt;
}
} '{' score_body '}' {
Score * sc = $4;
$$ = scm_list_2 (ly_lily_module_constant ("score-markup"), sc->self_scm ());
- scm_gc_unprotect_object (sc->self_scm ());
+ sc->unprotect ();
THIS->lexer_->pop_state ();
}
| MARKUP_HEAD_SCM0 embedded_scm {
Music *csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
csm->set_property ("element", m->self_scm ());
- scm_gc_unprotect_object (m->self_scm ());
+ m->unprotect ();
csm->set_property ("context-type",
scm_is_symbol (type) ? type : scm_string_to_symbol (type));
}
pscore_ = new Paper_score (dynamic_cast<Output_def *> (context ()->get_output_def ()));
- scm_gc_unprotect_object (pscore_->self_scm ());
+ pscore_->unprotect ();
SCM props = updated_grob_properties (context (), ly_symbol2scm ("System"));
Score_performer::initialize ()
{
performance_ = new Performance;
- scm_gc_unprotect_object (performance_->self_scm ());
+ performance_->unprotect ();
performance_->midi_ = context ()->get_output_def ();
Translator_group::initialize ();
Score *score = new Score;
score->set_music (music);
- SCM self = score->self_scm ();
- scm_gc_unprotect_object (self);
- return self;
+ return score->unprotect ();
}
LY_DEFINE (ly_score_embedded_format, "ly:score-embedded-format",
return SCM_BOOL_F;
score_def = score_def->clone ();
- SCM prot = score_def->self_scm ();
- scm_gc_unprotect_object (prot);
+ SCM prot = score_def->unprotect ();
/* TODO: SCORE_DEF should be scaled according to OD->parent_ or OD
itself. */
header, basename, key->self_scm ());
}
- scm_gc_unprotect_object (key->self_scm ());
+ key->unprotect ();
return SCM_UNSPECIFIED;
}
smobify_self ();
Music *m = unsmob_music (s.music_);
- music_ = m ? m->clone ()->self_scm () : SCM_EOL;
- scm_gc_unprotect_object (music_);
+ if (m)
+ {
+ Music *mclone = m->clone ();
+ music_ = mclone->unprotect ();
+ }
+ else
+ music_ = SCM_EOL;
+
for (int i = 0, n = s.defs_.size (); i < n; i++)
{
Output_def * copy = s.defs_[i]->clone ();
defs_.push (copy);
- scm_gc_unprotect_object (copy->self_scm ());
+ copy->unprotect ();
}
header_ = ly_make_anonymous_module (false);
if (ly_is_module (s.header_))
Real scale = scm_to_double (bpd->c_variable ("outputscale"));
Output_def *def = scale_output_def (unsmob_output_def (outdef), scale);
- scaled_def = def->self_scm ();
+ Output_def *bdef = scale_output_def (bpd, scale);
+ def->parent_ = bdef;
- scaled_bookdef = scale_output_def (bpd, scale)->self_scm ();
- unsmob_output_def (scaled_def)->parent_
- = unsmob_output_def (scaled_bookdef);
+ scaled_def = def->self_scm ();
+ scaled_bookdef = bdef->self_scm();
- scm_gc_unprotect_object (scaled_bookdef);
- scm_gc_unprotect_object (scaled_def);
+ def->unprotect();
+ bdef->unprotect ();
}
SCM context = ly_run_translator (music, scaled_def, key);
paper_book->add_score (systems);
paper_book->classic_output (outname);
- scm_gc_unprotect_object (paper_book->self_scm ());
+ paper_book->unprotect ();
}
scm_remember_upto_here_1 (scaled_def);
int outdef_count = defs_.size ();
Object_key *key = new Lilypond_general_key (book_key, user_key_, 0);
- SCM scm_key = key->self_scm ();
- scm_gc_unprotect_object (scm_key);
+ SCM scm_key = key->unprotect ();
for (int i = 0; !i || i < outdef_count; i++)
{
{
def = scale_output_def (def, scale);
def->parent_ = layoutbook;
- scaled = def->self_scm ();
- scm_gc_unprotect_object (scaled);
+
+ scaled = def->unprotect ();
}
/* TODO: fix or junk --no-layout. */
{
m->origin ()->error (_ ("errors found, ignoring music expression"));
- this->error_found_ = this->error_found_ || to_boolean (m->get_property ("error-found"));
+ this->error_found_ = this->error_found_
+ || to_boolean (m->get_property ("error-found"));
}
if (this->error_found_)
{
elem->pscore_ = pscore_;
all_elements_->add (elem);
- scm_gc_unprotect_object (elem->self_scm ());
+ elem->unprotect ();
}
}
pl->break_before_penalty_
= robust_scm2double (break_point->get_property ("page-penalty"), 0.0);
- return scm_gc_unprotect_object (pl->self_scm ());
+ return pl->unprotect ();
}
Link_array<Item>
SCM k = ly_symbol2scm (classname (t));
global_translator_dict->set (k, t->self_scm ());
- scm_gc_unprotect_object (t->self_scm ());
+ t->unprotect ();
}
Translator *
undumper_ = 0;
smobify_self ();
undumper_ = new Object_key_undumper ();
- scm_gc_unprotect_object (undumper_->self_scm ());
+ undumper_->unprotect ();
}
Tweak_registry::~Tweak_registry ()
{
tweaks_.clear ();
undumper_ = new Object_key_undumper ();
- scm_gc_unprotect_object (undumper_->self_scm ());
+ undumper_->unprotect ();
}
void
projects / lilypond.git / commitdiff