X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fprob.cc;h=d05a33e4f3aa60387ad40a612deaf01a6d952a54;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=4dbd2858ababb7b9921bf7ed3c6c0dea4ce4cff8;hpb=dbb4524af169a9c15e5c7fcfddfa1a4b85dd288d;p=lilypond.git diff --git a/lily/prob.cc b/lily/prob.cc index 4dbd2858ab..d05a33e4f3 100644 --- a/lily/prob.cc +++ b/lily/prob.cc @@ -1,26 +1,85 @@ /* - paper-system.cc -- implement Paper_system + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2004--2015 Jan Nieuwenhuizen - (c) 2004--2006 Jan Nieuwenhuizen + 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 "prob.hh" #include "main.hh" #include "item.hh" +#include "input.hh" +#include "profile.hh" -#include "ly-smobs.icc" -IMPLEMENT_SMOBS (Prob); -IMPLEMENT_TYPE_P (Prob, "ly:prob?"); -IMPLEMENT_DEFAULT_EQUAL_P (Prob); +const char * const Prob::type_p_name_ = "ly:prob?"; -Prob::Prob (SCM immutable_init) +SCM +Prob::equal_p (SCM sa, SCM sb) +{ + /* This comparison function is only designed to make the copy + constructor preserve equality. + + Perhaps it would be better to use a more strict definition of + equality; e.g., that two probs are equal iff they can be + distinguished by calls to ly:prob-property. + */ + Prob *probs[2] = {unsmob (sa), unsmob (sb)}; + SCM props[2][2]; + int i; + + for (i = 0; i < 2; i++) + { + props[i][0] = probs[i]->immutable_property_alist_; + props[i][1] = probs[i]->mutable_property_alist_; + } + + if (strcmp (probs[0]->class_name (), probs[1]->class_name ())) + return SCM_BOOL_F; + + /* Compare mutable and immutable lists, element by element. */ + for (i = 0; i < 2; i++) + { + SCM aprop = props[0][i]; + SCM bprop = props[1][i]; + + for (; + scm_is_pair (aprop) && scm_is_pair (bprop); + aprop = scm_cdr (aprop), bprop = scm_cdr (bprop)) + { + SCM aval = scm_cdar (aprop); + SCM bval = scm_cdar (bprop); + if (!scm_is_eq (scm_caar (aprop), scm_caar (bprop)) + || (!(unsmob (aval) && unsmob (bval)) + && !ly_is_equal (aval, bval))) + return SCM_BOOL_F; + } + + /* is one list shorter? */ + if (!scm_is_null (aprop) || !scm_is_null (bprop)) + return SCM_BOOL_F; + } + + return SCM_BOOL_T; +} + +Prob::Prob (SCM type, SCM immutable_init) : Smob () { - self_scm_ = SCM_EOL; mutable_property_alist_ = SCM_EOL; immutable_property_alist_ = immutable_init; + type_ = type; smobify_self (); } @@ -29,10 +88,11 @@ Prob::~Prob () } Prob::Prob (Prob const &src) + : Smob () { immutable_property_alist_ = src.immutable_property_alist_; mutable_property_alist_ = SCM_EOL; - self_scm_ = SCM_EOL; + type_ = src.type_; /* First we smobify_self, then we copy over the stuff. If we don't, stack vars that hold the copy might be optimized away, meaning @@ -41,7 +101,6 @@ Prob::Prob (Prob const &src) mutable_property_alist_ = src.copy_mutable_properties (); } - SCM Prob::copy_mutable_properties () const { @@ -54,61 +113,70 @@ Prob::derived_mark () const } SCM -Prob::mark_smob (SCM smob) +Prob::mark_smob () const { - Prob *system = (Prob *) SCM_CELL_WORD_1 (smob); - scm_gc_mark (system->mutable_property_alist_); - system->derived_mark (); - - return system->immutable_property_alist_; + ASSERT_LIVE_IS_ALLOWED (self_scm ()); + + scm_gc_mark (mutable_property_alist_); + derived_mark (); + + return immutable_property_alist_; } int -Prob::print_smob (SCM smob, SCM port, scm_print_state*) +Prob::print_smob (SCM port, scm_print_state *) const { - Prob *p = (Prob *) SCM_CELL_WORD_1 (smob); scm_puts ("#<", port); scm_puts ("Prob: ", port); + scm_display (type_, port); + scm_puts (" C++: ", port); + scm_puts (class_name (), port); + scm_display (mutable_property_alist_, port); + scm_display (immutable_property_alist_, port); - - scm_puts (p->class_name (), port); - scm_display (p->mutable_property_alist_, port); - scm_display (p->immutable_property_alist_, port); - scm_puts (" >\n", port); return 1; } - - SCM Prob::internal_get_property (SCM sym) const { +#ifdef DEBUG + if (profile_property_accesses) + note_property_access (&prob_property_lookup_table, sym); +#endif + /* TODO: type checking */ SCM s = scm_sloppy_assq (sym, mutable_property_alist_); - if (s != SCM_BOOL_F) + if (scm_is_true (s)) return scm_cdr (s); s = scm_sloppy_assq (sym, immutable_property_alist_); - return (s == SCM_BOOL_F) ? SCM_EOL : scm_cdr (s); + return scm_is_false (s) ? SCM_EOL : scm_cdr (s); } +/* We don't (yet) instrument probs */ void -Prob::internal_set_property (SCM sym, SCM val) +Prob::instrumented_set_property (SCM sym, SCM val, const char *, int, const char *) +{ + internal_set_property (sym, val); +} + +void +Prob::internal_set_property (SCM sym, SCM val) { if (do_internal_type_checking_global) type_check_assignment (sym, val); - + mutable_property_alist_ = scm_assq_set_x (mutable_property_alist_, sym, val); } void -Prob::type_check_assignment (SCM sym, SCM val) const +Prob::type_check_assignment (SCM, SCM) const { - (void) sym; - (void) val; + /* empty */ } SCM @@ -117,13 +185,12 @@ Prob::get_property_alist (bool m) const return (m) ? mutable_property_alist_ : immutable_property_alist_; } -String +string Prob::name () const { SCM nm = get_property ("name"); if (scm_is_symbol (nm)) return ly_symbol2string (nm); else - return this->class_name (); + return class_name (); } -