X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fcontext.cc;h=8a85165cfdde63d5aef1c665786d3196b3f6acb0;hb=3dfd0a47e01374e0d8d1e6b127fa3f7a15a53edc;hp=ba3809e69a18d20f4c697562e54d84177bfa616a;hpb=37ca1f80bf5401accd17056938f4f7b2c147ddb2;p=lilypond.git diff --git a/lily/context.cc b/lily/context.cc index ba3809e69a..8a85165cfd 100644 --- a/lily/context.cc +++ b/lily/context.cc @@ -1,9 +1,20 @@ /* - context.cc -- implement Context + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2004--2014 Han-Wen Nienhuys - (c) 2004--2007 Han-Wen Nienhuys + 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 . */ #include "context.hh" @@ -12,7 +23,6 @@ #include "dispatcher.hh" #include "global-context.hh" #include "international.hh" -#include "ly-smobs.icc" #include "main.hh" #include "output-def.hh" #include "profile.hh" @@ -24,8 +34,8 @@ bool Context::is_removable () const { - return context_list_ == SCM_EOL && ! iterator_count_ - && !dynamic_cast (daddy_context_); + return context_list_ == SCM_EOL && ! client_count_ + && !dynamic_cast (daddy_context_); } void @@ -33,22 +43,21 @@ Context::check_removal () { for (SCM p = context_list_; scm_is_pair (p); p = scm_cdr (p)) { - Context *ctx = unsmob_context (scm_car (p)); + Context *ctx = Context::unsmob (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, &Translator::finalize, + &Translator_group::finalize, + UP); + send_stream_event (ctx, "RemoveContext", 0, 0); + } } } -Context::Context (Context const &src) +Context::Context (Context const & /* src */) { - (void) src; assert (false); } @@ -62,21 +71,21 @@ void Context::add_context (Context *child) { context_list_ = ly_append2 (context_list_, - scm_cons (child->self_scm (), SCM_EOL)); + scm_cons (child->self_scm (), SCM_EOL)); child->daddy_context_ = this; this->events_below_->register_as_listener (child->events_below_); } - Context::Context () { daddy_context_ = 0; aliases_ = SCM_EOL; - iterator_count_ = 0; + client_count_ = 0; implementation_ = 0; properties_scm_ = SCM_EOL; accepts_list_ = SCM_EOL; + default_child_ = SCM_EOL; context_list_ = SCM_EOL; definition_ = SCM_EOL; definition_mods_ = SCM_EOL; @@ -95,7 +104,7 @@ Context::Context () /* TODO: this shares code with find_create_context (). */ Context * -Context::create_unique_context (SCM name, string id, SCM operations) +Context::create_unique_context (SCM name, const string &id, SCM operations) { /* Don't create multiple score contexts. @@ -104,25 +113,25 @@ Context::create_unique_context (SCM name, string id, SCM operations) if (gthis && gthis->get_score_context ()) return gthis->get_score_context ()->create_unique_context (name, id, operations); - vector path = path_to_acceptable_context (name); + vector path = path_to_acceptable_context (name); if (path.size ()) { Context *current = this; // Iterate through the path and create all of the implicit contexts. for (vsize i = 0; i < path.size (); i++) - { - SCM ops = SCM_EOL; - string id_str = "\\new"; - if (i == path.size () - 1) - { - ops = operations; - id_str = id; - } - current = current->create_context (path[i], - id_str, - ops); - } + { + SCM ops = SCM_EOL; + string id_str = "\\new"; + if (i == path.size () - 1) + { + ops = operations; + id_str = id; + } + current = current->create_context (path[i], + id_str, + ops); + } return current; } @@ -137,32 +146,53 @@ Context::create_unique_context (SCM name, string id, SCM operations) else { warning (_f ("cannot find or create new `%s'", - ly_symbol2string (name).c_str ())); + ly_symbol2string (name).c_str ())); ret = 0; } return ret; } Context * -Context::find_create_context (SCM n, string id, SCM operations) +Context::find_create_context (SCM n, const string &id, SCM operations) { /* Don't create multiple score contexts. */ Global_context *gthis = dynamic_cast (this); - if (gthis && gthis->get_score_context ()) - return gthis->get_score_context ()->find_create_context (n, id, operations); + if (gthis) + { + if (gthis->get_score_context ()) + return gthis->get_score_context ()->find_create_context (n, id, operations); + + // Special case: If we use \set Timing.xxx = whatever before + // Score is established, the alias of Score to Timing will not + // be taken into account. We check for this particular case + // here. Aliases apart from Score-level ones don't warrant + // context creation as they could create unwanted contexts, like + // RhythmicVoice instead of Voice. Creating a Score context, + // however, can't really do anything wrong. + + 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 (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")) { - Context *tg = get_default_interpreter (); + Context *tg = get_default_interpreter (id); return tg; } - vector path = path_to_acceptable_context (n); + vector path = path_to_acceptable_context (n); if (path.size ()) { @@ -170,17 +200,17 @@ Context::find_create_context (SCM n, string id, SCM operations) // start at 1. The first one (index 0) will be us. for (vsize i = 0; i < path.size (); i++) - { - SCM ops = (i == path.size () -1) ? operations : SCM_EOL; + { + SCM ops = (i == path.size () - 1) ? operations : SCM_EOL; - string this_id = ""; - if (i == path.size () -1) - this_id = id; + string this_id = ""; + if (i == path.size () - 1) + this_id = id; - current = current->create_context (path[i], - this_id, - ops); - } + current = current->create_context (path[i], + this_id, + ops); + } return current; } @@ -195,7 +225,7 @@ Context::find_create_context (SCM n, string id, SCM operations) else { warning (_f ("cannot find or create `%s' called `%s'", - ly_symbol2string (n).c_str (), id)); + ly_symbol2string (n).c_str (), id)); ret = 0; } return ret; @@ -205,24 +235,30 @@ IMPLEMENT_LISTENER (Context, acknowledge_infant); void Context::acknowledge_infant (SCM sev) { - infant_event_ = unsmob_stream_event (sev); + infant_event_ = Stream_event::unsmob (sev); } IMPLEMENT_LISTENER (Context, set_property_from_event); void Context::set_property_from_event (SCM sev) { - Stream_event *ev = unsmob_stream_event (sev); - + Stream_event *ev = Stream_event::unsmob (sev); + SCM sym = ev->get_property ("symbol"); if (scm_is_symbol (sym)) { SCM val = ev->get_property ("value"); + + if (SCM_UNBNDP (val)) { + unset_property (sym); + return; + } + bool ok = true; - if (val != SCM_EOL) - ok = type_check_assignment (sym, val, ly_symbol2scm ("translation-type?")); + ok = type_check_assignment (sym, val, ly_symbol2scm ("translation-type?")); + if (ok) - set_property (sym, val); + set_property (sym, val); } } @@ -230,8 +266,8 @@ IMPLEMENT_LISTENER (Context, unset_property_from_event); void Context::unset_property_from_event (SCM sev) { - Stream_event *ev = unsmob_stream_event (sev); - + Stream_event *ev = Stream_event::unsmob (sev); + SCM sym = ev->get_property ("symbol"); type_check_assignment (sym, SCM_EOL, ly_symbol2scm ("translation-type?")); unset_property (sym); @@ -245,53 +281,53 @@ IMPLEMENT_LISTENER (Context, create_context_from_event); void Context::create_context_from_event (SCM sev) { - Stream_event *ev = unsmob_stream_event (sev); - + Stream_event *ev = Stream_event::unsmob (sev); + string id = ly_scm2string (ev->get_property ("id")); SCM ops = ev->get_property ("ops"); SCM type_scm = ev->get_property ("type"); string type = ly_symbol2string (type_scm); - - vector path = path_to_acceptable_context (type_scm); + + vector path = path_to_acceptable_context (type_scm); if (path.size () != 1) { - programming_error (_f ("Invalid CreateContext event: Cannot create %s context", type.c_str ())); + programming_error (to_string ("Invalid CreateContext event: Cannot create %s context", type.c_str ())); return; } Context_def *cdef = path[0]; - + Context *new_context = cdef->instantiate (ops); new_context->id_string_ = id; - + /* Register various listeners: - Make the new context hear events that universally affect contexts - connect events_below etc. properly */ /* 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), - ly_symbol2scm ("CreateContext")); + add_listener (GET_LISTENER (new_context->create_context_from_event), + ly_symbol2scm ("CreateContext")); new_context->event_source ()-> - add_listener (GET_LISTENER (new_context->remove_context), - ly_symbol2scm ("RemoveContext")); + add_listener (GET_LISTENER (new_context->remove_context), + ly_symbol2scm ("RemoveContext")); new_context->event_source ()-> - add_listener (GET_LISTENER (new_context->change_parent), - ly_symbol2scm ("ChangeParent")); + add_listener (GET_LISTENER (new_context->change_parent), + ly_symbol2scm ("ChangeParent")); new_context->event_source ()-> - add_listener (GET_LISTENER (new_context->set_property_from_event), - ly_symbol2scm ("SetProperty")); + add_listener (GET_LISTENER (new_context->set_property_from_event), + ly_symbol2scm ("SetProperty")); new_context->event_source ()-> - add_listener (GET_LISTENER (new_context->unset_property_from_event), - ly_symbol2scm ("UnsetProperty")); + add_listener (GET_LISTENER (new_context->unset_property_from_event), + ly_symbol2scm ("UnsetProperty")); new_context->events_below_->register_as_listener (new_context->event_source_); this->add_context (new_context); new_context->unprotect (); - Context_def *td = unsmob_context_def (new_context->definition_); + Context_def *td = Context_def::unsmob (new_context->definition_); /* This cannot move before add_context (), because \override operations require that we are in the hierarchy. */ @@ -299,40 +335,40 @@ Context::create_context_from_event (SCM sev) apply_property_operations (new_context, ops); send_stream_event (this, "AnnounceNewContext", 0, - ly_symbol2scm ("context"), new_context->self_scm (), - ly_symbol2scm ("creator"), sev); + ly_symbol2scm ("context"), new_context->self_scm (), + ly_symbol2scm ("creator"), sev); } -vector +vector Context::path_to_acceptable_context (SCM name) const { // The 'accepts elements in definition_mods_ is a list of ('accepts string), // but the Context_def expects to see elements of the form ('accepts symbol). SCM accepts = SCM_EOL; - for (SCM s = scm_reverse (definition_mods_); scm_is_pair (s); s = scm_cdr (s)) + for (SCM s = definition_mods_; scm_is_pair (s); s = scm_cdr (s)) if (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); + SCM elt = scm_list_2 (scm_caar (s), scm_string_to_symbol (scm_cadar (s))); + accepts = scm_cons (elt, accepts); } - return unsmob_context_def (definition_)->path_to_acceptable_context (name, - get_output_def (), - accepts); - + return Context_def::unsmob (definition_)->path_to_acceptable_context (name, + get_output_def (), + scm_reverse_x (accepts, SCM_EOL)); + } Context * Context::create_context (Context_def *cdef, - string id, - SCM ops) + const string &id, + SCM ops) { infant_event_ = 0; /* 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), - ly_symbol2scm ("AnnounceNewContext")); + add_listener (GET_LISTENER (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 infant_event_ to create a return value. */ @@ -341,12 +377,12 @@ Context::create_context (Context_def *cdef, ly_symbol2scm ("type"), cdef->get_context_name (), ly_symbol2scm ("id"), ly_string2scm (id)); event_source_-> - remove_listener (GET_LISTENER (acknowledge_infant), - ly_symbol2scm ("AnnounceNewContext")); + remove_listener (GET_LISTENER (acknowledge_infant), + ly_symbol2scm ("AnnounceNewContext")); assert (infant_event_); SCM infant_scm = infant_event_->get_property ("context"); - Context *infant = unsmob_context (infant_scm); + Context *infant = Context::unsmob (infant_scm); if (!infant || infant->get_parent_context () != this) { @@ -364,9 +400,7 @@ Context::create_context (Context_def *cdef, SCM Context::default_child_context_name () const { - return scm_is_pair (accepts_list_) - ? scm_car (accepts_list_) - : SCM_EOL; + return default_child_; } bool @@ -376,7 +410,7 @@ Context::is_bottom_context () const } Context * -Context::get_default_interpreter () +Context::get_default_interpreter (const string &context_id) { if (!is_bottom_context ()) { @@ -384,15 +418,25 @@ Context::get_default_interpreter () SCM st = find_context_def (get_output_def (), nm); string name = ly_symbol2string (nm); - Context_def *t = unsmob_context_def (st); + Context_def *t = Context_def::unsmob (st); if (!t) - { - warning (_f ("cannot find or create: `%s'", name.c_str ())); - t = unsmob_context_def (this->definition_); - } - - Context *tg = create_context (t, "", SCM_EOL); - return tg->get_default_interpreter (); + { + warning (_f ("cannot find or create: `%s'", name.c_str ())); + t = Context_def::unsmob (this->definition_); + } + if (scm_is_symbol (t->get_default_child (SCM_EOL))) + { + Context *tg = create_context (t, "\\new", SCM_EOL); + return tg->get_default_interpreter (context_id); + } + return create_context (t, context_id, SCM_EOL); + } + else if (!context_id.empty () && context_id != id_string ()) + { + if (daddy_context_ && !dynamic_cast (daddy_context_)) + return daddy_context_->get_default_interpreter (context_id); + warning (_f ("cannot find or create new Bottom = \"%s\"", + context_id.c_str ())); } return this; } @@ -414,6 +458,19 @@ Context::where_defined (SCM sym, SCM *value) const 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 +{ +#ifndef NDEBUG + 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. */ @@ -443,10 +500,12 @@ be called from any other place than the send_stream_event macro. void Context::internal_send_stream_event (SCM type, Input *origin, SCM props[]) { - Stream_event *e = new Stream_event (type, 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]); + e->set_property (props[i], props[i + 1]); } event_source_->broadcast (e); e->unprotect (); @@ -455,10 +514,9 @@ Context::internal_send_stream_event (SCM type, Input *origin, SCM props[]) bool Context::is_alias (SCM sym) const { - if (sym == ly_symbol2scm ("Bottom") - && !scm_is_pair (accepts_list_)) - return true; - if (sym == unsmob_context_def (definition_)->get_context_name ()) + if (scm_is_eq (sym, ly_symbol2scm ("Bottom"))) + return is_bottom_context (); + if (scm_is_eq (sym, context_name_symbol ())) return true; return scm_c_memq (sym, aliases_) != SCM_BOOL_F; @@ -472,7 +530,7 @@ Context::add_alias (SCM sym) /* we don't (yet) instrument context properties */ void -Context::instrumented_set_property (SCM sym, SCM val, const char*, int, const char*) +Context::instrumented_set_property (SCM sym, SCM val, const char *, int, const char *) { internal_set_property (sym, val); } @@ -480,10 +538,13 @@ Context::instrumented_set_property (SCM sym, SCM val, const char*, int, const ch void Context::internal_set_property (SCM sym, SCM val) { + bool type_check_ok = type_check_assignment (sym, val, ly_symbol2scm ("translation-type?")); + if (do_internal_type_checking_global) - assert (type_check_assignment (sym, val, ly_symbol2scm ("translation-type?"))); + assert (type_check_ok); - properties_dict ()->set (sym, val); + if (type_check_ok) + properties_dict ()->set (sym, val); } /* @@ -499,8 +560,8 @@ IMPLEMENT_LISTENER (Context, change_parent); void Context::change_parent (SCM sev) { - Stream_event *ev = unsmob_stream_event (sev); - Context *to = unsmob_context (ev->get_property ("context")); + Stream_event *ev = Stream_event::unsmob (sev); + Context *to = Context::unsmob (ev->get_property ("context")); disconnect_from_parent (); to->add_context (this); @@ -533,19 +594,19 @@ Context::disconnect_from_parent () */ Context * find_context_below (Context *where, - SCM type, string id) + SCM type, const string &id) { if (where->is_alias (type)) { if (id == "" || where->id_string () == id) - return where; + return where; } Context *found = 0; for (SCM s = where->children_contexts (); !found && scm_is_pair (s); s = scm_cdr (s)) { - Context *tr = unsmob_context (scm_car (s)); + Context *tr = Context::unsmob (scm_car (s)); found = find_context_below (tr, type, id); } @@ -562,7 +623,7 @@ Context::properties_as_alist () const SCM Context::context_name_symbol () const { - Context_def *td = unsmob_context_def (definition_); + Context_def *td = Context_def::unsmob (definition_); return td->get_context_name (); } @@ -608,7 +669,7 @@ Context::print_smob (SCM s, SCM port, scm_print_state *) scm_puts ("#<", port); scm_puts (sc->class_name (), port); - if (Context_def *d = unsmob_context_def (sc->definition_)) + if (Context_def *d = Context_def::unsmob (sc->definition_)) { scm_puts (" ", port); scm_display (d->get_context_name (), port); @@ -639,6 +700,7 @@ Context::mark_smob (SCM sm) 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 (me->implementation_) scm_gc_mark (me->implementation_->self_scm ()); @@ -652,9 +714,7 @@ Context::mark_smob (SCM sm) return me->properties_scm_; } -IMPLEMENT_SMOBS (Context); -IMPLEMENT_DEFAULT_EQUAL_P (Context); -IMPLEMENT_TYPE_P (Context, "ly:context?"); +const char Context::type_p_name_[] = "ly:context?"; Global_context * Context::get_global_context () const @@ -683,8 +743,8 @@ measure_length (Context const *context) { SCM l = context->get_property ("measureLength"); Rational length (1); - if (unsmob_moment (l)) - length = unsmob_moment (l)->main_part_; + if (Moment::unsmob (l)) + length = Moment::unsmob (l)->main_part_; return length; } @@ -694,21 +754,49 @@ measure_position (Context const *context) SCM sm = context->get_property ("measurePosition"); Moment m = 0; - if (unsmob_moment (sm)) + if (Moment::unsmob (sm)) { - m = *unsmob_moment (sm); + m = *Moment::unsmob (sm); if (m.main_part_ < Rational (0)) - { - Rational length (measure_length (context)); - while (m.main_part_ < Rational (0)) - m.main_part_ += length; - } + { + Rational length (measure_length (context)); + while (m.main_part_ < Rational (0)) + m.main_part_ += length; + } } return m; } +/* Finds the measure position after a note of length DUR that + begins at the current measure position. */ +Moment +measure_position (Context const *context, Duration const *dur) +{ + Moment pos = measure_position (context); + Rational dur_length = dur ? dur->get_length () : Rational (0); + + Moment end_pos = pos.grace_part_ < Rational (0) + ? Moment (pos.main_part_, pos.grace_part_ + dur_length) + : Moment (pos.main_part_ + dur_length, 0); + + return end_pos; +} + +int +measure_number (Context const *context) +{ + SCM barnum = context->get_property ("internalBarNumber"); + SCM smp = context->get_property ("measurePosition"); + + int bn = robust_scm2int (barnum, 0); + Moment mp = robust_scm2moment (smp, Moment (0)); + if (mp.main_part_ < Rational (0)) + bn--; + + return bn; +} void set_context_property_on_children (Context *trans, SCM sym, SCM val) @@ -716,7 +804,7 @@ set_context_property_on_children (Context *trans, SCM sym, SCM val) trans->set_property (sym, ly_deep_copy (val)); for (SCM p = trans->children_contexts (); scm_is_pair (p); p = scm_cdr (p)) { - Context *trg = unsmob_context (scm_car (p)); + Context *trg = Context::unsmob (scm_car (p)); set_context_property_on_children (trg, sym, ly_deep_copy (val)); } } @@ -729,7 +817,17 @@ melisma_busy (Context *tr) for (; !busy && scm_is_pair (melisma_properties); melisma_properties = scm_cdr (melisma_properties)) - busy = busy || to_boolean (tr->internal_get_property (scm_car (melisma_properties))); + busy = busy || to_boolean (tr->get_property (scm_car (melisma_properties))); return busy; } + +bool +check_repeat_count_visibility (Context const *context, SCM count) +{ + SCM proc = context->get_property ("repeatCountVisibility"); + return (ly_is_procedure (proc) + && to_boolean (scm_call_2 (proc, + count, + context->self_scm ()))); +}