X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fcontext.cc;h=14abd62adf1c16cbc936c7f52b234cafaf33e7d6;hb=d461b7e3857b6c32b0cf3ac5c4d2db07b371780f;hp=cf5b1616798b74f1ed176bd46a9d22a40ba8c508;hpb=f085824b2182c1f0fa2c5118884770ac7ff775c7;p=lilypond.git diff --git a/lily/context.cc b/lily/context.cc index cf5b161679..14abd62adf 100644 --- a/lily/context.cc +++ b/lily/context.cc @@ -1,57 +1,141 @@ +/* + context.cc -- implement Context + + source file of the GNU LilyPond music typesetter + + (c) 2004 Han-Wen Nienhuys + +*/ + #include "translator-group.hh" #include "context-def.hh" +#include "context.hh" #include "warn.hh" -#include "music-output-def.hh" +#include "output-def.hh" #include "scm-hash.hh" #include "main.hh" +#include "ly-smobs.icc" +#include "score-context.hh" bool -Translator_group::is_removable () const +Context::is_removable () const +{ + return context_list_ == SCM_EOL && ! iterator_count_ && + !dynamic_cast (this) + ; +} + +void +Context::check_removal () +{ + for (SCM p = context_list_; ly_c_pair_p (p); p = ly_cdr (p)) + { + Context *trg = unsmob_context (ly_car (p)); + + trg->check_removal (); + if (trg->is_removable ()) + { + recurse_over_translators (trg, &Translator::finalize, UP); + remove_context (trg); + } + } +} + +Context::Context (Context const&) { - return trans_group_list_ == SCM_EOL && ! iterator_count_; + assert (false); } -Translator_group * -Translator_group::find_existing_translator (SCM n, String id) +Scheme_hash_table* +Context::properties_dict () const { - if ((is_alias (n) && (id_string_ == id || id.is_empty ())) || n == ly_symbol2scm ("Current")) - return this; + return Scheme_hash_table::unsmob (properties_scm_); +} - Translator_group* r = 0; - for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = ly_cdr (p)) +void +Context::add_context (Context*t) +{ + SCM ts = t->self_scm (); + context_list_ = ly_append2 (context_list_, + scm_cons (ts, SCM_EOL)); + + t->daddy_context_ = this; + if (!t->init_) { - Translator * t = unsmob_translator (ly_car (p)); + t->init_ = true; - r = dynamic_cast (t)->find_existing_translator (n, id); } + scm_gc_unprotect_object (ts); + Context_def * td = unsmob_context_def (t->definition_); + + /* + this can not move before add_context (), because \override + operations require that we are in the hierarchy. + */ + td->apply_default_property_operations (t); + + recurse_over_translators (t, &Translator::initialize, DOWN); + } +} + +Context::Context () +{ + daddy_context_ = 0; + init_ = false; + aliases_ = SCM_EOL; + iterator_count_ = 0; + implementation_ = SCM_EOL; + properties_scm_ = SCM_EOL; + accepts_list_ = SCM_EOL; + context_list_ = SCM_EOL; + definition_ = SCM_EOL; + + smobify_self (); - return r; + properties_scm_ = (new Scheme_hash_table)->self_scm (); + scm_gc_unprotect_object (properties_scm_); } -Translator_group* -Translator_group::find_create_translator (SCM n, String id, SCM operations) + +Context* +Context::find_create_context (SCM n, String id, + SCM operations) { - Translator_group * existing = find_existing_translator (n,id); + /* + Don't create multiple score contexts. + */ + if (dynamic_cast (this) + && dynamic_cast (this)->get_score_context ()) + return get_score_context ()->find_create_context (n, id, operations); + + + Context * existing = find_context_below (this, n,id); if (existing) return existing; + if (n == ly_symbol2scm ("Bottom")) + { + Context* tg = get_default_interpreter (); + tg->id_string_ = id; + return tg; + } /* TODO: use accepts_list_. */ Link_array path - = unsmob_context_def (definition_)->path_to_acceptable_translator (n, get_output_def ()); + = unsmob_context_def (definition_)->path_to_acceptable_context (n, get_output_def ()); if (path.size ()) { - Translator_group * current = this; + Context * current = this; // start at 1. The first one (index 0) will be us. for (int i=0; i < path.size (); i++) { SCM ops = (i == path.size () -1) ? operations : SCM_EOL; - Translator_group * new_group + Context * new_group = path[i]->instantiate (ops); if (i == path.size () -1) @@ -59,7 +143,7 @@ Translator_group::find_create_translator (SCM n, String id, SCM operations) new_group->id_string_ = id; } - current->add_fresh_group_translator (new_group); + current->add_context (new_group); apply_property_operations (new_group, ops); current = new_group; @@ -68,9 +152,13 @@ Translator_group::find_create_translator (SCM n, String id, SCM operations) return current; } - Translator_group *ret = 0; - if (daddy_trans_) - ret = daddy_trans_->find_create_translator (n, id, operations); + /* + Don't go up to Global_context, because global goes down to + Score_context + */ + Context *ret = 0; + if (daddy_context_ && !dynamic_cast (daddy_context_)) + ret = daddy_context_->find_create_context (n, id, operations); else { warning (_f ("Cannot find or create `%s' called `%s'", @@ -85,27 +173,27 @@ Translator_group::find_create_translator (SCM n, String id, SCM operations) none. */ SCM -default_child_context_name (Translator_group const *tg) +Context::default_child_context_name () const { - return gh_pair_p (tg->accepts_list_) - ? ly_car (scm_last_pair (tg->accepts_list_)) + return ly_c_pair_p (accepts_list_) + ? ly_car (scm_last_pair (accepts_list_)) : SCM_EOL; } bool -Translator_group::is_bottom_context () const +Context::is_bottom_context () const { - return !gh_symbol_p (default_child_context_name (this)); + return !scm_is_symbol (default_child_context_name ()); } -Translator_group* -Translator_group::get_default_interpreter () +Context* +Context::get_default_interpreter () { if (!is_bottom_context ()) { - SCM nm = default_child_context_name (this); - SCM st = get_output_def ()->find_translator (nm); + SCM nm = default_child_context_name (); + SCM st = find_context_def (get_output_def (), nm); Context_def *t = unsmob_context_def (st); if (!t) @@ -113,8 +201,8 @@ Translator_group::get_default_interpreter () warning (_f ("can't find or create: `%s'", ly_symbol2string (nm).to_str0 ())); t = unsmob_context_def (this->definition_); } - Translator_group *tg = t->instantiate (SCM_EOL); - add_fresh_group_translator (tg); + Context *tg = t->instantiate (SCM_EOL); + add_context (tg); if (!tg->is_bottom_context ()) return tg->get_default_interpreter (); else @@ -126,35 +214,55 @@ Translator_group::get_default_interpreter () /* PROPERTIES */ -Translator_group* -Translator_group::where_defined (SCM sym) const +Context* +Context::where_defined (SCM sym) const { if (properties_dict ()->contains (sym)) { - return (Translator_group*)this; + return (Context*)this; } - return (daddy_trans_) ? daddy_trans_->where_defined (sym) : 0; + return (daddy_context_) ? daddy_context_->where_defined (sym) : 0; } /* return SCM_EOL when not found. */ SCM -Translator_group::internal_get_property (SCM sym) const +Context::internal_get_property (SCM sym) const { SCM val =SCM_EOL; if (properties_dict ()->try_retrieve (sym, &val)) return val; - if (daddy_trans_) - return daddy_trans_->internal_get_property (sym); + if (daddy_context_) + return daddy_context_->internal_get_property (sym); return val; } +bool +Context::is_alias (SCM sym) const +{ + if (sym == ly_symbol2scm ("Bottom") + && !ly_c_pair_p (accepts_list_)) + return true; + if (sym == unsmob_context_def (definition_)->get_context_name ()) + return true; + + return scm_c_memq (sym, aliases_) != SCM_BOOL_F; +} + void -Translator_group::internal_set_property (SCM sym, SCM val) +Context::add_alias (SCM sym) +{ + aliases_ = scm_cons (sym, aliases_); +} + + + +void +Context::internal_set_property (SCM sym, SCM val) { #ifndef NDEBUG if (internal_type_checking_global_b) @@ -168,8 +276,175 @@ Translator_group::internal_set_property (SCM sym, SCM val) TODO: look up to check whether we have inherited var? */ void -Translator_group::unset_property (SCM sym) +Context::unset_property (SCM sym) { properties_dict ()->remove (sym); } +/** + Remove a context from the hierarchy. + */ +Context * +Context::remove_context (Context*trans) +{ + assert (trans); + + context_list_ = scm_delq_x (trans->self_scm (), context_list_); + trans->daddy_context_ = 0; + return trans; +} + +/* + ID == "" means accept any ID. + */ +Context * +find_context_below (Context * where, + SCM type, String id) +{ + if (where->is_alias (type)) + { + if (id == "" || where->id_string () == id) + return where; + } + + Context * found = 0; + for (SCM s = where->children_contexts (); + !found && ly_c_pair_p (s); s = ly_cdr (s)) + { + Context * tr = unsmob_context (ly_car (s)); + + found = find_context_below (tr, type, id); + } + + return found; +} + +SCM +Context::properties_as_alist () const +{ + return properties_dict ()->to_alist (); +} + +String +Context::context_name () const +{ + Context_def * td = unsmob_context_def (definition_ ); + return ly_symbol2string (td->get_context_name ()); +} + + +Score_context* +Context::get_score_context () const +{ + if (Score_context *sc =dynamic_cast ((Context*)this)) + return sc; + else if (daddy_context_) + return daddy_context_->get_score_context (); + else + return 0; +} + +Output_def * +Context::get_output_def () const +{ + return (daddy_context_) + ? daddy_context_->get_output_def () : 0; +} + +Context::~Context () +{ + +} + +Moment +Context::now_mom () const +{ + return daddy_context_->now_mom (); +} + +int +Context::print_smob (SCM s, SCM port, scm_print_state *) +{ + Context *sc = (Context *) ly_cdr (s); + + scm_puts ("#<", port); + scm_puts (classname (sc), port); + if (Context_def *d=unsmob_context_def (sc->definition_)) + { + scm_puts (" ", port); + scm_display (d->get_context_name (), port); + } + + if (Context *td=dynamic_cast (sc)) + { + scm_puts ("=", port); + scm_puts (td->id_string_.to_str0 (), port); + } + + + scm_puts (" ", port); + + scm_display (sc->context_list_, port); + scm_puts (" >", port); + + return 1; +} + +SCM +Context::mark_smob (SCM sm) +{ + Context * me = (Context*) SCM_CELL_WORD_1 (sm); + + scm_gc_mark (me->context_list_); + scm_gc_mark (me->aliases_); + scm_gc_mark (me->definition_); + scm_gc_mark (me->properties_scm_); + scm_gc_mark (me->accepts_list_); + scm_gc_mark (me->implementation_); + + return me->properties_scm_; +} + +IMPLEMENT_SMOBS (Context); +IMPLEMENT_DEFAULT_EQUAL_P (Context); +IMPLEMENT_TYPE_P (Context,"ly:context?"); + +bool +Context::try_music (Music* m) +{ + Translator* t = implementation (); + if (!t) + return false; + + bool b = t->try_music (m); + if (!b && daddy_context_) + b = daddy_context_->try_music (m); + + return b; +} + + +Global_context* +Context::get_global_context () const +{ + if (dynamic_cast((Context*) this)) + return dynamic_cast ((Context*) this); + + if (daddy_context_) + return daddy_context_->get_global_context (); + + programming_error ("No Global context!"); + return 0; +} + +Context* +Context::get_parent_context () const +{ + return daddy_context_; +} + +Translator_group* +Context::implementation () const +{ + return dynamic_cast (unsmob_translator (implementation_)); +}