/*
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 "international.hh"
#include "item.hh"
#include "main.hh"
-#include "simple-closure.hh"
#include "smobs.hh"
#include "spanner.hh"
#include "unpure-pure-container.hh"
SCM grob_property_path,
SCM new_value)
{
+ // Numbers may appear, but not in first place
if (!scm_is_symbol (context_property)
|| !scm_is_symbol (scm_car (grob_property_path)))
{
- warning (_ ("need symbol arguments for \\override and \\revert"));
+ warning (_ ("need symbol argument for \\override and \\revert"));
if (do_internal_type_checking_global)
assert (false);
}
bool
typecheck_grob (SCM symbol, SCM value)
{
- if (is_unpure_pure_container (value))
- return typecheck_grob (symbol, unpure_pure_container_unpure_part (value))
- && typecheck_grob (symbol, unpure_pure_container_pure_part (value));
+ if (Unpure_pure_container *upc = unsmob<Unpure_pure_container> (value))
+ return typecheck_grob (symbol, upc->unpure_part ())
+ && typecheck_grob (symbol, upc->pure_part ());
return ly_is_procedure (value)
- || is_simple_closure (value)
|| type_check_assignment (symbol, value, ly_symbol2scm ("backend-type?"));
}
-class Grob_properties {
+class Grob_properties : public Simple_smob<Grob_properties>
+{
+public:
+ SCM mark_smob () const;
+ static const char * const type_p_name_;
+private:
friend class Grob_property_info;
friend SCM ly_make_grob_properties (SCM);
+ // alist_ may contain unexpanded nested overrides
SCM alist_;
+ // based_on_ is the cooked_ value from the next higher context that
+ // alist_ is based on
SCM based_on_;
+ // cooked_ is a version of alist_ where nested overrides have been
+ // expanded
+ SCM cooked_;
+ // cooked_from_ is the value of alist_ from which the expansion has
+ // been done
+ SCM cooked_from_;
+ // nested_ is a count of nested overrides in alist_ Or rather: of
+ // entries that must not appear in the cooked list and are
+ // identified by having a "key" that is not a symbol. Temporary
+ // overrides and reverts also meet that description and have a
+ // nominal key of #t/#f and a value of the original cons cell.
+ int nested_;
Grob_properties (SCM alist, SCM based_on) :
- alist_ (alist), based_on_ (based_on) { }
- DECLARE_SIMPLE_SMOBS (Grob_properties);
+ alist_ (alist), based_on_ (based_on),
+ // if the constructor was called with lists possibly containing
+ // partial overrides, we would need to initialize with based_on in
+ // order to trigger an initial update. But this should never
+ // happen, so we initialize straight with alist.
+ cooked_ (alist), cooked_from_ (alist), nested_ (0) { }
};
-#include "ly-smobs.icc"
-IMPLEMENT_SIMPLE_SMOBS (Grob_properties);
-IMPLEMENT_DEFAULT_EQUAL_P (Grob_properties);
-IMPLEMENT_TYPE_P (Grob_properties, "ly:grob-properties?");
+const char * const Grob_properties::type_p_name_ = "ly:grob-properties?";
SCM
-Grob_properties::mark_smob (SCM smob)
+Grob_properties::mark_smob () const
{
- Grob_properties *gp = (Grob_properties *) SCM_SMOB_DATA (smob);
- scm_gc_mark (gp->alist_);
- return gp->based_on_;
-}
-
-int
-Grob_properties::print_smob (SCM /*smob*/, SCM port, scm_print_state *)
-{
- scm_puts ("#<Grob_properties>", port);
-
- return 1;
+ scm_gc_mark (alist_);
+ scm_gc_mark (based_on_);
+ scm_gc_mark (cooked_);
+ return cooked_from_;
}
LY_DEFINE (ly_make_grob_properties, "ly:make-grob-properties",
SCM res = SCM_UNDEFINED;
if (Context *c = context_->where_defined (symbol_, &res))
if (c != context_)
- return Grob_property_info (c, symbol_, Grob_properties::unsmob (res));
- props_ = Grob_properties::unsmob (res);
+ return Grob_property_info (c, symbol_, unsmob<Grob_properties> (res));
+ props_ = unsmob<Grob_properties> (res);
return *this;
}
return true;
SCM res = SCM_UNDEFINED;
if (context_->here_defined (symbol_, &res))
- props_ = Grob_properties::unsmob (res);
+ props_ = unsmob<Grob_properties> (res);
return props_;
}
|| !g->here_defined (symbol_, ¤t_context_val))
return false;
- Grob_properties *def = Grob_properties::unsmob (current_context_val);
+ Grob_properties *def = unsmob<Grob_properties> (current_context_val);
if (!def)
{
// any, they will be factored in when `updated' is being called.
SCM props = Grob_properties (def->alist_, def->alist_).smobbed_copy ();
context_->set_property (symbol_, props);
- props_ = Grob_properties::unsmob (props);
+ props_ = unsmob<Grob_properties> (props);
return props_;
}
alist defined in a parent context. BASED-ON should always be a tail
of ALIST.
- Push or pop (depending on value of VAL) a single entry from a
+ Push a single entry from a
translator property list by name of PROP. GROB_PROPERTY_PATH
indicates nested alists, eg. '(beamed-stem-lengths details)
+
+ Return value can be passed to matched_pop and will only cancel the
+ same override then.
*/
-void
+SCM
Grob_property_info::push (SCM grob_property_path, SCM new_value)
{
/*
Don't mess with MIDI.
*/
if (!create ())
- return;
+ return SCM_EOL;
SCM symbol = scm_car (grob_property_path);
- if (scm_is_pair (scm_cdr (grob_property_path)))
+ SCM rest = scm_cdr (grob_property_path);
+ if (scm_is_pair (rest))
{
- new_value = nested_property_alist (ly_assoc_get (symbol, updated (),
- SCM_EOL),
- scm_cdr (grob_property_path),
- new_value);
+ // poor man's typechecking
+ if (typecheck_grob (symbol, nested_create_alist (rest, new_value))) {
+ SCM cell = scm_cons (grob_property_path, new_value);
+ props_->alist_ = scm_cons (cell, props_->alist_);
+ props_->nested_++;
+ return cell;
+ }
+ return SCM_EOL;
}
/* it's tempting to replace the head of the list if it's the same
*/
if (typecheck_grob (symbol, new_value))
- props_->alist_ = scm_acons (symbol, new_value, props_->alist_);
+ {
+ SCM cell = scm_cons (symbol, new_value);
+ props_->alist_ = scm_cons (cell, props_->alist_);
+ return cell;
+ }
+ return SCM_EOL;
+}
+
+// Used for \once \override, returns a token for matched_pop
+SCM
+Grob_property_info::temporary_override (SCM grob_property_path, SCM new_value)
+{
+ SCM cell = push (grob_property_path, new_value);
+ if (!scm_is_pair (cell))
+ return cell;
+ if (scm_is_symbol (scm_car (cell)))
+ props_->nested_++;
+ cell = scm_cons (SCM_BOOL_T, cell);
+ props_->alist_ = scm_cons (cell, scm_cdr (props_->alist_));
+ return cell;
+}
+
+// Used for \once \revert, returns a token for matched_pop
+SCM
+Grob_property_info::temporary_revert (SCM grob_property_path)
+{
+ if (!check ())
+ return SCM_EOL;
+
+ SCM current_alist = props_->alist_;
+ SCM daddy = props_->based_on_;
+ SCM tail = SCM_EOL;
+
+ if (!scm_is_pair (grob_property_path)
+ || !scm_is_symbol (scm_car (grob_property_path)))
+ {
+ programming_error ("Grob property path should be list of symbols.");
+ return SCM_EOL;
+ }
+
+ if (scm_is_pair (scm_cdr (grob_property_path)))
+ {
+ tail = assoc_tail (grob_property_path, current_alist, daddy);
+ if (scm_is_false (tail))
+ return SCM_EOL;
+ }
+ else
+ {
+ tail = assq_tail (scm_car (grob_property_path), current_alist, daddy);
+ if (scm_is_false (tail))
+ return SCM_EOL;
+ ++props_->nested_;
+ }
+
+ SCM cell = scm_cons (SCM_BOOL_F, scm_car (tail));
+ props_->alist_ = partial_list_copy (current_alist, tail,
+ scm_cons (cell, scm_cdr (tail)));
+ return cell;
+}
+
+
+void
+Grob_property_info::matched_pop (SCM cell)
+{
+ if (!scm_is_pair (cell))
+ return;
+ if (!check ())
+ return;
+ SCM current_alist = props_->alist_;
+ SCM daddy = props_->based_on_;
+ for (SCM p = current_alist; !scm_is_eq (p, daddy); p = scm_cdr (p))
+ {
+ if (scm_is_eq (scm_car (p), cell))
+ {
+ SCM key = scm_car (cell);
+ if (scm_is_false (key))
+ {
+ // temporary revert, reactivate
+ cell = scm_cdr (cell);
+ if (scm_is_symbol (scm_car (cell)))
+ props_->nested_--;
+ props_->alist_ = partial_list_copy (current_alist, p,
+ scm_cons (cell, scm_cdr (p)));
+ return;
+ }
+ if (!scm_is_symbol (key))
+ props_->nested_--;
+ props_->alist_ = partial_list_copy (current_alist, p, scm_cdr (p));
+ return;
+ }
+ }
+ return;
}
/*
return;
}
- SCM symbol = scm_car (grob_property_path);
if (scm_is_pair (scm_cdr (grob_property_path)))
{
- // This is definitely wrong: the symbol must only be looked up
- // in the part of the alist before daddy. We are not fixing
- // this right now since this is slated for complete replacement.
- SCM current_sub_alist = ly_assoc_get (symbol, current_alist, SCM_EOL);
- SCM new_val
- = nested_property_revert_alist (current_sub_alist,
- scm_cdr (grob_property_path));
-
- if (scm_is_pair (current_alist)
- && scm_caar (current_alist) == symbol
- && current_alist != daddy)
- current_alist = scm_cdr (current_alist);
-
- current_alist = scm_acons (symbol, new_val, current_alist);
- props_->alist_ = current_alist;
+ SCM old_alist = current_alist;
+ current_alist = evict_from_alist (grob_property_path, current_alist, daddy);
+ if (scm_is_eq (old_alist, current_alist))
+ return;
+ props_->nested_--;
}
else
- {
- SCM new_alist = evict_from_alist (symbol, current_alist, daddy);
+ current_alist = evict_from_alist (scm_car (grob_property_path),
+ current_alist, daddy);
- if (new_alist == daddy)
- {
- props_ = 0;
- context_->unset_property (symbol_);
- }
- else
- props_->alist_ = new_alist;
+ if (scm_is_eq (current_alist, daddy))
+ {
+ assert (props_->nested_ == 0);
+ props_ = 0;
+ context_->unset_property (symbol_);
+ return;
}
+ props_->alist_ = current_alist;
}
/*
Convenience: a push/pop grob property using a single grob_property
SCM type = scm_car (entry);
entry = scm_cdr (entry);
- if (type == ly_symbol2scm ("push"))
+ if (scm_is_eq (type, ly_symbol2scm ("push")))
{
SCM context_prop = scm_car (entry);
SCM val = scm_cadr (entry);
SCM grob_prop_path = scm_cddr (entry);
Grob_property_info (tg, context_prop).push (grob_prop_path, val);
}
- else if (type == ly_symbol2scm ("pop"))
+ else if (scm_is_eq (type, ly_symbol2scm ("pop")))
{
SCM context_prop = scm_car (entry);
SCM grob_prop_path = scm_cdr (entry);
Grob_property_info (tg, context_prop).pop (grob_prop_path);
}
- else if (type == ly_symbol2scm ("assign"))
+ else if (scm_is_eq (type, ly_symbol2scm ("assign")))
tg->set_property (scm_car (entry), scm_cadr (entry));
- else if (type == ly_symbol2scm ("apply"))
- scm_apply_1 (scm_car (entry), tg->self_scm (), scm_cdr (entry));
- else if (type == ly_symbol2scm ("unset"))
+ else if (scm_is_eq (type, ly_symbol2scm ("apply")))
+ scm_apply_1 (scm_car (entry), tg->self_scm (), scm_cdr (entry));
+ else if (scm_is_eq (type, ly_symbol2scm ("unset")))
tg->unset_property (scm_car (entry));
}
}
= dad ? Grob_property_info (dad, symbol_).updated () : SCM_EOL;
SCM based_on = where.props_->based_on_;
- if (based_on == daddy_props)
- return where.props_->alist_;
- else
+ SCM alist = where.props_->alist_;
+ if (!scm_is_eq (based_on, daddy_props))
{
- SCM copy = daddy_props;
- SCM *tail = ©
- SCM p = where.props_->alist_;
- while (p != based_on)
- {
- *tail = scm_cons (scm_car (p), daddy_props);
- tail = SCM_CDRLOC (*tail);
- p = scm_cdr (p);
- }
-
- where.props_->alist_ = copy;
- where.props_->based_on_ = daddy_props;
-
- return copy;
+ where.props_->based_on_ = daddy_props;
+ alist = partial_list_copy (alist, based_on, daddy_props);
+ where.props_->alist_ = alist;
}
+ if (scm_is_eq (where.props_->cooked_from_, alist))
+ return where.props_->cooked_;
+ where.props_->cooked_from_ = alist;
+ where.props_->cooked_ = nalist_to_alist (alist, where.props_->nested_);
+ return where.props_->cooked_;
}