X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fcontext.cc;h=6759a21d713ac7c5f036f9c0bc45415b5379a170;hb=3032301cc8609347d997cd4367aa7ab055196e80;hp=6dff7f838bab86575324979414078f7521cb2f54;hpb=4bad5860a1f2984e55c37aa95d8a4cd19216ba97;p=lilypond.git diff --git a/lily/context.cc b/lily/context.cc index 6dff7f838b..6759a21d71 100644 --- a/lily/context.cc +++ b/lily/context.cc @@ -1,221 +1,329 @@ -/* - context.cc -- implement Context +/* + context.cc -- implement Context source file of the GNU LilyPond music typesetter - (c) 2004 Han-Wen Nienhuys - + (c) 2004--2005 Han-Wen Nienhuys */ -#include "translator-group.hh" -#include "context-def.hh" #include "context.hh" -#include "warn.hh" -#include "music-output-def.hh" -#include "scm-hash.hh" -#include "main.hh" + +#include "program-option.hh" +#include "context-def.hh" #include "ly-smobs.icc" +#include "main.hh" +#include "output-def.hh" +#include "scm-hash.hh" #include "score-context.hh" +#include "translator-group.hh" +#include "warn.hh" +#include "lilypond-key.hh" +#include "profile.hh" + bool Context::is_removable () const { - return context_list_ == SCM_EOL && ! iterator_count_ && - !dynamic_cast (this) - ; + return context_list_ == SCM_EOL && ! iterator_count_ + && !dynamic_cast (this); } - void Context::check_removal () { - for (SCM p = context_list_; gh_pair_p (p); p = gh_cdr (p)) + for (SCM p = context_list_; scm_is_pair (p); p = scm_cdr (p)) { - Context *trg = unsmob_context (ly_car (p)); + Context *trg = unsmob_context (scm_car (p)); trg->check_removal (); if (trg->is_removable ()) { - recurse_down_translators (trg, &Translator::finalize, false); + recurse_over_translators (trg, &Translator::finalize, + &Translator_group::finalize, + UP); remove_context (trg); } } } -Context::Context (Context const&) +Context::Context (Context const &) { assert (false); } -Scheme_hash_table* +Scheme_hash_table * Context::properties_dict () const { return Scheme_hash_table::unsmob (properties_scm_); } void -Context::add_context (Context*t) +Context::add_context (Context *t) { SCM ts = t->self_scm (); - context_list_ = gh_append2 (context_list_, - gh_cons (ts, SCM_EOL)); - + context_list_ = ly_append2 (context_list_, + scm_cons (ts, SCM_EOL)); + t->daddy_context_ = this; if (!t->init_) { t->init_ = true; - - 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. - */ + t->unprotect (); + Context_def *td = unsmob_context_def (t->definition_); + + /* This cannot move before add_context (), because \override + operations require that we are in the hierarchy. */ td->apply_default_property_operations (t); - recurse_down_translators (t, &Translator::initialize, true); + recurse_over_translators (t, + &Translator::initialize, + &Translator_group::initialize, + DOWN); } } -Context::Context () +Object_key const * +Context::get_key () const { + return key_; +} + +Context::Context (Object_key const *key) +{ + key_ = key; daddy_context_ = 0; init_ = false; - iterator_count_ = 0; - implementation_ = SCM_EOL; + aliases_ = SCM_EOL; + iterator_count_ = 0; + implementation_ = 0; properties_scm_ = SCM_EOL; accepts_list_ = SCM_EOL; context_list_ = SCM_EOL; definition_ = SCM_EOL; - + smobify_self (); + + Scheme_hash_table *tab = new Scheme_hash_table; + properties_scm_ = tab->unprotect (); - Scheme_hash_table *tab = new Scheme_hash_table ; - properties_scm_ = tab->self_scm (); - scm_gc_unprotect_object (tab->self_scm ()); + /* + UGH UGH + const correctness. + */ + if (key_) + ((Object_key*)key)->unprotect (); } +/* TODO: this shares code with find_create_context (). */ Context * -Context::find_existing_context (SCM n, String id) +Context::create_unique_context (SCM n, SCM operations) { - if ((is_alias (n) && (id_string_ == id || id.is_empty ())) || n == ly_symbol2scm ("Current")) - return this; + /* + Don't create multiple score contexts. + */ + if (dynamic_cast (this) + && dynamic_cast (this)->get_score_context ()) + return get_score_context ()->create_unique_context (n, operations); - Context* r = 0; - for (SCM p = context_list_; !r && gh_pair_p (p); p = ly_cdr (p)) + /* + TODO: use accepts_list_. + */ + Link_array path + = unsmob_context_def (definition_)->path_to_acceptable_context (n, get_output_def ()); + + if (path.size ()) { - Context * t = unsmob_context (ly_car (p)); - - r = dynamic_cast (t)->find_existing_context (n, id); + 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; + + current = current->create_context (path[i], + "\\new", + ops); + } + + return current; } - return r; + /* + 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_->create_unique_context (n, operations); + else + { + warning (_f ("can't find or create new `%s'", + ly_symbol2string (n).to_str0 ())); + ret = 0; + } + return ret; } - -Context* -Context::find_create_context (SCM n, String id, - SCM operations) +Context * +Context::find_create_context (SCM n, String id, SCM operations) { /* Don't create multiple score contexts. - */ - if (dynamic_cast (this) - && dynamic_cast (this)->get_score_context ()) + */ + if (dynamic_cast (this) + && dynamic_cast (this)->get_score_context ()) return get_score_context ()->find_create_context (n, id, operations); - - - Context * existing = find_existing_context (n,id); - if (existing) + + if (Context *existing = find_context_below (this, n, id)) return existing; if (n == ly_symbol2scm ("Bottom")) { - Context* tg = get_default_interpreter (); - tg->id_string_ = id; + Context *tg = get_default_interpreter (); return tg; } /* TODO: use accepts_list_. - */ + */ Link_array path = unsmob_context_def (definition_)->path_to_acceptable_context (n, get_output_def ()); if (path.size ()) { - Context * current = this; + Context *current = this; // start at 1. The first one (index 0) will be us. - for (int i=0; i < path.size (); i++) + for (int i = 0; i < path.size (); i++) { SCM ops = (i == path.size () -1) ? operations : SCM_EOL; - Context * new_group - = path[i]->instantiate (ops); - + String this_id = ""; if (i == path.size () -1) { - new_group->id_string_ = id; + this_id = id; } - current->add_context (new_group); - apply_property_operations (new_group, ops); - - current = new_group; + current = current->create_context (path[i], + this_id, + ops); } return current; } + /* + Don't go up to Global_context, because global goes down to + Score_context + */ Context *ret = 0; - if (daddy_context_) + 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'", + warning (_f ("can't find or create `%s' called `%s'", ly_symbol2string (n).to_str0 (), id)); - ret =0; + ret = 0; } return ret; } +Context * +Context::create_context (Context_def *cdef, + String id, + SCM ops) +{ + String type = ly_symbol2string (cdef->get_context_name ()); + Object_key const *key = get_context_key (type, id); + Context *new_context + = cdef->instantiate (ops, key); + + new_context->id_string_ = id; + add_context (new_context); + apply_property_operations (new_context, ops); + + return new_context; +} + +Object_key const * +Context::get_context_key (String type, String id) +{ + if (!use_object_keys) + return 0; + + String now_key = type + "@" + id; + + int disambiguation_count = 0; + if (context_counts_.find (now_key) != context_counts_.end ()) + { + disambiguation_count = context_counts_[now_key]; + } + + context_counts_[now_key] = disambiguation_count + 1; + + return new Lilypond_context_key (get_key (), + now_mom (), + type, id, + disambiguation_count); +} + +Object_key const * +Context::get_grob_key (String name) +{ + if (!use_object_keys) + return 0; + + int disambiguation_count = 0; + if (grob_counts_.find (name) != grob_counts_.end ()) + { + disambiguation_count = grob_counts_[name]; + } + grob_counts_[name] = disambiguation_count + 1; + + Object_key *k = new Lilypond_grob_key (get_key (), + now_mom (), + name, + disambiguation_count); + + return k; +} + /* Default child context as a SCM string, or something else if there is none. */ SCM -default_child_context_name (Context const *tg) +Context::default_child_context_name () const { - return gh_pair_p (tg->accepts_list_) - ? ly_car (scm_last_pair (tg->accepts_list_)) + return scm_is_pair (accepts_list_) + ? scm_car (accepts_list_) : SCM_EOL; } - bool Context::is_bottom_context () const { - return !gh_symbol_p (default_child_context_name (this)); + return !scm_is_symbol (default_child_context_name ()); } -Context* +Context * Context::get_default_interpreter () { if (!is_bottom_context ()) { - SCM nm = default_child_context_name (this); - SCM st = get_output_def ()->find_context_def (nm); + SCM nm = default_child_context_name (); + SCM st = find_context_def (get_output_def (), nm); + String name = ly_symbol2string (nm); Context_def *t = unsmob_context_def (st); if (!t) { - warning (_f ("can't find or create: `%s'", ly_symbol2string (nm).to_str0 ())); + warning (_f ("can't find or create: `%s'", name.to_str0 ())); t = unsmob_context_def (this->definition_); } - Context *tg = t->instantiate (SCM_EOL); - add_context (tg); + + Context *tg = create_context (t, "", SCM_EOL); if (!tg->is_bottom_context ()) return tg->get_default_interpreter (); else @@ -226,16 +334,23 @@ Context::get_default_interpreter () /* PROPERTIES - */ -Context* -Context::where_defined (SCM sym) const +*/ +Context * +Context::where_defined (SCM sym, SCM *value) const { - if (properties_dict ()->contains (sym)) +#ifndef NDEBUG + if (profile_property_accesses) + { + note_property_access (&context_property_lookup_table, sym); + } +#endif + + if (properties_dict ()->try_retrieve (sym, value)) { - return (Context*)this; + return (Context *)this; } - return (daddy_context_) ? daddy_context_->where_defined (sym) : 0; + return (daddy_context_) ? daddy_context_->where_defined (sym, value) : 0; } /* @@ -244,13 +359,20 @@ Context::where_defined (SCM sym) const SCM Context::internal_get_property (SCM sym) const { - SCM val =SCM_EOL; +#ifndef NDEBUG + if (profile_property_accesses) + { + note_property_access (&context_property_lookup_table, sym); + } +#endif + + SCM val = SCM_EOL; if (properties_dict ()->try_retrieve (sym, &val)) return val; if (daddy_context_) return daddy_context_->internal_get_property (sym); - + return val; } @@ -258,25 +380,34 @@ bool Context::is_alias (SCM sym) const { if (sym == ly_symbol2scm ("Bottom") - && !gh_pair_p (accepts_list_)) + && !scm_is_pair (accepts_list_)) return true; - return unsmob_context_def (definition_)->is_alias (sym); + if (sym == unsmob_context_def (definition_)->get_context_name ()) + return true; + + return scm_c_memq (sym, aliases_) != SCM_BOOL_F; +} + +void +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) + if (do_internal_type_checking_global) assert (type_check_assignment (sym, val, ly_symbol2scm ("translation-type?"))); #endif - + properties_dict ()->set (sym, val); } /* - TODO: look up to check whether we have inherited var? - */ + TODO: look up to check whether we have inherited var? +*/ void Context::unset_property (SCM sym) { @@ -285,9 +416,9 @@ Context::unset_property (SCM sym) /** Remove a context from the hierarchy. - */ +*/ Context * -Context::remove_context (Context*trans) +Context::remove_context (Context *trans) { assert (trans); @@ -298,47 +429,52 @@ Context::remove_context (Context*trans) /* ID == "" means accept any ID. - */ +*/ Context * -find_context_below (Context * where, - String type, String id) +find_context_below (Context *where, + SCM type, String id) { - if (where->is_alias (ly_symbol2scm (type.to_str0 ()))) + if (where->is_alias (type)) { - if (id == "" || where->id_string_ == id) + if (id == "" || where->id_string () == id) return where; } - - Context * found = 0; - for (SCM s = where->context_list_; - !found && gh_pair_p (s); s = gh_cdr (s)) + + Context *found = 0; + for (SCM s = where->children_contexts (); + !found && scm_is_pair (s); s = scm_cdr (s)) { - Context * tr = unsmob_context (gh_car (s)); + Context *tr = unsmob_context (scm_car (s)); found = find_context_below (tr, type, id); } - return found; + return found; } SCM Context::properties_as_alist () const { - return properties_dict()->to_alist(); + return properties_dict ()->to_alist (); +} + +SCM +Context::context_name_symbol () const +{ + Context_def *td = unsmob_context_def (definition_); + return td->get_context_name (); } String Context::context_name () const { - Context_def * td = unsmob_context_def (definition_ ); - return ly_symbol2string (td->get_context_name ()); + return ly_symbol2string (context_name_symbol ()); } - -Score_context* +Score_context * Context::get_score_context () const { - if (Score_context *sc =dynamic_cast ((Context*)this)) + if (Score_context *sc = dynamic_cast ((Context *) this)) return sc; else if (daddy_context_) return daddy_context_->get_score_context (); @@ -346,77 +482,84 @@ Context::get_score_context () const return 0; } -Music_output_def * +Output_def * Context::get_output_def () const { - return (daddy_context_) - ? daddy_context_->get_output_def () : 0; + return daddy_context_ ? daddy_context_->get_output_def () : 0; } -Context::~Context() +Context::~Context () { - } Moment Context::now_mom () const { - return daddy_context_->now_mom(); + Context const *p = this; + while (p->daddy_context_) + { + p = p->daddy_context_; + } + + return p->now_mom (); } int Context::print_smob (SCM s, SCM port, scm_print_state *) { - Context *sc = (Context *) ly_cdr (s); - + Context *sc = (Context *) SCM_CELL_WORD_1 (s); + scm_puts ("#<", port); scm_puts (classname (sc), port); - if (Context_def *d=unsmob_context_def (sc->definition_)) + 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)) + if (!sc->id_string_.is_empty ()) { scm_puts ("=", port); - scm_puts (td->id_string_.to_str0 (), port); + scm_puts (sc->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); + Context *me = (Context *) SCM_CELL_WORD_1 (sm); + if (me->key_) + scm_gc_mark (me->key_->self_scm ()); scm_gc_mark (me->context_list_); - scm_gc_mark (me->definition_); - scm_gc_mark (me->properties_scm_); + 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_); + if (me->implementation_) + scm_gc_mark (me->implementation_->self_scm ()); return me->properties_scm_; } IMPLEMENT_SMOBS (Context); IMPLEMENT_DEFAULT_EQUAL_P (Context); -IMPLEMENT_TYPE_P(Context,"ly:context?"); +IMPLEMENT_TYPE_P (Context, "ly:context?"); bool -Context::try_music (Music* m) +Context::try_music (Music *m) { - Translator* t = unsmob_translator (implementation_); + Translator_group *t = implementation (); if (!t) return false; - + bool b = t->try_music (m); if (!b && daddy_context_) b = daddy_context_->try_music (m); @@ -424,16 +567,70 @@ Context::try_music (Music* m) return b; } - -Global_context* +Global_context * Context::get_global_context () const { - if (dynamic_cast((Context*) this)) - return dynamic_cast ((Context*) this); + if (dynamic_cast ((Context *) this)) + return dynamic_cast ((Context *) this); if (daddy_context_) return daddy_context_->get_global_context (); - programming_error ("No Global context!"); + programming_error ("no Global context"); return 0; } + +Context * +Context::get_parent_context () const +{ + return daddy_context_; +} + +void +Context::clear_key_disambiguations () +{ + if (!use_object_keys) + return; + + grob_counts_.clear (); + context_counts_.clear (); + for (SCM s = context_list_; scm_is_pair (s); s = scm_cdr (s)) + { + unsmob_context (scm_car (s))->clear_key_disambiguations (); + } +} + + +/* + Ugh. Where to put this? +*/ +Rational +measure_length (Context const *context) +{ + SCM l = context->get_property ("measureLength"); + Rational length (1); + if (unsmob_moment (l)) + length = unsmob_moment (l)->main_part_; + return length; +} + +Moment +measure_position (Context const *context) +{ + SCM sm = context->get_property ("measurePosition"); + + Moment m = 0; + if (unsmob_moment (sm)) + { + m = *unsmob_moment (sm); + + if (m.main_part_ < Rational (0)) + { + Rational length (measure_length (context)); + while (m.main_part_ < Rational (0)) + m.main_part_ += length; + } + } + + return m; +}