/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 2004--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 2004--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "dispatcher.hh"
#include "global-context.hh"
#include "international.hh"
-#include "ly-smobs.icc"
#include "main.hh"
#include "output-def.hh"
#include "profile.hh"
#include "scm-hash.hh"
#include "translator-group.hh"
#include "warn.hh"
+#include "lily-imports.hh"
bool
Context::is_removable () const
{
- return context_list_ == SCM_EOL && ! client_count_
+ return scm_is_null (context_list_) && ! client_count_
&& !dynamic_cast<Global_context const *> (daddy_context_);
}
{
for (SCM p = context_list_; scm_is_pair (p); p = scm_cdr (p))
{
- Context *ctx = Context::unsmob (scm_car (p));
+ Context *ctx = unsmob<Context> (scm_car (p));
ctx->check_removal ();
if (ctx->is_removable ())
{
- recurse_over_translators (ctx, &Translator::finalize,
- &Translator_group::finalize,
- UP);
- send_stream_event (ctx, "RemoveContext", 0, 0);
+ recurse_over_translators
+ (ctx,
+ Callback0_wrapper::make_smob
+ <Translator, &Translator::finalize> (),
+ Callback0_wrapper::make_smob
+ <Translator_group, &Translator_group::finalize> (),
+ UP);
+ send_stream_event (ctx, "RemoveContext", 0);
}
}
}
-Context::Context (Context const & /* src */)
-{
- assert (false);
-}
-
Scheme_hash_table *
Context::properties_dict () const
{
- return Scheme_hash_table::unsmob (properties_scm_);
+ return unsmob<Scheme_hash_table> (properties_scm_);
}
void
scm_cons (child->self_scm (), SCM_EOL));
child->daddy_context_ = this;
- this->events_below_->register_as_listener (child->events_below_);
+ events_below_->register_as_listener (child->events_below_);
}
Context::Context ()
smobify_self ();
- Scheme_hash_table *tab = new Scheme_hash_table;
- properties_scm_ = tab->unprotect ();
+ properties_scm_ = Scheme_hash_table::make_smob ();
event_source_ = new Dispatcher ();
event_source_->unprotect ();
events_below_ = new Dispatcher ();
SCM score_name = default_child_context_name ();
SCM score_def = find_context_def (get_output_def (), score_name);
- if (Context_def *cd = Context_def::unsmob (score_def))
+ if (Context_def *cd = unsmob<Context_def> (score_def))
{
if (cd->is_alias (n))
return create_context (cd, id, operations);
if (Context *existing = find_context_below (this, n, id))
return existing;
- if (n == ly_symbol2scm ("Bottom"))
+ if (scm_is_eq (n, ly_symbol2scm ("Bottom")))
{
Context *tg = get_default_interpreter (id);
return tg;
return ret;
}
-IMPLEMENT_LISTENER (Context, acknowledge_infant);
void
Context::acknowledge_infant (SCM sev)
{
- infant_event_ = Stream_event::unsmob (sev);
+ infant_event_ = unsmob<Stream_event> (sev);
}
-IMPLEMENT_LISTENER (Context, set_property_from_event);
void
Context::set_property_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sym = ev->get_property ("symbol");
if (scm_is_symbol (sym))
unset_property (sym);
return;
}
-
+
bool ok = true;
ok = type_check_assignment (sym, val, ly_symbol2scm ("translation-type?"));
if (ok)
- set_property (sym, val);
+ {
+ if (to_boolean (ev->get_property ("once")))
+ {
+ if (Global_context *g = get_global_context ())
+ {
+ SCM old_val = SCM_UNDEFINED;
+ if (here_defined (sym, &old_val))
+ g->add_finalization (scm_list_4 (ly_context_set_property_x_proc,
+ self_scm (),
+ sym,
+ old_val));
+ else
+ g->add_finalization (scm_list_3 (ly_context_unset_property_proc,
+ self_scm (),
+ sym));
+ }
+ }
+ set_property (sym, val);
+ }
}
}
-IMPLEMENT_LISTENER (Context, unset_property_from_event);
void
Context::unset_property_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sym = ev->get_property ("symbol");
- type_check_assignment (sym, SCM_EOL, ly_symbol2scm ("translation-type?"));
- unset_property (sym);
+ bool ok = type_check_assignment (sym, SCM_EOL, ly_symbol2scm ("translation-type?"));
+
+ if (ok)
+ {
+ if (to_boolean (ev->get_property ("once")))
+ {
+ if (Global_context *g = get_global_context ())
+ {
+ SCM old_val = SCM_UNDEFINED;
+ if (here_defined (sym, &old_val))
+ g->add_finalization (scm_list_4 (ly_context_set_property_x_proc,
+ self_scm (),
+ sym,
+ old_val));
+ else
+ g->add_finalization (scm_list_3 (ly_context_unset_property_proc,
+ self_scm (),
+ sym));
+ }
+ }
+ unset_property (sym);
+ }
}
/*
Creates a new context from a CreateContext event, and sends an
AnnounceNewContext event to this context.
*/
-IMPLEMENT_LISTENER (Context, create_context_from_event);
void
Context::create_context_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
string id = ly_scm2string (ev->get_property ("id"));
SCM ops = ev->get_property ("ops");
/* We want to be the first ones to hear our own events. Therefore, wait
before registering events_below_ */
new_context->event_source ()->
- add_listener (GET_LISTENER (new_context->create_context_from_event),
+ add_listener (new_context->GET_LISTENER (Context, create_context_from_event),
ly_symbol2scm ("CreateContext"));
new_context->event_source ()->
- add_listener (GET_LISTENER (new_context->remove_context),
+ add_listener (new_context->GET_LISTENER (Context, remove_context),
ly_symbol2scm ("RemoveContext"));
new_context->event_source ()->
- add_listener (GET_LISTENER (new_context->change_parent),
+ add_listener (new_context->GET_LISTENER (Context, change_parent),
ly_symbol2scm ("ChangeParent"));
new_context->event_source ()->
- add_listener (GET_LISTENER (new_context->set_property_from_event),
+ add_listener (new_context->GET_LISTENER (Context, set_property_from_event),
ly_symbol2scm ("SetProperty"));
new_context->event_source ()->
- add_listener (GET_LISTENER (new_context->unset_property_from_event),
+ add_listener (new_context->GET_LISTENER (Context, unset_property_from_event),
ly_symbol2scm ("UnsetProperty"));
new_context->events_below_->register_as_listener (new_context->event_source_);
- this->add_context (new_context);
+ add_context (new_context);
new_context->unprotect ();
- Context_def *td = Context_def::unsmob (new_context->definition_);
+ Context_def *td = unsmob<Context_def> (new_context->definition_);
/* This cannot move before add_context (), because \override
operations require that we are in the hierarchy. */
// but the Context_def expects to see elements of the form ('accepts symbol).
SCM accepts = SCM_EOL;
for (SCM s = definition_mods_; scm_is_pair (s); s = scm_cdr (s))
- if (scm_caar (s) == ly_symbol2scm ("accepts"))
+ if (scm_is_eq (scm_caar (s), ly_symbol2scm ("accepts")))
{
SCM elt = scm_list_2 (scm_caar (s), scm_string_to_symbol (scm_cadar (s)));
accepts = scm_cons (elt, accepts);
}
- return Context_def::unsmob (definition_)->path_to_acceptable_context (name,
+ return unsmob<Context_def> (definition_)->path_to_acceptable_context (name,
get_output_def (),
scm_reverse_x (accepts, SCM_EOL));
/* TODO: This is fairly misplaced. We can fix this when we have taken out all
iterator specific stuff from the Context class */
event_source_->
- add_listener (GET_LISTENER (acknowledge_infant),
+ add_listener (GET_LISTENER (Context, acknowledge_infant),
ly_symbol2scm ("AnnounceNewContext"));
/* The CreateContext creates a new context, and sends an announcement of the
new context through another event. That event will be stored in
ly_symbol2scm ("type"), cdef->get_context_name (),
ly_symbol2scm ("id"), ly_string2scm (id));
event_source_->
- remove_listener (GET_LISTENER (acknowledge_infant),
+ remove_listener (GET_LISTENER (Context, acknowledge_infant),
ly_symbol2scm ("AnnounceNewContext"));
assert (infant_event_);
SCM infant_scm = infant_event_->get_property ("context");
- Context *infant = Context::unsmob (infant_scm);
+ Context *infant = unsmob<Context> (infant_scm);
if (!infant || infant->get_parent_context () != this)
{
SCM st = find_context_def (get_output_def (), nm);
string name = ly_symbol2string (nm);
- Context_def *t = Context_def::unsmob (st);
+ Context_def *t = unsmob<Context_def> (st);
if (!t)
{
warning (_f ("cannot find or create: `%s'", name.c_str ()));
- t = Context_def::unsmob (this->definition_);
+ t = unsmob<Context_def> (definition_);
}
if (scm_is_symbol (t->get_default_child (SCM_EOL)))
{
Context *
Context::where_defined (SCM sym, SCM *value) const
{
-#ifndef NDEBUG
+#ifdef DEBUG
if (profile_property_accesses)
note_property_access (&context_property_lookup_table, sym);
#endif
return (daddy_context_) ? daddy_context_->where_defined (sym, value) : 0;
}
+/* Quick variant of where_defined. Checks only the context itself. */
+
+bool
+Context::here_defined (SCM sym, SCM *value) const
+{
+#ifdef DEBUG
+ if (profile_property_accesses)
+ note_property_access (&context_property_lookup_table, sym);
+#endif
+
+ return properties_dict ()->try_retrieve (sym, value);
+}
+
/*
return SCM_EOL when not found.
*/
SCM
Context::internal_get_property (SCM sym) const
{
-#ifndef NDEBUG
+#ifdef DEBUG
if (profile_property_accesses)
note_property_access (&context_property_lookup_table, sym);
#endif
}
/*
-Called by the send_stream_event macro. props is a 0-terminated array of
-properties and corresponding values, interleaved. This method should not
-be called from any other place than the send_stream_event macro.
+These methods should not be called from any other place than the
+send_stream_event macro.
*/
+
void
-Context::internal_send_stream_event (SCM type, Input *origin, SCM props[])
+Context::internal_send_stream_event (SCM type, Input *origin)
{
- Stream_event *e = new Stream_event
- (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"), type),
- origin);
- for (int i = 0; props[i]; i += 2)
- {
- e->set_property (props[i], props[i + 1]);
- }
+ Stream_event *e = new Stream_event (Lily::ly_make_event_class (type), origin);
+ event_source_->broadcast (e);
+ e->unprotect ();
+}
+
+void
+Context::internal_send_stream_event (SCM type, Input *origin,
+ SCM prop, SCM val)
+{
+ Stream_event *e = new Stream_event (Lily::ly_make_event_class (type), origin);
+ e->set_property (prop, val);
+ event_source_->broadcast (e);
+ e->unprotect ();
+}
+
+void
+Context::internal_send_stream_event (SCM type, Input *origin,
+ SCM prop, SCM val, SCM prop2, SCM val2)
+{
+ Stream_event *e = new Stream_event (Lily::ly_make_event_class (type), origin);
+ e->set_property (prop, val);
+ e->set_property (prop2, val2);
+ event_source_->broadcast (e);
+ e->unprotect ();
+}
+
+void
+Context::internal_send_stream_event (SCM type, Input *origin,
+ SCM prop, SCM val, SCM prop2, SCM val2,
+ SCM prop3, SCM val3)
+{
+ Stream_event *e = new Stream_event (Lily::ly_make_event_class (type), origin);
+ e->set_property (prop, val);
+ e->set_property (prop2, val2);
+ e->set_property (prop3, val3);
+ event_source_->broadcast (e);
+ e->unprotect ();
+}
+
+void
+Context::internal_send_stream_event (SCM type, Input *origin,
+ SCM prop, SCM val, SCM prop2, SCM val2,
+ SCM prop3, SCM val3, SCM prop4, SCM val4)
+{
+ Stream_event *e = new Stream_event (Lily::ly_make_event_class (type), origin);
+ e->set_property (prop, val);
+ e->set_property (prop2, val2);
+ e->set_property (prop3, val3);
+ e->set_property (prop4, val4);
event_source_->broadcast (e);
e->unprotect ();
}
if (scm_is_eq (sym, context_name_symbol ()))
return true;
- return scm_c_memq (sym, aliases_) != SCM_BOOL_F;
+ return scm_is_true (scm_c_memq (sym, aliases_));
}
void
properties_dict ()->remove (sym);
}
-IMPLEMENT_LISTENER (Context, change_parent);
void
Context::change_parent (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
- Context *to = Context::unsmob (ev->get_property ("context"));
+ Stream_event *ev = unsmob<Stream_event> (sev);
+ Context *to = unsmob<Context> (ev->get_property ("context"));
disconnect_from_parent ();
to->add_context (this);
/*
Die. The next GC sweep should take care of the actual death.
*/
-IMPLEMENT_LISTENER (Context, remove_context);
void
Context::remove_context (SCM)
{
void
Context::disconnect_from_parent ()
{
- daddy_context_->events_below_->unregister_as_listener (this->events_below_);
- daddy_context_->context_list_ = scm_delq_x (this->self_scm (), daddy_context_->context_list_);
+ daddy_context_->events_below_->unregister_as_listener (events_below_);
+ daddy_context_->context_list_ = scm_delq_x (self_scm (), daddy_context_->context_list_);
daddy_context_ = 0;
}
-/*
- ID == "" means accept any ID.
-*/
+Context *
+find_context_above (Context *where, SCM type)
+{
+ while (where && !where->is_alias (type))
+ where = where->get_parent_context ();
+
+ return where;
+}
+
+Context *
+find_context_above_by_parent_type (Context *where, SCM parent_type)
+{
+ while (Context *parent = where->get_parent_context ())
+ {
+ if (parent->is_alias (parent_type))
+ return where;
+ where = parent;
+ }
+ return 0;
+}
+
Context *
find_context_below (Context *where,
SCM type, const string &id)
for (SCM s = where->children_contexts ();
!found && scm_is_pair (s); s = scm_cdr (s))
{
- Context *tr = Context::unsmob (scm_car (s));
+ Context *tr = unsmob<Context> (scm_car (s));
found = find_context_below (tr, type, id);
}
return found;
}
+Context *
+find_context_near (Context *where,
+ SCM type, const string &id)
+{
+ for ( ; where; where = where->get_parent_context ())
+ {
+ Context *found = find_context_below (where, type, id);
+ if (found)
+ return found;
+ }
+
+ return 0;
+}
+
+Context *
+find_top_context (Context *where)
+{
+ Context *top = where;
+ for ( ; where; where = where->get_parent_context())
+ top = where;
+ return top;
+}
+
SCM
Context::properties_as_alist () const
{
SCM
Context::context_name_symbol () const
{
- Context_def *td = Context_def::unsmob (definition_);
+ Context_def *td = unsmob<Context_def> (definition_);
return td->get_context_name ();
}
}
int
-Context::print_smob (SCM s, SCM port, scm_print_state *)
+Context::print_smob (SCM port, scm_print_state *) const
{
- Context *sc = (Context *) SCM_CELL_WORD_1 (s);
-
scm_puts ("#<", port);
- scm_puts (sc->class_name (), port);
- if (Context_def *d = Context_def::unsmob (sc->definition_))
+ scm_puts (class_name (), port);
+ if (Context_def *d = unsmob<Context_def> (definition_))
{
scm_puts (" ", port);
scm_display (d->get_context_name (), port);
}
- if (!sc->id_string_.empty ())
+ if (!id_string_.empty ())
{
scm_puts ("=", port);
- scm_puts (sc->id_string_.c_str (), port);
+ scm_puts (id_string_.c_str (), port);
}
scm_puts (" ", port);
- scm_display (sc->context_list_, port);
+ scm_display (context_list_, port);
scm_puts (" >", port);
return 1;
}
+void
+Context::derived_mark () const
+{
+}
+
SCM
-Context::mark_smob (SCM sm)
+Context::mark_smob () const
{
- Context *me = (Context *) SCM_CELL_WORD_1 (sm);
+ scm_gc_mark (context_list_);
+ scm_gc_mark (aliases_);
+ scm_gc_mark (definition_);
+ scm_gc_mark (definition_mods_);
+ scm_gc_mark (properties_scm_);
+ scm_gc_mark (accepts_list_);
+ scm_gc_mark (default_child_);
- scm_gc_mark (me->context_list_);
- scm_gc_mark (me->aliases_);
- scm_gc_mark (me->definition_);
- scm_gc_mark (me->definition_mods_);
- scm_gc_mark (me->properties_scm_);
- scm_gc_mark (me->accepts_list_);
- scm_gc_mark (me->default_child_);
+ if (implementation_)
+ scm_gc_mark (implementation_->self_scm ());
- if (me->implementation_)
- scm_gc_mark (me->implementation_->self_scm ());
+ if (event_source_)
+ scm_gc_mark (event_source_->self_scm ());
- if (me->event_source_)
- scm_gc_mark (me->event_source_->self_scm ());
+ if (events_below_)
+ scm_gc_mark (events_below_->self_scm ());
- if (me->events_below_)
- scm_gc_mark (me->events_below_->self_scm ());
+ derived_mark ();
- return me->properties_scm_;
+ return properties_scm_;
}
-IMPLEMENT_SMOBS (Context);
-IMPLEMENT_DEFAULT_EQUAL_P (Context);
-IMPLEMENT_TYPE_P (Context, "ly:context?");
+const char * const Context::type_p_name_ = "ly:context?";
Global_context *
Context::get_global_context () const
{
SCM l = context->get_property ("measureLength");
Rational length (1);
- if (Moment::unsmob (l))
- length = Moment::unsmob (l)->main_part_;
+ if (unsmob<Moment> (l))
+ length = unsmob<Moment> (l)->main_part_;
return length;
}
SCM sm = context->get_property ("measurePosition");
Moment m = 0;
- if (Moment::unsmob (sm))
+ if (unsmob<Moment> (sm))
{
- m = *Moment::unsmob (sm);
+ m = *unsmob<Moment> (sm);
if (m.main_part_ < Rational (0))
{
trans->set_property (sym, ly_deep_copy (val));
for (SCM p = trans->children_contexts (); scm_is_pair (p); p = scm_cdr (p))
{
- Context *trg = Context::unsmob (scm_car (p));
+ Context *trg = unsmob<Context> (scm_car (p));
set_context_property_on_children (trg, sym, ly_deep_copy (val));
}
}
bool
melisma_busy (Context *tr)
{
- SCM melisma_properties = tr->get_property ("melismaBusyProperties");
- bool busy = false;
+ // When there are subcontexts, they are responsible for maintaining
+ // melismata.
+ SCM ch = tr->children_contexts ();
+ if (scm_is_pair (ch))
+ {
+ // all contexts need to have a busy melisma for this to evaluate
+ // to true.
+
+ do {
+ if (!melisma_busy (unsmob<Context> (scm_car (ch))))
+ return false;
+ ch = scm_cdr (ch);
+ } while (scm_is_pair (ch));
+ return true;
+ }
- for (; !busy && scm_is_pair (melisma_properties);
+ for (SCM melisma_properties = tr->get_property ("melismaBusyProperties");
+ scm_is_pair (melisma_properties);
melisma_properties = scm_cdr (melisma_properties))
- busy = busy || to_boolean (tr->internal_get_property (scm_car (melisma_properties)));
+ if (to_boolean (tr->get_property (scm_car (melisma_properties))))
+ return true;
- return busy;
+ return false;
}
bool
projects / lilypond.git / blobdiff