*/
for (vsize i = 0; i < left_objects_.size (); i++)
{
- if (left_objects_[i]->get_property ("side-axis") == scm_from_int (X_AXIS))
+ if (scm_is_eq (left_objects_[i]->get_property ("side-axis"), scm_from_int (X_AXIS)))
Side_position_interface::add_support (left_objects_[i], a);
}
Accidental_placement::add_accidental
(accidental_placement_, a,
- get_property ("accidentalGrouping") == ly_symbol2scm ("voice"),
+ scm_is_eq (get_property ("accidentalGrouping"), ly_symbol2scm ("voice")),
(long) trans);
note_head->set_object ("accidental-grob", a->self_scm ());
|| note->in_event_class ("trill-span-event"))
// option to skip accidentals on string harmonics
&& (to_boolean (get_property ("harmonicAccidentals"))
- || info.grob ()->get_property ("style") != ly_symbol2scm ("harmonic"))
+ || !scm_is_eq (info.grob ()->get_property ("style"),
+ ly_symbol2scm ("harmonic")))
// ignore accidentals in non-printing voices like NullVoice
&& !to_boolean (info.context ()->get_property ("nullAccidentals")))
{
SCM key = scm_cons (scm_from_int (n), scm_from_long (stagger ? context_hash : 1));
// assoc because we're dealing with pairs
SCM entry = scm_assoc (key, accs);
- if (entry == SCM_BOOL_F)
+ if (scm_is_false (entry))
entry = SCM_EOL;
else
entry = scm_cdr (entry);
for (vsize i = ret.size (); i--;)
if (Grob *s = Rhythmic_head::get_stem (ret[i]))
ret.push_back (s);
-
+
uniquify (ret);
return ret;
}
SCM fv = ly_assoc_get (scm_cons (scm_from_int (start), scm_from_int (end)),
me->get_property ("minimum-translations-alist"),
SCM_EOL);
- if (fv != SCM_EOL)
+ if (!scm_is_null (fv))
return ly_scm2floatvector (fv);
}
scm_from_int (p.get_notename ())),
start_key_sig_);
- if (handle == SCM_BOOL_F)
+ if (scm_is_false (handle))
handle = scm_assoc (scm_from_int (p.get_notename ()),
start_key_sig_);
- Rational sig_alter = (handle != SCM_BOOL_F)
+ Rational sig_alter = (scm_is_true (handle))
? robust_scm2rational (scm_cdr (handle), Rational (0))
: Rational (0);
bool
Auto_beam_engraver::test_moment (Direction dir, Moment test_mom, Moment dur)
{
- return scm_call_4 (get_property ("autoBeamCheck"),
- context ()->self_scm (),
- scm_from_int (dir),
- test_mom.smobbed_copy (),
- dur.smobbed_copy ())
- != SCM_BOOL_F;
+ return scm_is_true (scm_call_4 (get_property ("autoBeamCheck"),
+ context ()->self_scm (),
+ scm_from_int (dir),
+ test_mom.smobbed_copy (),
+ dur.smobbed_copy ()));
}
void
durlog - 2,
Stem::is_invisible (stem),
stem_duration->factor (),
- (stem->get_property ("tuplet-start") == SCM_BOOL_T));
+ (to_boolean (stem->get_property ("tuplet-start"))));
stems_->push_back (stem);
last_add_mom_ = now;
extend_mom_ = max (extend_mom_, now) + get_event_length (ev, now);
{
SCM directive = me->get_property ("outside-staff-placement-directive");
- if ((directive == ly_symbol2scm ("left-to-right-greedy"))
- || (directive == ly_symbol2scm ("left-to-right-polite"))
- || (directive == ly_symbol2scm ("right-to-left-greedy"))
- || (directive == ly_symbol2scm ("right-to-left-polite")))
+ if (scm_is_eq (directive, ly_symbol2scm ("left-to-right-greedy"))
+ || scm_is_eq (directive, ly_symbol2scm ("left-to-right-polite"))
+ || scm_is_eq (directive, ly_symbol2scm ("right-to-left-greedy"))
+ || scm_is_eq (directive, ly_symbol2scm ("right-to-left-polite")))
return directive;
me->warning (_f ("\"%s\" is not a valid outside-staff-placement-directive",
SCM directive
= valid_outside_staff_placement_directive (me);
- bool l2r = ((directive == ly_symbol2scm ("left-to-right-greedy"))
- || (directive == ly_symbol2scm ("left-to-right-polite")));
+ bool l2r = (scm_is_eq (directive, ly_symbol2scm ("left-to-right-greedy"))
+ || scm_is_eq (directive, ly_symbol2scm ("left-to-right-polite")));
- bool polite = ((directive == ly_symbol2scm ("left-to-right-polite"))
- || (directive == ly_symbol2scm ("right-to-left-polite")));
+ bool polite = (scm_is_eq (directive, ly_symbol2scm ("left-to-right-polite"))
+ || scm_is_eq (directive, ly_symbol2scm ("right-to-left-polite")));
vector<Box> boxes;
vector<Skyline_pair> skylines_to_merge;
{
bar_ = make_item ("BarLine", SCM_EOL);
SCM gl = get_property ("whichBar");
- if (scm_equal_p (gl, bar_->get_property ("glyph")) != SCM_BOOL_T)
+ if (!ly_is_equal (gl, bar_->get_property ("glyph")))
bar_->set_property ("glyph", gl);
}
}
alternative_event_ = ev;
int current_barnumber = robust_scm2int (get_property ("currentBarNumber"), 0);
Direction alternative_dir = robust_scm2dir (ev->get_property ("alternative-dir"), CENTER);
- bool make_alternative = get_property ("alternativeNumberingStyle") == ly_symbol2scm ("numbers")
- || get_property ("alternativeNumberingStyle") == ly_symbol2scm ("numbers-with-letters");
+ bool make_alternative = scm_is_eq (get_property ("alternativeNumberingStyle"),
+ ly_symbol2scm ("numbers"))
+ || scm_is_eq (get_property ("alternativeNumberingStyle"),
+ ly_symbol2scm ("numbers-with-letters"));
if (make_alternative)
{
/*
create_items ();
SCM alternative_style = get_property ("alternativeNumberingStyle");
string text_tag = "";
- if (alternative_style == ly_symbol2scm ("numbers-with-letters"))
+ if (scm_is_eq (alternative_style, ly_symbol2scm ("numbers-with-letters")))
{
if (alternative_event_)
{
max (durlog - 2, 0),
Stem::is_invisible (stem),
stem_duration->factor (),
- (stem->get_property ("tuplet-start") == SCM_BOOL_T));
+ (to_boolean (stem->get_property ("tuplet-start"))));
Beam::add_stem (beam_, stem);
}
placing this here avoids warnings downstream */
if (heads.size())
{
- if (heads[0]->get_property ("style") == ly_symbol2scm ("kievan"))
+ if (scm_is_eq (heads[0]->get_property ("style"),
+ ly_symbol2scm ("kievan")))
{
if (dir == CENTER)
dir = DOWN;
for (SCM s = scm_car (right_beaming); scm_is_pair (s); s = scm_cdr (s))
{
int k = -right_dir * scm_to_int (scm_car (s)) + i;
- if (scm_c_memq (scm_from_int (k), left_beaming) != SCM_BOOL_F)
+ if (scm_is_true (scm_c_memq (scm_from_int (k), left_beaming)))
count++;
}
int beam_count = get_beam_count (me);
SCM shorten_list = me->get_property ("beamed-stem-shorten");
- if (shorten_list == SCM_EOL)
+ if (scm_is_null (shorten_list))
return scm_from_int (0);
Real staff_space = Staff_symbol_referencer::staff_space (me);
for (SCM s = scm_car (beaming); scm_is_pair (s); s = scm_cdr (s))
{
- if (scm_c_memq (scm_car (s), scm_cdr (beaming)) != SCM_BOOL_F)
+ if (scm_is_true (scm_c_memq (scm_car (s), scm_cdr (beaming))))
l.add_point (scm_to_int (scm_car (s)));
}
{
Grob *stem = stems[i];
SCM beaming_prop = stem->get_property ("beaming");
- if (beaming_prop == SCM_EOL
- || index_get_cell (beaming_prop, d) == SCM_EOL)
+ if (scm_is_null (beaming_prop)
+ || scm_is_null (index_get_cell (beaming_prop, d)))
{
int count = beaming->beamlet_count (i, d);
if (i > 0
SCM s = scm_assoc (align_name, column_alist_);
Item *group = 0;
- if (s != SCM_BOOL_F)
+ if (scm_is_true (s))
{
Grob *e = Grob::unsmob (scm_cdr (s));
group = dynamic_cast<Item *> (e);
SCM order = break_align_order (me);
- if (order == SCM_BOOL_F)
+ if (scm_is_false (order))
return elts;
vector<Grob *> writable_elts (elts);
Grob *elt = elts[i];
if (edge_idx == VPOS
- && (elt->get_property ("break-align-symbol")
- == ly_symbol2scm ("left-edge")))
+ && scm_is_eq (elt->get_property ("break-align-symbol"),
+ ly_symbol2scm ("left-edge")))
edge_idx = idx;
SCM l = elt->get_property ("space-alist");
}
}
- if (rsym == ly_symbol2scm ("left-edge"))
+ if (scm_is_eq (rsym, ly_symbol2scm ("left-edge")))
edge_idx = next_idx;
SCM entry = SCM_EOL;
if (r)
{
- if (type == ly_symbol2scm ("extra-space"))
+ if (scm_is_eq (type, ly_symbol2scm ("extra-space")))
offsets[next_idx] = extents[idx][RIGHT] + distance
- extents[next_idx][LEFT];
/* should probably junk minimum-space */
- else if (type == ly_symbol2scm ("minimum-space"))
+ else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
offsets[next_idx] = max (extents[idx][RIGHT], distance);
}
else
SCM newcar = do_break_substitution (scm_car (src));
SCM oldcdr = scm_cdr (src);
- if (newcar == SCM_UNDEFINED
- && (scm_is_pair (oldcdr) || oldcdr == SCM_EOL))
+ if (SCM_UNBNDP (newcar)
+ && (scm_is_pair (oldcdr) || scm_is_null (oldcdr)))
{
/*
This is tail-recursion, ie.
else
val = do_break_substitution (val);
- if (val != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (val))
{
/*
for ly:grob? properties, SCM_UNDEFINED could leak out
if (!Pitch::is_smob (p))
continue;
- if (n->get_property ("bass") == SCM_BOOL_T)
+ if (to_boolean (n->get_property ("bass")))
bass = p;
else
{
}
else
pitches = scm_cons (p, pitches);
- if (n->get_property ("inversion") == SCM_BOOL_T)
+ if (to_boolean (n->get_property ("inversion")))
{
inversion = p;
if (!scm_is_number (oct))
SCM transposition = get_property ("clefTransposition");
SCM force_clef = get_property ("forceClef");
- if (clefpos == SCM_EOL
- || scm_equal_p (glyph, prev_glyph_) == SCM_BOOL_F
- || scm_equal_p (clefpos, prev_cpos_) == SCM_BOOL_F
- || scm_equal_p (transposition, prev_transposition_) == SCM_BOOL_F
+ if (scm_is_null (clefpos)
+ || !ly_is_equal (glyph, prev_glyph_)
+ || !ly_is_equal (clefpos, prev_cpos_)
+ || !ly_is_equal (transposition, prev_transposition_)
|| to_boolean (force_clef))
{
apply_on_children (context (),
ly_lily_module_constant ("invalidate-alterations"));
set_glyph ();
- if (prev_cpos_ != SCM_BOOL_F || to_boolean (get_property ("firstClef")))
+ if (scm_is_true (prev_cpos_) || to_boolean (get_property ("firstClef")))
create_clef ();
if (clef_)
static SCM
min_permission (SCM perm1, SCM perm2)
{
- if (perm1 == ly_symbol2scm ("force"))
+ if (scm_is_eq (perm1, ly_symbol2scm ("force")))
return perm2;
- if (perm1 == ly_symbol2scm ("allow")
- && perm2 != ly_symbol2scm ("force"))
+ if (scm_is_eq (perm1, ly_symbol2scm ("allow"))
+ && !scm_is_eq (perm2, ly_symbol2scm ("force")))
return perm2;
return SCM_EOL;
}
Context_def::add_context_mod (SCM mod)
{
SCM tag = scm_car (mod);
- if (ly_symbol2scm ("description") == tag)
+ if (scm_is_eq (tag, ly_symbol2scm ("description")))
{
description_ = scm_cadr (mod);
return;
if (scm_is_string (sym))
sym = scm_string_to_symbol (sym);
- if (ly_symbol2scm ("default-child") == tag)
+ if (scm_is_eq (tag, ly_symbol2scm ("default-child")))
default_child_ = sym;
- else if (ly_symbol2scm ("consists") == tag
- || ly_symbol2scm ("remove") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("consists"))
+ || scm_is_eq (tag, ly_symbol2scm ("remove")))
{
translator_mods_ = scm_cons (scm_list_2 (tag, sym), translator_mods_);
}
- else if (ly_symbol2scm ("accepts") == tag
- || ly_symbol2scm ("denies") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("accepts"))
+ || scm_is_eq (tag, ly_symbol2scm ("denies")))
accept_mods_ = scm_cons (scm_list_2 (tag, sym), accept_mods_);
- else if (ly_symbol2scm ("pop") == tag
- || ly_symbol2scm ("push") == tag
- || ly_symbol2scm ("assign") == tag
- || ly_symbol2scm ("unset") == tag
- || ly_symbol2scm ("apply") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("pop"))
+ || scm_is_eq (tag, ly_symbol2scm ("push"))
+ || scm_is_eq (tag, ly_symbol2scm ("assign"))
+ || scm_is_eq (tag, ly_symbol2scm ("unset"))
+ || scm_is_eq (tag, ly_symbol2scm ("apply")))
property_ops_ = scm_cons (mod, property_ops_);
- else if (ly_symbol2scm ("alias") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("alias")))
context_aliases_ = scm_cons (sym, context_aliases_);
- else if (ly_symbol2scm ("translator-type") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("translator-type")))
translator_group_type_ = sym;
- else if (ly_symbol2scm ("context-name") == tag)
+ else if (scm_is_eq (tag, ly_symbol2scm ("context-name")))
context_name_ = sym;
else
programming_error ("unknown context mod tag");
{
SCM tag = scm_caar (s);
SCM sym = scm_cadar (s);
- if (tag == ly_symbol2scm ("accepts"))
+ if (scm_is_eq (tag, ly_symbol2scm ("accepts")))
acc = scm_cons (sym, acc);
- else if (tag == ly_symbol2scm ("denies"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("denies")))
acc = scm_delete_x (sym, acc);
}
for (SCM s = user_mod; scm_is_pair (s); s = scm_cdr (s))
{
SCM entry = scm_car (s);
- if (scm_car (entry) == ly_symbol2scm ("default-child"))
+ if (scm_is_eq (scm_car (entry), ly_symbol2scm ("default-child")))
{
name = scm_cadr (entry);
break;
if (scm_is_string (arg))
arg = scm_string_to_symbol (arg);
- if (ly_symbol2scm ("consists") == tag)
+ if (scm_is_eq (tag, ly_symbol2scm ("consists")))
l1 = scm_cons (arg, l1);
- else if (ly_symbol2scm ("remove") == tag
+ else if (scm_is_eq (tag, ly_symbol2scm ("remove"))
&& (scm_is_pair (arg)
|| ly_is_procedure (arg)
|| get_translator (arg)))
"Creates a context modification, optionally initialized"
" via the list of modifications @var{mod-list}.")
{
- if (mod_list != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (mod_list))
{
LY_ASSERT_TYPE (ly_cheap_is_list, mod_list, 1);
return Context_mod (mod_list).smobbed_copy ();
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"))
+ else if (scm_is_eq (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 ("unset")))
tg->unset_property (scm_car (entry));
}
}
Context *t = Context::unsmob (context);
SCM result = t->get_property (sym);
- return def != SCM_UNDEFINED && scm_is_null (result) ? def : result;
+ return !SCM_UNBNDP (def) && scm_is_null (result) ? def : result;
}
LY_DEFINE (ly_context_set_property_x, "ly:context-set-property!",
bool
Context::is_removable () const
{
- return context_list_ == SCM_EOL && ! client_count_
+ return scm_is_null (context_list_) && ! client_count_
&& !dynamic_cast<Global_context const *> (daddy_context_);
}
if (Context *existing = find_context_below (this, n, id))
return existing;
- if (n == ly_symbol2scm ("Bottom"))
+ if (scm_is_eq (n, ly_symbol2scm ("Bottom")))
{
Context *tg = get_default_interpreter (id);
return tg;
unset_property (sym);
return;
}
-
+
bool ok = true;
ok = type_check_assignment (sym, val, ly_symbol2scm ("translation-type?"));
// but the Context_def expects to see elements of the form ('accepts symbol).
SCM accepts = SCM_EOL;
for (SCM s = definition_mods_; scm_is_pair (s); s = scm_cdr (s))
- if (scm_caar (s) == ly_symbol2scm ("accepts"))
+ if (scm_is_eq (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);
if (scm_is_eq (sym, context_name_symbol ()))
return true;
- return scm_c_memq (sym, aliases_) != SCM_BOOL_F;
+ return scm_is_true (scm_c_memq (sym, aliases_));
}
void
SCM clefpos = get_property ("cueClefPosition");
SCM transposition = get_property ("cueClefTransposition");
- if (scm_equal_p (glyph, prev_glyph_) == SCM_BOOL_F
- || scm_equal_p (clefpos, prev_cpos_) == SCM_BOOL_F
- || scm_equal_p (transposition, prev_transposition_) == SCM_BOOL_F)
+ if (!ly_is_equal (glyph, prev_glyph_)
+ || !ly_is_equal (clefpos, prev_cpos_)
+ || !ly_is_equal (transposition, prev_transposition_))
{
set_glyph ();
if (scm_is_string (glyph))
get_grob_direction (Grob *me)
{
SCM d = me->get_property ("direction");
- if (d == ly_symbol2scm ("calculation-in-progress"))
+ if (scm_is_eq (d, ly_symbol2scm ("calculation-in-progress")))
{
programming_error ("Grob direction requested while calculation in"
" progress.");
{
SCM list = scm_hashq_ref (listeners_, ev_class, SCM_EOL);
- if (list == SCM_EOL)
+ if (scm_is_null (list))
{
programming_error ("remove_listener called with incorrect class.");
return;
int priority = ++disp->priority_count_;
// Don't register twice to the same dispatcher.
- if (scm_assq (disp->self_scm (), dispatchers_) != SCM_BOOL_F)
+ if (scm_is_true (scm_assq (disp->self_scm (), dispatchers_)))
{
warning (_ ("Already listening to dispatcher, ignoring request"));
return;
cfg.remove_collision (p);
cfg[p] = dp;
- if (Staff_symbol_referencer::on_line (dp.dot_, p) &&
- dp.dot_->get_property ("style") != ly_symbol2scm ("kievan"))
+ if (Staff_symbol_referencer::on_line (dp.dot_, p)
+ && !scm_is_eq (dp.dot_->get_property ("style"),
+ ly_symbol2scm ("kievan")))
cfg.remove_collision (p);
}
percent_event_->self_scm ());
SCM count = percent_event_->get_property ("repeat-count");
- if (count != SCM_EOL && to_boolean (get_property ("countPercentRepeats"))
+ if (!scm_is_null (count) && to_boolean (get_property ("countPercentRepeats"))
&& check_repeat_count_visibility (context (), count))
{
Item *double_percent_counter
SCM defn = SCM_EOL;
- if (scm_hash_table_p (tab) == SCM_BOOL_T)
+ if (to_boolean (scm_hash_table_p (tab)))
defn = scm_hashq_ref (tab, drum_type, SCM_EOL);
if (scm_is_pair (defn))
SCM style = scm_car (defn);
SCM script = scm_cadr (defn);
- if (scm_integer_p (pos) == SCM_BOOL_T)
+ if (scm_is_integer (pos))
note->set_property ("staff-position", pos);
if (scm_is_symbol (style))
note->set_property ("style", style);
SCM defn = SCM_EOL;
if (scm_is_symbol (sym)
- && (scm_hash_table_p (tab) == SCM_BOOL_T))
+ && to_boolean (scm_hash_table_p (tab)))
defn = scm_hashq_ref (tab, sym, SCM_EOL);
if (Pitch *pit = Pitch::unsmob (defn))
LY_ASSERT_TYPE (scm_is_integer, length, 1);
int dots = 0;
- if (dotcount != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (dotcount))
{
LY_ASSERT_TYPE (scm_is_integer, dotcount, 2);
dots = scm_to_int (dotcount);
char const *ctxprop)
{
SCM spanner_type = evt->get_property (evprop);
- if (spanner_type == SCM_EOL)
+ if (scm_is_null (spanner_type))
spanner_type = get_property (ctxprop);
return spanner_type;
}
SCM cresc_type = get_property_setting (current_span_event_, "span-type",
(start_type + "Spanner").c_str ());
- if (cresc_type == ly_symbol2scm ("text"))
+ if (scm_is_eq (cresc_type, ly_symbol2scm ("text")))
{
current_spanner_
= make_spanner ("DynamicTextSpanner",
early: this allows dynamics to be spaced individually instead of
being linked together.
*/
- if (current_spanner_->get_property ("style") == ly_symbol2scm ("none"))
+ if (scm_is_eq (current_spanner_->get_property ("style"),
+ ly_symbol2scm ("none")))
current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
}
else
{
- if (cresc_type != ly_symbol2scm ("hairpin"))
+ if (!scm_is_eq (cresc_type, ly_symbol2scm ("hairpin")))
{
string as_string = ly_scm_write_string (cresc_type);
current_span_event_
string type;
SCM start_sym = scm_car (ev->get_property ("class"));
- if (start_sym == ly_symbol2scm ("decrescendo-event"))
+ if (scm_is_eq (start_sym, ly_symbol2scm ("decrescendo-event")))
type = "decrescendo";
- else if (start_sym == ly_symbol2scm ("crescendo-event"))
+ else if (scm_is_eq (start_sym, ly_symbol2scm ("crescendo-event")))
type = "crescendo";
else
programming_error ("unknown dynamic spanner type");
Engraver_dispatch_list *dispatch
= Engraver_dispatch_list::unsmob (acklist);
- if (acklist == SCM_BOOL_F)
+ if (scm_is_false (acklist))
{
SCM ifaces
= scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta));
{
cause = m->to_event ()->unprotect ();
}
- if (e->get_property ("cause") == SCM_EOL
+ if (scm_is_null (e->get_property ("cause"))
&& (Stream_event::is_smob (cause) || Grob::is_smob (cause)))
e->set_property ("cause", cause);
SCM handle = scm_sloppy_assq (ly_symbol2scm ("meta"), props);
SCM klass = scm_cdr (scm_sloppy_assq (ly_symbol2scm ("class"), scm_cdr (handle)));
- if (klass == ly_symbol2scm ("Item"))
+ if (scm_is_eq (klass, ly_symbol2scm ("Item")))
grob = new Item (props);
- else if (klass == ly_symbol2scm ("Spanner"))
+ else if (scm_is_eq (klass, ly_symbol2scm ("Spanner")))
grob = new Spanner (props);
- else if (klass == ly_symbol2scm ("Paper_column"))
+ else if (scm_is_eq (klass, ly_symbol2scm ("Paper_column")))
grob = new Paper_column (props);
assert (grob);
bool
ly_is_grob_cause (SCM obj)
{
- return Grob::is_smob (obj) || Stream_event::is_smob (obj) || (obj == SCM_EOL);
+ return Grob::is_smob (obj) || Stream_event::is_smob (obj) || scm_is_null (obj);
}
#include "translator.icc"
Align_interface::add_element (alignment_, group.group_);
}
- if (scm_memq (group.number_, get_property ("implicitBassFigures")) != SCM_BOOL_F)
+ if (scm_is_true (scm_memq (group.number_, get_property ("implicitBassFigures"))))
{
item->set_property ("transparent", SCM_BOOL_T);
item->set_property ("implicit", SCM_BOOL_T);
{
SCM defaults
= g->layout ()->lookup_variable (ly_symbol2scm ("font-defaults"));
- if (defaults == SCM_UNDEFINED)
+ if (SCM_UNBNDP (defaults))
defaults = SCM_EOL;
return g->get_property_alist_chain (defaults);
}
{
SCM defaults
= g->layout ()->lookup_variable (ly_symbol2scm ("text-font-defaults"));
- if (defaults == SCM_UNDEFINED)
+ if (SCM_UNBNDP (defaults))
defaults = SCM_EOL;
return g->get_property_alist_chain (defaults);
}
{
SCM entry = scm_c_vector_ref (font_vector, i);
- if (scm_promise_p (entry) == SCM_BOOL_T)
+ if (to_boolean (scm_promise_p (entry)))
{
Font_metric *fm = Font_metric::unsmob (scm_force (entry));
size = fm->design_size ();
{
LY_ASSERT_TYPE (scm_is_string, name, 1);
int sz = INT_MAX;
- if (size != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (size))
{
LY_ASSERT_TYPE (scm_is_number, size, 2);
sz = scm_to_int (size);
if (scm_is_pair (handle))
return scm_cdr (handle);
- if (default_value == SCM_UNDEFINED)
+ if (SCM_UNBNDP (default_value))
default_value = SCM_BOOL_F;
- if (strict_checking == SCM_BOOL_T)
+ if (to_boolean (strict_checking))
{
string key_string = ly_scm2string
(scm_object_to_string (key, SCM_UNDEFINED));
char str[400]; // ugh.
- if (scm_exact_p (s) == SCM_BOOL_F)
+ if (scm_is_false (scm_exact_p (s)))
{
Real r (scm_to_double (s));
if (isinf (r) || isnan (r))
return ly_chain_assoc_get (key, scm_cdr (achain), default_value);
}
- if (strict_checking == SCM_BOOL_T)
+ if (to_boolean (strict_checking))
{
string key_string = ly_scm2string
(scm_object_to_string (key, SCM_UNDEFINED));
+ default_value_string + "'.");
}
- return default_value == SCM_UNDEFINED ? SCM_BOOL_F : default_value;
+ return SCM_UNBNDP (default_value) ? SCM_BOOL_F : default_value;
}
LY_DEFINE (ly_stderr_redirect, "ly:stderr-redirect",
string
format_single_argument (SCM arg, int precision, bool escape = false)
{
- if (scm_is_integer (arg) && scm_exact_p (arg) == SCM_BOOL_T)
+ if (scm_is_integer (arg) && scm_is_true (scm_exact_p (arg)))
return (String_convert::int_string (scm_to_int (arg)));
else if (scm_is_number (arg))
{
for (; scm_is_pair (s); s = scm_cdr (s))
{
results.push_back (format_single_argument (scm_car (s), precision));
- if (scm_cdr (s) != SCM_EOL)
+ if (!scm_is_null (scm_cdr (s)))
results.push_back (" ");
}
- if (s != SCM_EOL)
+ if (!scm_is_null (s))
results.push_back (format_single_argument (s, precision));
}
{
extract_grob_set (g, "note-heads", note_heads);
SCM map = get_property ("glissandoMap");
- if (map == SCM_EOL)
+ if (scm_is_null (map))
for (vsize i = 0; i < note_heads.size (); i++)
{
note_column_1.push_back (i);
void
check_interfaces_for_property (Grob const *me, SCM sym)
{
- if (sym == ly_symbol2scm ("meta"))
+ if (scm_is_eq (sym, ly_symbol2scm ("meta")))
{
/*
otherwise we get in a nasty recursion loop.
for (; !found && scm_is_pair (ifs); ifs = scm_cdr (ifs))
{
SCM iface = scm_hashq_ref (all_ifaces, scm_car (ifs), SCM_BOOL_F);
- if (iface == SCM_BOOL_F)
+ if (scm_is_false (iface))
{
string msg = to_string (_f ("Unknown interface `%s'",
ly_symbol2string (scm_car (ifs)).c_str ()));
continue;
}
- found = found || (scm_c_memq (sym, scm_caddr (iface)) != SCM_BOOL_F);
+ found = found || scm_is_true (scm_c_memq (sym, scm_caddr (iface)));
}
if (!found)
if (!ly_is_procedure (v)
&& !Simple_closure::is_smob (v)
&& !Unpure_pure_container::is_smob (v)
- && v != ly_symbol2scm ("calculation-in-progress"))
+ && !scm_is_eq (v, ly_symbol2scm ("calculation-in-progress")))
type_check_assignment (sym, v, ly_symbol2scm ("backend-type?"));
check_interfaces_for_property (this, sym);
#endif
SCM handle = scm_sloppy_assq (sym, mutable_property_alist_);
- if (handle != SCM_BOOL_F)
+ if (scm_is_true (handle))
return scm_cdr (handle);
handle = scm_sloppy_assq (sym, immutable_property_alist_);
check_interfaces_for_property (this, sym);
}
- return (handle == SCM_BOOL_F) ? SCM_EOL : scm_cdr (handle);
+ return scm_is_false (handle) ? SCM_EOL : scm_cdr (handle);
}
SCM
SCM val = get_property_data (sym);
#ifndef NDEBUG
- if (val == ly_symbol2scm ("calculation-in-progress"))
+ if (scm_is_eq (val, ly_symbol2scm ("calculation-in-progress")))
{
programming_error (to_string ("cyclic dependency: calculation-in-progress encountered for #'%s (%s)",
ly_symbol2string (sym).c_str (),
grob_property_callback_stack = scm_cdr (grob_property_callback_stack);
#endif
- if (value == SCM_UNSPECIFIED)
+ if (scm_is_eq (value, SCM_UNSPECIFIED))
{
value = get_property_data (sym);
- assert (value == SCM_EOL || value == marker);
- if (value == marker)
+ assert (scm_is_null (value) || scm_is_eq (value, marker));
+ if (scm_is_eq (value, marker))
*alist = scm_assq_remove_x (*alist, sym);
}
else
SCM s = scm_sloppy_assq (sym, object_alist_);
- if (s != SCM_BOOL_F)
+ if (scm_is_true (s))
{
SCM val = scm_cdr (s);
if (ly_is_procedure (val)
bool
Grob::internal_has_interface (SCM k)
{
- return scm_c_memq (k, interfaces_) != SCM_BOOL_F;
+ return scm_is_true (scm_c_memq (k, interfaces_));
}
SCM
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
LY_ASSERT_TYPE (scm_is_integer, beg, 3);
LY_ASSERT_TYPE (scm_is_integer, end, 4);
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_EOL;
SCM retval = sc->internal_get_pure_property (sym, scm_to_int (beg), scm_to_int (end));
- if (retval == SCM_EOL)
+ if (scm_is_null (retval))
retval = val;
return retval;
LY_ASSERT_SMOB (Grob, refp, 2);
LY_ASSERT_TYPE (scm_is_integer, beg, 3);
LY_ASSERT_TYPE (scm_is_integer, end, 4);
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_EOL;
Interval retval = sc->pure_height (ref, scm_to_int (beg), scm_to_int (end));
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_EOL;
SCM retval = sc->get_property (sym);
- if (retval == SCM_EOL)
+ if (scm_is_null (retval))
retval = val;
return retval;
LY_ASSERT_SMOB (Grob, grob, 1);
- if (global == SCM_UNDEFINED)
+ if (SCM_UNBNDP (global))
{
global = sc->layout ()->lookup_variable (ly_symbol2scm ("font-defaults"));
- if (global == SCM_UNDEFINED)
+ if (SCM_UNBNDP (global))
global = SCM_EOL;
}
}
}
- if (get_property_data ("X-extent") == SCM_EOL)
+ if (scm_is_null (get_property_data ("X-extent")))
set_property ("X-extent", Grob::stencil_width_proc);
- if (get_property_data ("Y-extent") == SCM_EOL)
+ if (scm_is_null (get_property_data ("Y-extent")))
set_property ("Y-extent",
Unpure_pure_container::make_smob (Grob::stencil_height_proc,
Grob::pure_stencil_height_proc));
- if (get_property_data ("vertical-skylines") == SCM_EOL)
+ if (scm_is_null (get_property_data ("vertical-skylines")))
set_property ("vertical-skylines",
Unpure_pure_container::make_smob (Grob::simple_vertical_skylines_from_extents_proc,
Grob::pure_simple_vertical_skylines_from_extents_proc));
- if (get_property_data ("horizontal-skylines") == SCM_EOL)
+ if (scm_is_null (get_property_data ("horizontal-skylines")))
set_property ("horizontal-skylines",
Unpure_pure_container::make_smob (Grob::simple_horizontal_skylines_from_extents_proc,
Grob::pure_simple_horizontal_skylines_from_extents_proc));
SCM value = cached; \
if (__builtin_constant_p ((x))) \
{ \
- if (!cached) \
+ if (!SCM_UNPACK (cached)) \
value = cached = scm_gc_protect_object (scm_or_str2symbol (x)); \
} \
else \
SCM value = cached; \
if (__builtin_constant_p ((x))) \
{ \
- if (!cached) \
+ if (!SCM_UNPACK (cached)) \
value = cached = \
scm_variable_ref (scm_c_module_lookup (global_lily_module, (x))); \
} \
SCM ly_assoc_prepend_x (SCM alist, SCM key, SCM val);
inline bool ly_is_list (SCM x) { return scm_is_true (scm_list_p (x)); }
-inline bool ly_cheap_is_list (SCM x) { return scm_is_pair (x) || x == SCM_EOL; }
+inline bool ly_cheap_is_list (SCM x) { return scm_is_pair (x) || scm_is_null (x); }
inline bool ly_is_procedure (SCM x) { return scm_is_true (scm_procedure_p (x)); }
inline bool ly_is_port (SCM x) { return scm_is_true (scm_port_p (x)); }
if ((Text_interface::is_markup (long_text)
|| Text_interface::is_markup (short_text))
&& (!text_spanner_
- || short_text_ != short_text
- || long_text_ != long_text))
+ || !scm_is_eq (short_text_, short_text)
+ || !scm_is_eq (long_text_, long_text)))
{
if (text_spanner_)
stop_spanner ();
SCM key = get_property ("keyAlterations");
if ((to_boolean (get_property ("printKeyCancellation"))
- || key == SCM_EOL)
+ || scm_is_null (key))
&& !scm_is_eq (last, key))
{
SCM restore = SCM_EOL;
{
SCM new_alter_pair = scm_assoc (scm_caar (s), key);
Rational old_alter = robust_scm2rational (scm_cdar (s), 0);
- if (new_alter_pair == SCM_BOOL_F
+ if (scm_is_false (new_alter_pair)
|| ((ly_scm2rational (scm_cdr (new_alter_pair)) - old_alter) * old_alter
< Rational (0)))
{
/*
backup rules
- after making a change to the lexer rules, run
+ after making a change to the lexer rules, run
flex -b <this lexer file>
- and make sure that
+ and make sure that
lex.backup
contains no backup states, but only the reminder
Compressed tables always back up.
%option debug
%option yyclass="Lily_lexer"
%option stack
-%option never-interactive
+%option never-interactive
%option warn
%x chords
yy_pop_state ();
} else {
LexerError (_ ("string expected after \\include").c_str ());
- if (sval != SCM_UNDEFINED) {
+ if (!SCM_UNBNDP (sval)) {
SCM err = scm_current_error_port ();
scm_puts ("This value was found instead: ", err);
scm_display (sval, err);
hi.step_forward ();
SCM sval = ly_parse_scm (hi, be_safe_global && is_main_input_, parser_);
- if (sval == SCM_UNDEFINED)
+ if (SCM_UNBNDP (sval))
error_level_ = 1;
int n = hi.end () - hi.start ();
%%
-/* Make the lexer generate a token of the given type as the next token.
+/* Make the lexer generate a token of the given type as the next token.
TODO: make it possible to define a value for the token as well */
void
Lily_lexer::push_extra_token (Input const &where, int token_type, SCM scm)
m->set_spot (override_input (here_input ()));
}
- if (sid != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (sid))
return scan_scm_id (sid);
- string msg (_f ("unknown escaped string: `\\%s'", str));
+ string msg (_f ("unknown escaped string: `\\%s'", str));
LexerError (msg.c_str ());
yylval = ly_string2scm (str);
m->set_spot (override_input (here_input ()));
}
- if (sid != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (sid))
return scan_scm_id (sid);
- string msg (_f ("undefined character or shorthand: %s", str));
+ string msg (_f ("undefined character or shorthand: %s", str));
LexerError (msg.c_str ());
yylval = ly_string2scm (str);
optional = SCM_CDR (cs);
cs = SCM_CAR (cs);
}
-
+
if (ly_is_procedure (cs))
push_extra_token (here_input (), EXPECT_SCM, cs);
else
SCM handle = SCM_BOOL_F;
if (scm_is_pair (pitchname_tab_stack_))
handle = scm_hashq_get_handle (scm_cdar (pitchname_tab_stack_), sym);
-
+
if (scm_is_pair (handle)) {
yylval = scm_cdr (handle);
if (Pitch::is_smob (yylval))
return DRUM_PITCH;
}
else if ((YYSTATE == chords)
- && (handle = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
+ && scm_is_true (handle = scm_hashq_get_handle (chordmodifier_tab_, sym)))
{
yylval = scm_cdr (handle);
return CHORD_MODIFIER;
if (!Input::is_smob (m->get_property ("origin")))
m->set_spot (override_input (here_input ()));
}
-
+
int token;
switch (extra_token) {
case '$':
/*
urg, belong to string (_convert)
- and should be generalised
+ and should be generalised
*/
void
strip_leading_white (string&s)
void
strip_trailing_white (string&s)
{
- ssize i = s.length ();
- while (i--)
+ ssize i = s.length ();
+ while (i--)
if (!isspace (s[i]))
break;
return false;
}
if (ver < oldest_version)
- {
+ {
non_fatal_error (_f ("file too old: %s (oldest supported: %s)", ver.to_string (), oldest_version.to_string ()));
non_fatal_error (_ ("consider updating the input with the convert-ly script"));
return false;
}
return true;
}
-
+
/*
substitute _
if (ligature_)
{
primitives_.push_back (info);
- if (info.grob () && brew_ligature_primitive_proc != SCM_EOL)
+ if (info.grob () && !scm_is_null (brew_ligature_primitive_proc))
info.grob ()->set_property ("stencil", brew_ligature_primitive_proc);
}
}
{
// If undefined, some internal function caused it...should never happen.
- assert (val != SCM_UNDEFINED);
+ assert (!SCM_UNBNDP (val));
if (!scm_is_symbol (sym))
return false;
SCM type = scm_object_property (sym, type_symbol);
- if (type != SCM_EOL && !ly_is_procedure (type))
+ if (!scm_is_null (type) && !ly_is_procedure (type))
{
warning (_f ("cannot find property type-check for `%s' (%s).",
ly_symbol2string (sym).c_str (),
TODO: should remove #f from allowed vals?
*/
- if (val == SCM_EOL || val == SCM_BOOL_F)
+ if (scm_is_null (val) || scm_is_false (val))
return true;
- if (val != SCM_EOL
+ if (!scm_is_null (val)
&& ly_is_procedure (type)
- && scm_call_1 (type, val) == SCM_BOOL_F)
+ && scm_is_false (scm_call_1 (type, val)))
{
SCM typefunc = ly_lily_module_constant ("type-name");
SCM type_name = scm_call_1 (typefunc, type);
-
+
warning (_f ("type check for `%s' failed; value `%s' must be of type `%s'",
ly_symbol2string (sym).c_str (),
print_scm_val (val),
int
robust_scm2int (SCM k, int o)
{
- if (scm_integer_p (k) == SCM_BOOL_T)
+ if (scm_is_integer (k))
o = scm_to_int (k);
return o;
}
vsize
robust_scm2vsize (SCM k, vsize o)
{
- if (scm_integer_p (k) == SCM_BOOL_T)
+ if (scm_is_integer (k))
{
int i = scm_to_int (k);
if (i >= 0)
for (SCM s = scopes_; scm_is_pair (s); s = scm_cdr (s))
{
SCM var = ly_module_lookup (scm_car (s), sym);
- if (var != SCM_BOOL_F)
+ if (scm_is_true (var))
return scm_variable_ref (var);
}
if (scm_is_pair (path))
{
SCM prev = ly_module_lookup (mod, sym);
- if (prev != SCM_BOOL_F)
+ if (scm_is_true (prev))
val = nested_property_alist (scm_variable_ref (prev), path, val);
}
scm_module_define (mod, sym, val);
out_file_name.ext_ = "";
out_file_name.root_ = "";
- if (ly_get_option (ly_symbol2scm ("gui")) != SCM_BOOL_T
- && ly_get_option (ly_symbol2scm ("strip-output-dir")) == SCM_BOOL_T)
+ if (!to_boolean (ly_get_option (ly_symbol2scm ("gui")))
+ && to_boolean (ly_get_option (ly_symbol2scm ("strip-output-dir"))))
{
out_file_name.dir_ = "";
}
LY_ASSERT_TYPE (ly_is_symbol, symbol, 2);
SCM val = parser->lexer_->lookup_identifier (ly_symbol2string (symbol));
- if (val != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (val))
return val;
else
return SCM_EOL;
get_paper (Lily_parser *parser)
{
SCM papers = parser->lexer_->lookup_identifier ("$papers");
- Output_def *layout = ((papers == SCM_UNDEFINED) || scm_is_null (papers))
+ Output_def *layout = (SCM_UNBNDP (papers) || scm_is_null (papers))
? 0 : Output_def::unsmob (scm_car (papers));
SCM default_paper = parser->lexer_->lookup_identifier ("$defaultpaper");
layout = layout ? layout : Output_def::unsmob (default_paper);
* robust_scm2double (me->get_property ("thickness"), 1);
SCM type = me->get_property ("style");
- if (type == ly_symbol2scm ("zigzag"))
+ if (scm_is_eq (type, ly_symbol2scm ("zigzag")))
return make_zigzag_line (me, from, to);
- else if (type == ly_symbol2scm ("trill"))
+ else if (scm_is_eq (type, ly_symbol2scm ("trill")))
return make_trill_line (me, from, to);
- else if (type == ly_symbol2scm ("none"))
+ else if (scm_is_eq (type, ly_symbol2scm ("none")))
return Stencil ();
Stencil stencil;
- if (type == ly_symbol2scm ("dashed-line") || type == ly_symbol2scm ("dotted-line"))
+ if (scm_is_eq (type, ly_symbol2scm ("dashed-line"))
+ || scm_is_eq (type, ly_symbol2scm ("dotted-line")))
{
Real fraction
- = type == ly_symbol2scm ("dotted-line")
+ = scm_is_eq (type, ly_symbol2scm ("dotted-line"))
? 0.0
: robust_scm2double (me->get_property ("dash-fraction"), 0.4);
SCM bound_details = me->get_property ("bound-details");
SCM details = SCM_BOOL_F;
- if (details == SCM_BOOL_F)
+ if (scm_is_false (details))
details = ly_assoc_get ((dir == LEFT)
? ly_symbol2scm ("left")
: ly_symbol2scm ("right"), bound_details, SCM_BOOL_F);
details = scm_append (scm_list_2 (extra, details));
}
- if (details == SCM_BOOL_F)
+ if (scm_is_false (details))
details = ly_assoc_get (ly_symbol2scm ("default"), bound_details, SCM_EOL);
SCM text = ly_assoc_get (ly_symbol2scm ("text"), details, SCM_BOOL_F);
SCM text = me->get_property ("text");
if (Text_interface::is_markup (text)
&& me->get_bound (LEFT)->break_status_dir () == CENTER
- && ly_assoc_get (ly_symbol2scm ("stencil"), alist, SCM_BOOL_F) == SCM_BOOL_F)
+ && scm_is_false (ly_assoc_get (ly_symbol2scm ("stencil"), alist, SCM_BOOL_F)))
{
Output_def *layout = me->layout ();
SCM properties = Font_interface::text_font_alist_chain (me);
SCM val,
SCM result)
{
- if (scm_variable_bound_p (val) == SCM_BOOL_T)
+ if (to_boolean (scm_variable_bound_p (val)))
return scm_cons (scm_cons (key, scm_variable_ref (val)), result);
programming_error ("unbound variable in module");
return result;
if (!scm_is_number (m))
m = get_property ("rehearsalMark");
- if (scm_integer_p (m) == SCM_BOOL_T
- && scm_exact_p (m) == SCM_BOOL_T)
+ if (scm_is_integer (m)
+ && scm_is_true (scm_exact_p (m)))
{
int mark_count = scm_to_int (m);
mark_count++;
/*
TODO: use line interface
*/
- if (which == ly_symbol2scm ("bracket"))
+ if (scm_is_eq (which, ly_symbol2scm ("bracket")))
m = Lookup::bracket (X_AXIS, iv, t, -height, t);
- else if (which == ly_symbol2scm ("triangle"))
+ else if (scm_is_eq (which, ly_symbol2scm ("triangle")))
m = Lookup::triangle (iv, t, height);
m.align_to (Y_AXIS, DOWN);
internal_brew_primitive (Grob *me)
{
SCM primitive_scm = me->get_property ("primitive");
- if (primitive_scm == SCM_EOL)
+ if (scm_is_null (primitive_scm))
{
programming_error ("Mensural_ligature:"
" undefined primitive -> ignoring grob");
static bool
safe_is_member (SCM scm, SCM lst)
{
- return scm_list_p (lst) == SCM_BOOL_T
- && scm_member (scm, lst) != SCM_BOOL_F;
+ return ly_is_list (lst) && scm_is_true (scm_member (scm, lst));
}
void
Grob *g = info.grob ();
if (text_
- && g->get_property ("break-align-symbol")
- == ly_symbol2scm ("staff-bar"))
+ && scm_is_eq (g->get_property ("break-align-symbol"),
+ ly_symbol2scm ("staff-bar")))
bar_ = g;
else if (text_
&& !support_
SCM proc = ly_lily_module_constant ("midi-program");
SCM program = scm_call_1 (proc, ly_symbol2scm (audio_->str_.c_str ()));
- found = (program != SCM_BOOL_F);
+ found = (scm_is_true (program));
if (found)
program_byte = (Byte) scm_to_int (program);
else
SCM /* result */)
{
SCM module = (SCM) closure;
- if (scm_variable_bound_p (val) == SCM_BOOL_T)
+ if (to_boolean (scm_variable_bound_p (val)))
scm_module_define (module, key, scm_variable_ref (val));
return SCM_EOL;
}
{
SCM mod = scm_car (s);
SCM v = ly_module_lookup (mod, sym);
- if (SCM_VARIABLEP (v) && SCM_VARIABLE_REF (v) != SCM_UNDEFINED)
+ if (SCM_VARIABLEP (v) && !SCM_UNBNDP (SCM_VARIABLE_REF (v)))
return scm_variable_ref (v);
}
- if (def != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (def))
return def;
return SCM_BOOL_F;
}
Grob *last = 0;
for (vsize i = 0; i < numbers_.size (); i++)
{
- if (scm_from_int (d) == numbers_[i]->get_property ("direction"))
+ if (scm_is_eq (scm_from_int (d),
+ numbers_[i]->get_property ("direction")))
{
if (last)
Side_position_interface::add_support (numbers_[i], last);
numbers_.clear ();
Grob *last = last_numbers_.size () ? last_numbers_[0] : 0;
- if (last && last->get_property ("text") == SCM_EOL)
+ if (last && scm_is_null (last->get_property ("text")))
{
SCM thres = get_property ("restNumberThreshold");
int t = 1;
if (measure_count == 1)
{
- if (me->get_property ("staff-position") == SCM_EOL)
+ if (scm_is_null (me->get_property ("staff-position")))
{
int dir = get_grob_direction (me);
Real pos = Rest::staff_position_internal (me, mdl, dir);
{
SCM ifs = get_property ("types");
- return scm_c_memq (k, ifs) != SCM_BOOL_F;
+ return scm_is_true (scm_c_memq (k, ifs));
}
Music::Music (SCM init)
{
Pitch transposed = p->transposed (delta);
- if (prop == ly_symbol2scm ("tonic"))
+ if (scm_is_eq (prop, ly_symbol2scm ("tonic")))
transposed = Pitch (-1, transposed.get_notename (),
transposed.get_alteration ());
new_val = transposed.smobbed_copy ();
}
- else if (prop == ly_symbol2scm ("element"))
+ else if (scm_is_eq (prop, ly_symbol2scm ("element")))
{
if (Music *m = Music::unsmob (val))
m->transpose (delta);
}
- else if (prop == ly_symbol2scm ("elements")
- || prop == ly_symbol2scm ("articulations"))
+ else if (scm_is_eq (prop, ly_symbol2scm ("elements"))
+ || scm_is_eq (prop, ly_symbol2scm ("articulations")))
transpose_music_list (val, delta);
- else if (prop == ly_symbol2scm ("pitch-alist")
+ else if (scm_is_eq (prop, ly_symbol2scm ("pitch-alist"))
&& scm_is_pair (val))
new_val = ly_transpose_key_alist (val, delta.smobbed_copy ());
// when we don't want them displayed. So don't make space
// for them if 'stencil is #f
Grob *g = make_item ("StringNumber", ev->self_scm ());
- if (g->get_property ("stencil") != SCM_BOOL_F)
+ if (scm_is_true (g->get_property ("stencil")))
add_fingering (inf.grob (),
ly_symbol2scm ("StringNumber"), &string_numbers_,
ev, note_ev);
vector_sort (*scripts, less<Finger_tuple> ());
- bool up_p = scm_c_memq (ly_symbol2scm ("up"), orientations) != SCM_BOOL_F;
- bool down_p = scm_c_memq (ly_symbol2scm ("down"), orientations) != SCM_BOOL_F;
- bool left_p = scm_c_memq (ly_symbol2scm ("left"), orientations) != SCM_BOOL_F;
- bool right_p = scm_c_memq (ly_symbol2scm ("right"), orientations) != SCM_BOOL_F;
+ bool up_p = scm_is_true (scm_c_memq (ly_symbol2scm ("up"), orientations));
+ bool down_p = scm_is_true (scm_c_memq (ly_symbol2scm ("down"), orientations));
+ bool left_p = scm_is_true (scm_c_memq (ly_symbol2scm ("left"), orientations));
+ bool right_p = scm_is_true (scm_c_memq (ly_symbol2scm ("right"), orientations));
Direction hordir = (right_p) ? RIGHT : LEFT;
if (left_p || right_p)
{
SCM up_style = head_up->get_property ("style");
SCM down_style = head_down->get_property ("style");
if (merge_possible
- && (up_style == ly_symbol2scm ("fa") || up_style == ly_symbol2scm ("faThin"))
- && (down_style == ly_symbol2scm ("fa") || down_style == ly_symbol2scm ("faThin")))
+ && (scm_is_eq (up_style, ly_symbol2scm ("fa"))
+ || scm_is_eq (up_style, ly_symbol2scm ("faThin")))
+ && (scm_is_eq (down_style, ly_symbol2scm ("fa"))
+ || scm_is_eq (down_style, ly_symbol2scm ("faThin"))))
{
Offset att = Offset (0.0, -1.0);
head_up->set_property ("stem-attachment", ly_offset2scm (att));
SCM entry = scm_hashq_ref (lily_character_table_, sym, SCM_BOOL_F);
Offset o;
- if (entry == SCM_BOOL_F)
+ if (scm_is_false (entry))
return o;
SCM char_alist = entry;
SCM sym = ly_symbol2scm (name);
SCM alist = scm_hashq_ref (lily_character_table_, sym, SCM_BOOL_F);
- if (alist != SCM_BOOL_F)
+ if (scm_is_true (alist))
{
SCM bbox = scm_cdr (scm_assq (ly_symbol2scm ("bbox"), alist));
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
SCM answer = op->lookup_variable (sym);
- if (answer == SCM_UNDEFINED)
+ if (SCM_UNBNDP (answer))
{
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_EOL;
answer = val;
SCM tab2 = b->lookup_variable (ly_symbol2scm ("pango-fonts"));
SCM alist1 = SCM_EOL;
- if (scm_hash_table_p (tab1) == SCM_BOOL_T)
+ if (to_boolean (scm_hash_table_p (tab1)))
{
alist1 = scm_append (ly_alist_vals (ly_hash2alist (tab1)));
Output_def::lookup_variable (SCM sym) const
{
SCM var = ly_module_lookup (scope_, sym);
- if (SCM_VARIABLEP (var) && SCM_VARIABLE_REF (var) != SCM_UNDEFINED)
+ if (SCM_VARIABLEP (var) && !SCM_UNBNDP (SCM_VARIABLE_REF (var)))
return SCM_VARIABLE_REF (var);
if (parent_)
? c_variable ("inner-margin")
: c_variable ("right-margin"));
- if (scm_paper_width == SCM_UNDEFINED
- || scm_left_margin_default == SCM_UNDEFINED
- || scm_right_margin_default == SCM_UNDEFINED)
+ if (SCM_UNBNDP (scm_paper_width)
+ || SCM_UNBNDP (scm_left_margin_default)
+ || SCM_UNBNDP (scm_right_margin_default))
{
programming_error ("called normalize () on paper with missing settings");
return;
if (twosided)
binding_offset = robust_scm2double (c_variable ("binding-offset"), 0);
- if (scm_line_width == SCM_UNDEFINED)
+ if (SCM_UNBNDP (scm_line_width))
{
- left_margin = ((scm_left_margin == SCM_UNDEFINED)
+ left_margin = (SCM_UNBNDP (scm_left_margin)
? left_margin_default
: scm_to_double (scm_left_margin));
- right_margin = ((scm_right_margin == SCM_UNDEFINED)
+ right_margin = (SCM_UNBNDP (scm_right_margin)
? right_margin_default
: scm_to_double (scm_right_margin)) + binding_offset;
line_width = paper_width - left_margin - right_margin;
else
{
line_width = scm_to_double (scm_line_width);
- if (scm_left_margin == SCM_UNDEFINED)
+ if (SCM_UNBNDP (scm_left_margin))
{
// Vertically center systems if only line-width is given
- if (scm_right_margin == SCM_UNDEFINED)
+ if (SCM_UNBNDP (scm_right_margin))
{
left_margin = (paper_width - line_width) / 2;
right_margin = left_margin;
else
{
left_margin = scm_to_double (scm_left_margin);
- right_margin = ((scm_right_margin == SCM_UNDEFINED)
+ right_margin = (SCM_UNBNDP (scm_right_margin)
? (paper_width - line_width - left_margin)
: scm_to_double (scm_right_margin)) + binding_offset;
}
SCM ret = SCM_EOL;
bool reset_footnotes_on_new_page = to_boolean (book_->top_paper ()->c_variable ("reset-footnotes-on-new-page"));
SCM label_page_table = book_->top_paper ()->c_variable ("label-page-table");
- if (label_page_table == SCM_UNDEFINED)
+ if (SCM_UNBNDP (label_page_table))
label_page_table = SCM_EOL;
// Build a list of (systems configuration . footnote-count) triples.
if ((!too_few_lines (line_count) && (next_height > cur_page_height && cur_rod_height > 0))
|| too_many_lines (next_line_count)
- || (prev && prev->page_permission_ == ly_symbol2scm ("force")))
+ || prev && scm_is_eq (prev->page_permission_, ly_symbol2scm ("force")))
{
line_count = cur.compressed_nontitle_lines_count_;
cur_rod_height = cur.full_height ();
system_count_on_this_page += cur_line.compressed_nontitle_lines_count_;
line++;
- if (cur_line.page_permission_ == ly_symbol2scm ("force"))
+ if (scm_is_eq (cur_line.page_permission_, ly_symbol2scm ("force")))
break;
}
if ((line > page_first_line)
&& (isinf (space.force_)
|| ((line > 0)
- && (cached_line_details_[line - 1].page_permission_ == ly_symbol2scm ("force")))))
+ && scm_is_eq (cached_line_details_[line - 1].page_permission_,
+ ly_symbol2scm ("force")))))
{
res.systems_per_page_.push_back (line - page_first_line);
res.force_.push_back (prev_force);
/* if there is a forced break, this reduces to 2 1-page problems */
cache_line_details (configuration);
for (vsize i = 0; i + 1 < cached_line_details_.size (); i++)
- if (cached_line_details_[i].page_permission_ == ly_symbol2scm ("force"))
+ if (scm_is_eq (cached_line_details_[i].page_permission_,
+ ly_symbol2scm ("force")))
{
vector<Line_details> lines1 (cached_line_details_.begin (), cached_line_details_.begin () + i + 1);
vector<Line_details> lines2 (cached_line_details_.begin () + i + 1, cached_line_details_.end ());
else if (Prob *p = Prob::unsmob (scm_car (s)))
{
SCM stencils = p->get_property ("footnotes");
- if (stencils == SCM_EOL)
+ if (scm_is_null (stencils))
continue;
for (SCM st = stencils; scm_is_pair (st); st = scm_cdr (st))
footnotes.push_back (0);
}
if (page_start > 0
- && lines_[page_start - 1].page_permission_ == ly_symbol2scm ("force"))
+ && scm_is_eq (lines_[page_start - 1].page_permission_,
+ ly_symbol2scm ("force")))
break;
}
return !isinf (cur.demerits_);
if (duration_[LEFT] < penalty.duration_[LEFT])
ret.push_back (Page_turn_event (duration_[LEFT], penalty.duration_[LEFT], permission_, penalty_));
- if (penalty.permission_ != SCM_EOL)
+ if (!scm_is_null (penalty.permission_))
ret.push_back (Page_turn_event (intersect[LEFT], intersect[RIGHT], permission_, new_pen));
if (penalty.duration_[RIGHT] < duration_[RIGHT])
for (; scm_is_pair (cs); cs = scm_cdr (cs))
{
SCM command = scm_car (cs);
- if (command == ly_symbol2scm ("start-repeat"))
+ if (scm_is_eq (command, ly_symbol2scm ("start-repeat")))
start = true;
- else if (command == ly_symbol2scm ("end-repeat"))
+ else if (scm_is_eq (command, ly_symbol2scm ("end-repeat")))
end = true;
}
SCM
Page_turn_engraver::max_permission (SCM perm1, SCM perm2)
{
- if (perm1 == SCM_EOL)
+ if (scm_is_null (perm1))
return perm2;
- if (perm1 == ly_symbol2scm ("allow") && perm2 == ly_symbol2scm ("force"))
+ if (scm_is_eq (perm1, ly_symbol2scm ("allow"))
+ && scm_is_eq (perm2, ly_symbol2scm ("force")))
return perm2;
return perm1;
}
for (vsize start = end; start--;)
{
if (start < end - 1
- && breakpoint_property (start + 1, "page-turn-permission") == ly_symbol2scm ("force"))
+ && scm_is_eq (breakpoint_property (start + 1, "page-turn-permission"),
+ ly_symbol2scm ("force")))
break;
if (start > 0 && best.demerits_ < state_[start - 1].demerits_)
variable that is bound to a *named* procedure, i.e. not a
lambda expression.
*/
- if (utf8_string != SCM_BOOL_F
- && scm_procedure_name (SCM_VARIABLE_REF (utf8_string)) != SCM_BOOL_F)
+ if (scm_is_true (utf8_string)
+ && scm_is_true (scm_procedure_name (SCM_VARIABLE_REF (utf8_string))))
has_utf8_string = true;
}
symbol_to_pango_style (SCM style)
{
PangoStyle pstyle = PANGO_STYLE_NORMAL;
- if (style == ly_symbol2scm ("italic"))
+ if (scm_is_eq (style, ly_symbol2scm ("italic")))
pstyle = PANGO_STYLE_ITALIC;
- else if (style == ly_symbol2scm ("oblique")
- || style == ly_symbol2scm ("slanted"))
+ else if (scm_is_eq (style, ly_symbol2scm ("oblique"))
+ || scm_is_eq (style, ly_symbol2scm ("slanted")))
pstyle = PANGO_STYLE_OBLIQUE;
return pstyle;
symbol_to_pango_variant (SCM variant)
{
PangoVariant pvariant = PANGO_VARIANT_NORMAL;
- if (variant == ly_symbol2scm ("caps"))
+ if (scm_is_eq (variant, ly_symbol2scm ("caps")))
pvariant = PANGO_VARIANT_SMALL_CAPS;
return pvariant;
}
symbol_to_pango_weight (SCM weight)
{
PangoWeight pw = PANGO_WEIGHT_NORMAL;
- if (weight == ly_symbol2scm ("bold"))
+ if (scm_is_eq (weight, ly_symbol2scm ("bold")))
pw = PANGO_WEIGHT_BOLD;
- if (weight == ly_symbol2scm ("heavy"))
+ if (scm_is_eq (weight, ly_symbol2scm ("heavy")))
pw = PANGO_WEIGHT_HEAVY;
- if (weight == ly_symbol2scm ("ultrabold"))
+ if (scm_is_eq (weight, ly_symbol2scm ("ultrabold")))
pw = PANGO_WEIGHT_ULTRABOLD;
- if (weight == ly_symbol2scm ("light"))
+ if (scm_is_eq (weight, ly_symbol2scm ("light")))
pw = PANGO_WEIGHT_LIGHT;
- if (weight == ly_symbol2scm ("ultralight"))
+ if (scm_is_eq (weight, ly_symbol2scm ("ultralight")))
pw = PANGO_WEIGHT_ULTRALIGHT;
return pw;
}
else
{
- if (scores_ == SCM_EOL)
+ if (scm_is_null (scores_))
return 0;
paper_->set_variable (ly_symbol2scm ("first-page-number"),
scm_from_long (*first_page_number));
with different line-widths) and why we need it at all.
*/
- if (paper_->c_variable ("line-width") == SCM_UNDEFINED)
+ if (SCM_UNBNDP (paper_->c_variable ("line-width")))
paper_->set_variable (ly_symbol2scm ("line-width"),
paper_->c_variable ("paper-width"));
SCM framework = ly_module_lookup (mod,
ly_symbol2scm ("output-framework"));
- if (framework != SCM_BOOL_F)
+ if (scm_is_true (framework))
{
SCM func = scm_variable_ref (framework);
scm_call_4 (func,
SCM framework
= ly_module_lookup (mod, ly_symbol2scm ("output-preview-framework"));
- if (framework != SCM_BOOL_F)
+ if (scm_is_true (framework))
{
SCM func = scm_variable_ref (framework);
scm_call_4 (func,
if (ly_is_module (scm_car (s)))
{
header = scm_car (s);
- if (header_0_ == SCM_EOL)
+ if (scm_is_null (header_0_))
header_0_ = header;
}
else if (Page_marker *page_marker = Page_marker::unsmob (scm_car (s)))
SCM
Paper_book::systems ()
{
- if (systems_ != SCM_BOOL_F)
+ if (scm_is_true (systems_))
return systems_;
systems_ = SCM_EOL;
{
SCM perm = ps->get_property ("page-break-permission");
Prob *next = Prob::unsmob (scm_cadr (s));
- if (perm == SCM_EOL)
+ if (scm_is_null (perm))
next->set_property ("penalty", scm_from_int (10001));
- else if (perm == ly_symbol2scm ("force"))
+ else if (scm_is_eq (perm, ly_symbol2scm ("force")))
next->set_property ("penalty", scm_from_int (-10001));
}
}
SCM
Paper_book::pages ()
{
- if (SCM_BOOL_F != pages_)
+ if (scm_is_true (pages_))
return pages_;
pages_ = SCM_EOL;
scm_call_2 (post_process, paper_->self_scm (), pages_);
/* set systems_ from the pages */
- if (systems_ == SCM_BOOL_F)
+ if (scm_is_false (systems_))
{
systems_ = SCM_EOL;
for (SCM p = pages_; scm_is_pair (p); p = scm_cdr (p))
for (vsize i = 0; i < break_events_.size (); i++)
{
SCM perm = break_events_[i]->get_property ("break-permission");
- if (perm == ly_symbol2scm ("force") || perm == ly_symbol2scm ("allow"))
+ if (scm_is_eq (perm, ly_symbol2scm ("force"))
+ || scm_is_eq (perm, ly_symbol2scm ("allow")))
warning (_ ("forced break was overridden by some other event, "
"should you be using bar checks?"));
}
for (;!align && scm_is_pair (align_syms); align_syms = scm_cdr (align_syms))
{
SCM align_sym = scm_car (align_syms);
- if (align_sym == ly_symbol2scm ("staff-bar")
- || align_sym == ly_symbol2scm ("break-alignment"))
+ if (scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
+ || scm_is_eq (align_sym, ly_symbol2scm ("break-alignment")))
align = Pointer_group_interface::find_grob
(me, ly_symbol2scm ("elements"),
- (align_sym == ly_symbol2scm ("staff-bar")
+ (scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
? Bar_line::non_empty_barline
: Break_alignment_interface::has_interface));
else
get_font_table (Output_def *def)
{
SCM font_table = def->lookup_variable (ly_symbol2scm ("scaled-fonts"));
- if (scm_hash_table_p (font_table) != SCM_BOOL_T)
+ if (!to_boolean (scm_hash_table_p (font_table)))
{
font_table = scm_c_make_hash_table (11);
def->set_variable (ly_symbol2scm ("scaled-fonts"), font_table);
get_pango_font_table (Output_def *def)
{
SCM font_table = def->lookup_variable (ly_symbol2scm ("pango-fonts"));
- if (scm_hash_table_p (font_table) != SCM_BOOL_T)
+ if (!to_boolean (scm_hash_table_p (font_table)))
{
font_table = scm_c_make_hash_table (11);
def->set_variable (ly_symbol2scm ("pango-fonts"), font_table);
void
Paper_outputter::close ()
{
- if (scm_port_p (file_) == SCM_BOOL_T)
+ if (ly_is_port (file_))
{
scm_close_port (file_);
/*
SCM
Paper_score::get_paper_systems ()
{
- if (paper_systems_ == SCM_BOOL_F)
+ if (scm_is_false (paper_systems_))
{
vector<Column_x_positions> breaking = calc_breaking ();
system_->break_into_pieces (breaking);
SCM head = scm_car (expr);
- if (head == ly_symbol2scm ("delay-stencil-evaluation"))
+ if (scm_is_eq (head, ly_symbol2scm ("delay-stencil-evaluation")))
{
// we likely need to do something here...just don't know what...
return SCM_EOL;
}
- if (head == ly_symbol2scm ("combine-stencil"))
+ if (scm_is_eq (head, ly_symbol2scm ("combine-stencil")))
{
SCM out = SCM_EOL;
SCM *tail = &out;
for (SCM x = scm_cdr (expr); scm_is_pair (x); x = scm_cdr (x))
{
SCM footnote = get_footnotes (scm_car (x));
- if (SCM_EOL != footnote)
+ if (!scm_is_null (footnote))
{
*tail = scm_cons (footnote, SCM_EOL);
tail = SCM_CDRLOC (*tail);
}
return scm_append (out);
}
- if (head == ly_symbol2scm ("translate-stencil"))
+ if (scm_is_eq (head, ly_symbol2scm ("translate-stencil")))
return get_footnotes (scm_caddr (expr));
- if (head == ly_symbol2scm ("footnote"))
+ if (scm_is_eq (head, ly_symbol2scm ("footnote")))
return scm_list_1 (scm_cdr (expr));
return SCM_EOL;
if (ps->safe_)
{
static SCM module = SCM_BOOL_F;
- if (module == SCM_BOOL_F)
+ if (scm_is_false (module))
{
SCM function = ly_lily_module_constant ("make-safe-lilypond-module");
module = scm_gc_protect_object (scm_call_0 (function));
} else if (Output_def * od = Output_def::unsmob ($1)) {
SCM id = SCM_EOL;
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $1);
SCM id = SCM_EOL;
Output_def * od = Output_def::unsmob ($1);
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $1);
} else if (Output_def *od = Output_def::unsmob ($2)) {
SCM id = SCM_EOL;
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $2);
} else if (Output_def *od = Output_def::unsmob ($2)) {
SCM id = SCM_EOL;
- if (od->c_variable ("is-paper") == SCM_BOOL_T)
+ if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
- else if (od->c_variable ("is-midi") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-midi")))
id = ly_symbol2scm ("$defaultmidi");
- else if (od->c_variable ("is-layout") == SCM_BOOL_T)
+ else if (to_boolean (od->c_variable ("is-layout")))
id = ly_symbol2scm ("$defaultlayout");
parser->lexer_->set_identifier (id, $2);
{
Output_def *od = Output_def::unsmob ($2);
if (od) {
- if (od->lookup_variable (ly_symbol2scm ("is-paper")) == SCM_BOOL_T)
+ if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
parser->parser_error (@2, _("\\paper cannot be used in \\score, use \\layout instead"));
od = 0;
output_def {
Output_def *od = Output_def::unsmob ($1);
- if (od->lookup_variable (ly_symbol2scm ("is-paper")) != SCM_BOOL_T)
+ if (!to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
parser->parser_error (@1, _ ("need \\paper for paper block"));
$$ = get_paper (parser)->unprotect ();
mode_changed_music:
mode_changing_head grouped_music_list {
- if ($1 == ly_symbol2scm ("chords"))
+ if (scm_is_eq ($1, ly_symbol2scm ("chords")))
{
$$ = MAKE_SYNTAX ("unrelativable-music", @$, $2);
}
if (ctxmod)
mods = ctxmod->get_mods ();
$$ = MAKE_SYNTAX ("context-specification", @$, $1, SCM_EOL, mods, SCM_BOOL_T, $3);
- if ($1 == ly_symbol2scm ("ChordNames"))
+ if (scm_is_eq ($1, ly_symbol2scm ("ChordNames")))
{
$$ = MAKE_SYNTAX ("unrelativable-music", @$, $$);
}
{
SCM what = scm_car (ev->get_property ("class"));
SCM text = SCM_EOL;
- if (what == ly_symbol2scm ("solo-one-event"))
+ if (scm_is_eq (what, ly_symbol2scm ("solo-one-event")))
text = get_property ("soloText");
- else if (what == ly_symbol2scm ("solo-two-event"))
+ else if (scm_is_eq (what, ly_symbol2scm ("solo-two-event")))
text = get_property ("soloIIText");
- else if (what == ly_symbol2scm ("unisono-event"))
+ else if (scm_is_eq (what, ly_symbol2scm ("unisono-event")))
text = get_property ("aDueText");
if (Text_interface::is_markup (text))
SCM tag = scm_cdar (split_list_);
- if (tag == ly_symbol2scm ("chords"))
+ if (scm_is_eq (tag, ly_symbol2scm ("chords")))
chords_together ();
- else if (tag == ly_symbol2scm ("apart")
- || tag == ly_symbol2scm ("apart-silence")
- || tag == ly_symbol2scm ("apart-spanner"))
- apart (tag == ly_symbol2scm ("apart-silence"));
- else if (tag == ly_symbol2scm ("unisono"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("apart"))
+ || scm_is_eq (tag, ly_symbol2scm ("apart-silence"))
+ || scm_is_eq (tag, ly_symbol2scm ("apart-spanner")))
+ apart (scm_is_eq (tag, ly_symbol2scm ("apart-silence")));
+ else if (scm_is_eq (tag, ly_symbol2scm ("unisono")))
{
// Continue to use the most recently used part because we might have
// killed mmrests in the other part.
unisono (false, (last_playing_ == 2) ? 2 : 1);
}
- else if (tag == ly_symbol2scm ("unisilence"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("unisilence")))
{
// as for unisono
unisono (true, (last_playing_ == 2) ? 2 : 1);
}
- else if (tag == ly_symbol2scm ("silence1"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("silence1")))
unisono (true, 1);
- else if (tag == ly_symbol2scm ("silence2"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("silence2")))
unisono (true, 2);
- else if (tag == ly_symbol2scm ("solo1"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("solo1")))
solo1 ();
- else if (tag == ly_symbol2scm ("solo2"))
+ else if (scm_is_eq (tag, ly_symbol2scm ("solo2")))
solo2 ();
else if (scm_is_symbol (tag))
{
percent_->set_bound (LEFT, col);
SCM count = percent_event_->get_property ("repeat-count");
- if (count != SCM_EOL && to_boolean (get_property ("countPercentRepeats"))
+ if (!scm_is_null (count) && to_boolean (get_property ("countPercentRepeats"))
&& check_repeat_count_visibility (context (), count))
{
percent_counter_ = make_spanner ("PercentRepeatCounter",
SCM style = get_property (p->type_->style_sym_);
- bool mixed = style == ly_symbol2scm ("mixed");
+ bool mixed = scm_is_eq (style, ly_symbol2scm ("mixed"));
bool bracket = (mixed
- || style == ly_symbol2scm ("bracket"));
- bool text = (style == ly_symbol2scm ("text")
- || mixed);
+ || scm_is_eq (style, ly_symbol2scm ("bracket")));
+ bool text = (mixed
+ || scm_is_eq (style, ly_symbol2scm ("text")));
if (text && !p->item_)
create_text_grobs (p, mixed);
int bn = measure_number (context ());
SCM handle = scm_assoc (key, keysig);
- if (handle != SCM_BOOL_F)
+ if (scm_is_true (handle))
{
bool same_bar = (bn == robust_scm2int (scm_caddr (handle), 0));
bool same_alt
handle = SCM_BOOL_F;
}
- bool print_acc
- = (handle == SCM_BOOL_F) || p->get_alteration () == Rational (0)
- || (ev->get_property ("force-accidental") == SCM_BOOL_T);
+ bool print_acc = scm_is_false (handle)
+ || p->get_alteration () == Rational (0)
+ || to_boolean (ev->get_property ("force-accidental"));
if (trill_head_)
{
Prob *ps = Prob::unsmob (prob);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_EOL;
SCM retval = ps->get_property (sym);
- if (retval == SCM_EOL)
+ if (scm_is_null (retval))
return val;
else
return retval;
{
SCM aval = scm_cdar (aprop);
SCM bval = scm_cdar (bprop);
- if (scm_caar (aprop) != scm_caar (bprop)
+ if (!scm_is_eq (scm_caar (aprop), scm_caar (bprop))
|| (!(Input::is_smob (aval) && Input::is_smob (bval))
- &&
- !to_boolean (scm_equal_p (aval, bval))))
+ && !ly_is_equal (aval, bval)))
return SCM_BOOL_F;
}
/* is one list shorter? */
- if (aprop != SCM_EOL || bprop != SCM_EOL)
+ if (!scm_is_null (aprop) || !scm_is_null (bprop))
return SCM_BOOL_F;
}
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 */
" @var{sym}. Choices are @code{prob}, @code{grob}, and"
" @code{context}.")
{
- if (sym == ly_symbol2scm ("context"))
+ if (scm_is_eq (sym, ly_symbol2scm ("context")))
return context_property_lookup_table ? context_property_lookup_table
: scm_c_make_hash_table (1);
- if (sym == ly_symbol2scm ("prob"))
+ if (scm_is_eq (sym, ly_symbol2scm ("prob")))
return prob_property_lookup_table ? prob_property_lookup_table
: scm_c_make_hash_table (1);
- if (sym == ly_symbol2scm ("grob"))
+ if (scm_is_eq (sym, ly_symbol2scm ("grob")))
return grob_property_lookup_table ? grob_property_lookup_table
: scm_c_make_hash_table (1);
return scm_c_make_hash_table (1);
*table = scm_permanent_object (scm_c_make_hash_table (259));
SCM hashhandle = scm_hashq_get_handle (*table, sym);
- if (hashhandle == SCM_BOOL_F)
+ if (scm_is_false (hashhandle))
{
scm_hashq_set_x (*table, sym, scm_from_int (0));
hashhandle = scm_hashq_get_handle (*table, sym);
{
LY_ASSERT_TYPE (ly_is_symbol, var, 1);
- if (val == SCM_UNDEFINED)
+ if (SCM_UNBNDP (val))
val = SCM_BOOL_T;
string varstr = robust_symbol2string (var, "");
}
SCM handle = scm_hashq_get_handle (option_hash, var);
- if (handle == SCM_BOOL_F)
+ if (scm_is_false (handle))
warning (_f ("no such internal option: %s", varstr.c_str ()));
internal_set_option (var, val);
// for cue notes if quotedCueEventTypes is not set) use quotedEventTypes
if (is_cue)
accept = get_outlet ()->get_property ("quotedCueEventTypes");
- if (accept == SCM_EOL)
+ if (scm_is_null (accept))
accept = get_outlet ()->get_property ("quotedEventTypes");
for (; scm_is_pair (accept); accept = scm_cdr (accept))
while (scm_is_pair (cs))
{
SCM command = scm_car (cs);
- if (command == ly_symbol2scm ("start-repeat"))
+ if (scm_is_eq (command, ly_symbol2scm ("start-repeat")))
start = true;
- else if (command == ly_symbol2scm ("end-repeat"))
+ else if (scm_is_eq (command, ly_symbol2scm ("end-repeat")))
end = true;
- else if (command == ly_symbol2scm ("segno-display"))
+ else if (scm_is_eq (command, ly_symbol2scm ("segno-display")))
segno = true;
- else if (scm_is_pair (command) && scm_car (command) == ly_symbol2scm ("volta"))
+ else if (scm_is_pair (command)
+ && scm_is_eq (scm_car (command), ly_symbol2scm ("volta")))
volta_found = true;
cs = scm_cdr (cs);
}
Score_performer::finish (SCM)
{
SCM channel_mapping = context ()->get_property ("midiChannelMapping");
- bool use_ports = channel_mapping == ly_symbol2scm ("voice");
+ bool use_ports = scm_is_eq (channel_mapping, ly_symbol2scm ("voice"));
performance_->ports_ = use_ports;
recurse_over_translators (context (),
&Translator::finalize,
/* UGR, FIXME, these are default \layout blocks once again. They
suck. */
for (vsize i = 0; !score_def && i < sc->defs_.size (); i++)
- if (sc->defs_[i]->c_variable ("is-layout") == SCM_BOOL_T)
+ if (to_boolean (sc->defs_[i]->c_variable ("is-layout")))
score_def = sc->defs_[i];
if (!score_def)
Real scale = 1.0;
- if (layoutbook && layoutbook->c_variable ("is-paper") == SCM_BOOL_T)
+ if (layoutbook && to_boolean (layoutbook->c_variable ("is-paper")))
scale = scm_to_double (layoutbook->c_variable ("output-scale"));
SCM outputs = SCM_EOL;
Output_def *def = outdef_count ? defs_[i] : default_def;
SCM scaled = def->self_scm ();
- if (def->c_variable ("is-layout") == SCM_BOOL_T)
+ if (to_boolean (def->c_variable ("is-layout")))
{
def = scale_output_def (def, scale);
def->parent_ = layoutbook;
void
copy_property (Grob *g, SCM sym, SCM alist)
{
- if (g->get_property (sym) == SCM_EOL)
+ if (scm_is_null (g->get_property (sym)))
{
SCM entry = scm_assoc (sym, alist);
if (scm_is_pair (entry))
SCM alist = tg->get_property ("scriptDefinitions");
SCM art = scm_assoc (art_type, alist);
- if (art == SCM_BOOL_F)
+ if (scm_is_false (art))
{
/* FIXME: */
warning (_ ("do not know how to interpret articulation:"));
SCM val = scm_cdar (s);
- if (sym == ly_symbol2scm ("script-priority"))
+ if (scm_is_eq (sym, ly_symbol2scm ("script-priority")))
{
priority_found = true;
/* Make sure they're in order of user input by adding index i.
}
SCM preset = p->get_property_data (sym);
- if (val == SCM_EOL
- || scm_call_1 (type, preset) == SCM_BOOL_F)
+ if (scm_is_null (val)
+ || scm_is_false (scm_call_1 (type, preset)))
p->set_property (sym, val);
}
assert (scm_is_pair (s));
SCM key = scm_car (s);
- if (key == ly_symbol2scm ("feta"))
+ if (scm_is_eq (key, ly_symbol2scm ("feta")))
{
SCM name_entry = scm_cdr (s);
SCM str = ((scm_is_pair (name_entry)) ? index_get_cell (name_entry, d)
Grob *slur = Grob::unsmob (me->get_object ("slur"));
SCM avoid_slur = me->get_property ("avoid-slur");
if (slur && to_boolean (slur->get_property ("cross-staff"))
- && (avoid_slur == ly_symbol2scm ("outside")
- || avoid_slur == ly_symbol2scm ("around")))
+ && (scm_is_eq (avoid_slur, ly_symbol2scm ("outside"))
+ || scm_is_eq (avoid_slur, ly_symbol2scm ("around"))))
return SCM_BOOL_T;
return SCM_BOOL_F;
? me->get_property ("parent-alignment-X")
: me->get_property ("parent-alignment-Y");
- if (par_align == SCM_EOL)
+ if (scm_is_null (par_align))
par_align = self_align;
Real x = 0.0;
*tail = scm_cons (evaluate_with_simple_closure (delayed_argument, scm_car (s),
pure, start, end),
SCM_EOL);
- if (scm_car (*tail) == SCM_UNSPECIFIED)
+ if (scm_is_eq (scm_car (*tail), SCM_UNSPECIFIED))
return SCM_UNSPECIFIED;
tail = SCM_CDRLOC (*tail);
}
SCM args = scm_cons (delayed_argument,
evaluate_args (delayed_argument, scm_cdr (inside),
pure, start, end));
- if (scm_cdr (args) == SCM_UNSPECIFIED)
+ if (scm_is_eq (scm_cdr (args), SCM_UNSPECIFIED))
return SCM_UNSPECIFIED;
if (pure)
return call_pure_function (proc, args, start, end);
}
else if (!scm_is_pair (expr))
return expr;
- else if (scm_car (expr) == ly_symbol2scm ("quote"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("quote")))
return scm_cadr (expr);
else if (Unpure_pure_container::is_smob (scm_car (expr))
|| ly_is_procedure (scm_car (expr)))
? Unpure_pure_container::unsmob (scm_car (expr))->unpure_part ()
: scm_car (expr);
SCM args = evaluate_args (delayed_argument, scm_cdr (expr), pure, start, end);
- if (args == SCM_UNSPECIFIED)
+ if (scm_is_eq (args, SCM_UNSPECIFIED))
return SCM_UNSPECIFIED;
if (pure)
return call_pure_function (proc, args, start, end);
SCM_ASSERT_TYPE (scm_ilength (rods) > 0, rods, SCM_ARG1, __FUNCTION__, "list of rods");
LY_ASSERT_TYPE (scm_is_number, length, 3);
- bool is_ragged = ragged == SCM_BOOL_T;
+ bool is_ragged = to_boolean (ragged);
Simple_spacer spacer;
for (SCM s = springs; scm_is_pair (s); s = scm_cdr (s))
{
for (vsize i = 1; i + 1 < ret.cols_.size (); i++)
{
SCM p = ret.cols_[i]->get_property ("line-break-permission");
- if (p == ly_symbol2scm ("force"))
+ if (scm_is_eq (p, ly_symbol2scm ("force")))
ret.satisfies_constraints_ = false;
}
LY_ASSERT_SMOB (Skyline, other_skyline_scm, 1);
Real horizon_padding = 0;
- if (horizon_padding_scm != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (horizon_padding_scm))
{
LY_ASSERT_TYPE (scm_is_number, horizon_padding_scm, 3);
horizon_padding = scm_to_double (horizon_padding_scm);
LY_ASSERT_SMOB (Skyline, other_skyline_scm, 1);
Real horizon_padding = 0;
- if (horizon_padding_scm != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (horizon_padding_scm))
{
LY_ASSERT_TYPE (scm_is_number, horizon_padding_scm, 3);
horizon_padding = scm_to_double (horizon_padding_scm);
}
Real dist = 0.0;
- if (info.type_ == ly_symbol2scm ("around"))
+ if (scm_is_eq (info.type_, ly_symbol2scm ("around")))
dist = info.extents_[Y_AXIS].distance (y);
/*
Have to score too: the curve enumeration is limited in its
shape, and may produce curves which collide anyway.
*/
- else if (info.type_ == ly_symbol2scm ("inside"))
+ else if (scm_is_eq (info.type_, ly_symbol2scm ("inside")))
dist = state.dir_ * (y - info.extents_[Y_AXIS][state.dir_]);
else
programming_error ("unknown avoidance type");
end_ys[RIGHT],
end_ys[LEFT]);
Real encompass_place = extra_encompass_infos_[i].extents_[Y_AXIS][dir_];
- if (extra_encompass_infos_[i].type_ == ly_symbol2scm ("inside")
+ if (scm_is_eq (extra_encompass_infos_[i].type_,
+ ly_symbol2scm ("inside"))
&& minmax (dir_, encompass_place, y_place) == encompass_place
&& (!extra_encompass_infos_[i].grob_->internal_has_interface (ly_symbol2scm ("key-signature-interface"))
&& !Clef::has_interface (extra_encompass_infos_[i].grob_)
z[Y_AXIS] += dir_ * parameters_.free_slur_distance_;
avoid.push_back (z);
}
- else if (extra_encompasses[i]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
+ else if (scm_is_eq (extra_encompasses[i]->get_property ("avoid-slur"),
+ ly_symbol2scm ("inside")))
{
Grob *g = extra_encompasses [i];
Interval xe = g->extent (common_[X_AXIS], X_AXIS);
/* if we encompass a separation-item that spans multiple staves,
we filter out the grobs that don't belong to our staff */
if (me->common_refpoint (breakables[j], Y_AXIS) == me->get_parent (Y_AXIS)
- && breakables[j]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
+ && scm_is_eq (breakables[j]->get_property ("avoid-slur"),
+ ly_symbol2scm ("inside")))
new_encompasses.push_back (breakables[j]);
}
else
return offset_scm;
SCM avoid = script->get_property ("avoid-slur");
- if (avoid != ly_symbol2scm ("outside") && avoid != ly_symbol2scm ("around"))
+ if (!scm_is_eq (avoid, ly_symbol2scm ("outside"))
+ && !scm_is_eq (avoid, ly_symbol2scm ("around")))
return offset_scm;
Real offset = robust_scm2double (offset_scm, 0.0);
return offset_scm;
SCM avoid = script->get_property ("avoid-slur");
- if (avoid != ly_symbol2scm ("outside")
- && avoid != ly_symbol2scm ("around"))
+ if (!scm_is_eq (avoid, ly_symbol2scm ("outside"))
+ && !scm_is_eq (avoid, ly_symbol2scm ("around")))
return offset_scm;
Direction dir = get_grob_direction (script);
Interval exts[] = {xext, yext};
bool do_shift = false;
Real EPS = 1.0e-5;
- if (avoid == ly_symbol2scm ("outside"))
+ if (scm_is_eq (avoid, ly_symbol2scm ("outside")))
{
for (LEFT_and_RIGHT (d))
{
slur = slurs[0];
if (Tie::has_interface (e)
- || avoid == ly_symbol2scm ("inside"))
+ || scm_is_eq (avoid, ly_symbol2scm ("inside")))
{
for (vsize i = slurs.size (); i--;)
add_extra_encompass (slurs[i], e);
if (slur)
e->set_object ("slur", slur->self_scm ());
}
- else if (avoid == ly_symbol2scm ("outside")
- || avoid == ly_symbol2scm ("around"))
+ else if (scm_is_eq (avoid, ly_symbol2scm ("outside"))
+ || scm_is_eq (avoid, ly_symbol2scm ("around")))
{
if (slur)
{
e->set_object ("slur", slur->self_scm ());
}
}
- else if (avoid != ly_symbol2scm ("ignore"))
+ else if (!scm_is_eq (avoid, ly_symbol2scm ("ignore")))
e->warning (_f ("Ignoring grob for slur: %s. avoid-slur not set?",
e->name ().c_str ()));
}
SCM
Slur::outside_slur_cross_staff (SCM smob, SCM previous)
{
- if (previous == SCM_BOOL_T)
+ if (to_boolean (previous))
return previous;
Grob *me = Grob::unsmob (smob);
{
#if 0
SCM s = scm_cdr (smob_protection_list);
- while (scm_is_pair (s) && scm_car (s) == SCM_BOOL_F)
+ while (scm_is_pair (s) && scm_is_false (scm_car (s))
{
s = scm_cdr (s);
}
#else
SCM next = scm_cdr (*prot_cons);
- if (next == SCM_EOL)
+ if (scm_is_null (next)))
scm_set_car_x (*prot_cons, SCM_BOOL_F);
else
{
scm_set_car_x (*prot_cons, SCM_BOOL_F);
while (scm_is_pair (next)
- && scm_car (next) == SCM_BOOL_F)
+ && scm_is_false (scm_car (next)))
next = scm_cdr (next);
for (SCM s = mins; scm_is_pair (s); s = scm_cdr (s))
{
SCM dist = scm_car (s);
- if (scm_car (dist) == p->self_scm ())
+ if (scm_is_eq (scm_car (dist), p->self_scm ()))
{
scm_set_cdr_x (dist, scm_max (scm_cdr (dist),
newdist));
{
Grob *h = gelts[j];
- if (h && h->get_property ("break-align-symbol") == ly_symbol2scm ("staff-bar"))
+ if (h && scm_is_eq (h->get_property ("break-align-symbol"),
+ ly_symbol2scm ("staff-bar")))
{
extract_grob_set (h, "elements", helts);
for (vsize k = helts.size (); k--;)
// The pure property cache is indexed by (name start . end), where name is
// a symbol, and start and end are numbers referring to the starting and
// ending column ranks of the current line.
- if (scm_hash_table_p (pure_property_cache_) == SCM_BOOL_F)
+ if (scm_is_false (scm_hash_table_p (pure_property_cache_)))
return SCM_UNDEFINED;
SCM key = scm_cons (sym, scm_cons (scm_from_int (start), scm_from_int (end)));
void
Spanner::cache_pure_property (SCM sym, int start, int end, SCM val)
{
- if (scm_hash_table_p (pure_property_cache_) == SCM_BOOL_F)
+ if (scm_is_false (scm_hash_table_p (pure_property_cache_)))
pure_property_cache_ = scm_c_make_hash_table (17);
SCM key = scm_cons (sym, scm_cons (scm_from_int (start), scm_from_int (end)));
Staff_performer::get_audio_staff (const string &voice)
{
SCM channel_mapping = get_property ("midiChannelMapping");
- if (channel_mapping != ly_symbol2scm ("instrument")
+ if (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument"))
&& staff_map_.size ())
return staff_map_.begin ()->second;
audio_staff->add_audio_item (instrument_);
SCM proc = ly_lily_module_constant ("percussion?");
SCM drums = scm_call_1 (proc, ly_symbol2scm (instrument_string_.c_str ()));
- audio_staff->percussion_ = (drums == SCM_BOOL_T);
+ audio_staff->percussion_ = to_boolean (drums);
}
void
{
SCM channel_mapping = get_property ("midiChannelMapping");
map<string, int> &channel_map
- = (channel_mapping != ly_symbol2scm ("instrument"))
+ = (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument")))
? channel_map_
: static_channel_map_;
- if (channel_mapping == ly_symbol2scm ("staff")
+ if (scm_is_eq (channel_mapping, ly_symbol2scm ("staff"))
&& channel_ >= 0)
return channel_;
if (i != channel_map.end ())
return i->second;
- int channel = (channel_mapping == ly_symbol2scm ("staff"))
+ int channel = (scm_is_eq (channel_mapping, ly_symbol2scm ("staff")))
? channel_count_++
: channel_map.size ();
voice = c->id_string ();
SCM channel_mapping = get_property ("midiChannelMapping");
string str = new_instrument_string ();
- if (channel_mapping != ly_symbol2scm ("instrument"))
+ if (!scm_is_eq (channel_mapping, ly_symbol2scm ("instrument")))
channel_ = get_channel (voice);
else if (channel_ < 0 && str.empty ())
channel_ = get_channel (str);
if (str.length ())
{
- if (channel_mapping != ly_symbol2scm ("voice"))
+ if (!scm_is_eq (channel_mapping, ly_symbol2scm ("voice")))
channel_ = get_channel (str);
set_instrument (channel_, voice);
set_instrument_name (voice);
Real fixed = last_ext[RIGHT];
Real ideal = fixed + 1.0;
- if (type == ly_symbol2scm ("fixed-space"))
+ if (scm_is_eq (type, ly_symbol2scm ("fixed-space")))
{
fixed += distance;
ideal = fixed;
}
- else if (type == ly_symbol2scm ("extra-space"))
+ else if (scm_is_eq (type, ly_symbol2scm ("extra-space")))
ideal = fixed + distance;
- else if (type == ly_symbol2scm ("semi-fixed-space"))
+ else if (scm_is_eq (type, ly_symbol2scm ("semi-fixed-space")))
{
fixed += distance / 2;
ideal = fixed + distance / 2;
}
- else if (type == ly_symbol2scm ("minimum-space"))
+ else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
ideal = last_ext[LEFT] + max (last_ext.length (), distance);
- else if (type == ly_symbol2scm ("minimum-fixed-space"))
+ else if (scm_is_eq (type, ly_symbol2scm ("minimum-fixed-space")))
{
fixed = last_ext[LEFT] + max (last_ext.length (), distance);
ideal = fixed;
thick *= ss;
Stencil a;
- if (style == ly_symbol2scm ("rectangle"))
+ if (scm_is_eq (style, ly_symbol2scm ("rectangle")))
a = Lookup::rotated_box (slope, width, thick, blot);
else
a = Lookup::beam (slope, width, thick, blot);
bool is_harmonic_centered = false;
for (vsize i = 0; i < heads.size (); i++)
is_harmonic_centered = is_harmonic_centered
- || heads[i]->get_property ("style") == ly_symbol2scm ("harmonic");
+ || scm_is_eq (heads[i]->get_property ("style"),
+ ly_symbol2scm ("harmonic"));
is_harmonic_centered = is_harmonic_centered && is_invisible (me);
Real w = hed->extent (hed, X_AXIS)[dir];
bool
is_stencil_head (SCM symbol)
{
- return scm_object_property (symbol, ly_symbol2scm ("stencil-head?"))
- == SCM_BOOL_T;
+ return to_boolean (scm_object_property (symbol, ly_symbol2scm ("stencil-head?")));
}
SCM
if (scm_is_number (scm_car (l)))
return l;
SCM res = get_number_list (scm_car (l));
- if (res == SCM_BOOL_F)
+ if (scm_is_false (res))
return get_number_list (scm_cdr (l));
return res;
}
{
if (scm_is_pair (l))
{
- if (scm_memv (scm_car (l),
- scm_list_n (ly_symbol2scm ("moveto"),
- ly_symbol2scm ("rmoveto"),
- ly_symbol2scm ("lineto"),
- ly_symbol2scm ("rlineto"),
- ly_symbol2scm ("curveto"),
- ly_symbol2scm ("rcurveto"),
- ly_symbol2scm ("closepath"),
- SCM_UNDEFINED))
- != SCM_BOOL_F)
+ if (scm_is_true (scm_memv (scm_car (l),
+ scm_list_n (ly_symbol2scm ("moveto"),
+ ly_symbol2scm ("rmoveto"),
+ ly_symbol2scm ("lineto"),
+ ly_symbol2scm ("rlineto"),
+ ly_symbol2scm ("curveto"),
+ ly_symbol2scm ("rcurveto"),
+ ly_symbol2scm ("closepath"),
+ SCM_UNDEFINED))))
return l;
SCM res = get_path_list (scm_car (l));
- if (res == SCM_BOOL_F)
+ if (scm_is_false (res))
return get_path_list (scm_cdr (l));
return res;
}
bool first = true;
while (scm_is_pair (expr))
{
- if (scm_car (expr) == ly_symbol2scm ("moveto")
- || (scm_car (expr) == ly_symbol2scm ("rmoveto") && first))
+ if (scm_is_eq (scm_car (expr), ly_symbol2scm ("moveto"))
+ || (scm_is_eq (scm_car (expr), ly_symbol2scm ("rmoveto")) && first))
{
Real x = robust_scm2double (scm_cadr (expr), 0.0);
Real y = robust_scm2double (scm_caddr (expr), 0.0);
current = start;
expr = scm_cdddr (expr);
}
- if (scm_car (expr) == ly_symbol2scm ("rmoveto"))
+ if (scm_is_eq (scm_car (expr), ly_symbol2scm ("rmoveto")))
{
Real x = robust_scm2double (scm_cadr (expr), 0.0);
Real y = robust_scm2double (scm_caddr (expr), 0.0);
current = start;
expr = scm_cdddr (expr);
}
- else if (scm_car (expr) == ly_symbol2scm ("lineto"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("lineto")))
{
Real x = robust_scm2double (scm_cadr (expr), 0.0);
Real y = robust_scm2double (scm_caddr (expr), 0.0);
current = Offset (x, y);
expr = scm_cdddr (expr);
}
- else if (scm_car (expr) == ly_symbol2scm ("rlineto"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("rlineto")))
{
Real x = robust_scm2double (scm_cadr (expr), 0.0);
Real y = robust_scm2double (scm_caddr (expr), 0.0);
current = (Offset (x, y) + current);
expr = scm_cdddr (expr);
}
- else if (scm_car (expr) == ly_symbol2scm ("curveto"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("curveto")))
{
Real x1 = robust_scm2double (scm_cadr (expr), 0.0);
expr = scm_cddr (expr);
out);
current = Offset (x3, y3);
}
- else if (scm_car (expr) == ly_symbol2scm ("rcurveto"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("rcurveto")))
{
Real x1 = robust_scm2double (scm_cadr (expr), 0.0);
expr = scm_cddr (expr);
out);
current = (Offset (x3, y3) + current);
}
- else if (scm_car (expr) == ly_symbol2scm ("closepath"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("closepath")))
{
if ((current[X_AXIS] != start[X_AXIS]) || (current[Y_AXIS] != start[Y_AXIS]))
{
{
if (not scm_is_pair (expr))
return;
- if (scm_car (expr) == ly_symbol2scm ("draw-line"))
+ if (scm_is_eq (scm_car (expr), ly_symbol2scm ("draw-line")))
make_draw_line_boxes (boxes, buildings, trans, scm_cdr (expr), true);
- else if (scm_car (expr) == ly_symbol2scm ("dashed-line"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("dashed-line")))
{
expr = scm_cdr (expr);
SCM th = scm_car (expr);
SCM x2 = scm_car (expr);
make_draw_line_boxes (boxes, buildings, trans, scm_list_5 (th, scm_from_double (0.0), scm_from_double (0.0), x1, x2), true);
}
- else if (scm_car (expr) == ly_symbol2scm ("circle"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("circle")))
{
expr = scm_cdr (expr);
SCM rad = scm_car (expr);
SCM_BOOL_T,
SCM_UNDEFINED));
}
- else if (scm_car (expr) == ly_symbol2scm ("ellipse"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("ellipse")))
{
expr = scm_cdr (expr);
SCM x_rad = scm_car (expr);
SCM_BOOL_T,
SCM_UNDEFINED));
}
- else if (scm_car (expr) == ly_symbol2scm ("partial-ellipse"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("partial-ellipse")))
make_partial_ellipse_boxes (boxes, buildings, trans, scm_cdr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("round-filled-box"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("round-filled-box")))
make_round_filled_box_boxes (boxes, trans, scm_cdr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("named-glyph"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("named-glyph")))
make_named_glyph_boxes (boxes, buildings, trans, scm_cdr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("polygon"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("polygon")))
make_polygon_boxes (boxes, buildings, trans, scm_cdr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("path"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("path")))
make_path_boxes (boxes, buildings, trans, scm_cdr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("glyph-string"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("glyph-string")))
make_glyph_string_boxes (boxes, buildings, trans, scm_cdr (expr));
else
{
{
if (scm_is_null (expr))
return vector<Transform_matrix_and_expression> ();
- else if (expr == ly_string2scm (""))
+ else if (scm_is_eq (expr, ly_string2scm ("")))
return vector<Transform_matrix_and_expression> ();
- else if (scm_car (expr) == ly_symbol2scm ("combine-stencil"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("combine-stencil")))
{
vector<Transform_matrix_and_expression> out;
for (SCM s = scm_cdr (expr); scm_is_pair (s); s = scm_cdr (s))
}
return out;
}
- else if (scm_car (expr) == ly_symbol2scm ("footnote"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("footnote")))
return vector<Transform_matrix_and_expression> ();
- else if (scm_car (expr) == ly_symbol2scm ("translate-stencil"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("translate-stencil")))
{
Real x = robust_scm2double (scm_caadr (expr), 0.0);
Real y = robust_scm2double (scm_cdadr (expr), 0.0);
pango_matrix_translate (&trans, x, y);
return stencil_traverser (trans, scm_caddr (expr));
}
- else if (scm_car (expr) == ly_symbol2scm ("scale-stencil"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("scale-stencil")))
{
Real x = robust_scm2double (scm_caadr (expr), 0.0);
Real y = robust_scm2double (scm_cadadr (expr), 0.0);
pango_matrix_scale (&trans, x, y);
return stencil_traverser (trans, scm_caddr (expr));
}
- else if (scm_car (expr) == ly_symbol2scm ("rotate-stencil"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("rotate-stencil")))
{
Real ang = robust_scm2double (scm_caadr (expr), 0.0);
Real x = robust_scm2double (scm_car (scm_cadadr (expr)), 0.0);
pango_matrix_translate (&trans, -x, -y);
return stencil_traverser (trans, scm_caddr (expr));
}
- else if (scm_car (expr) == ly_symbol2scm ("delay-stencil-evaluation"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("delay-stencil-evaluation")))
// should not use the place-holder text, but no need for the warning below
return vector<Transform_matrix_and_expression> ();
- else if (scm_car (expr) == ly_symbol2scm ("grob-cause"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("grob-cause")))
return stencil_traverser (trans, scm_caddr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("color"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("color")))
return stencil_traverser (trans, scm_caddr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("transparent-stencil"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("transparent-stencil")))
return stencil_traverser (trans, scm_cadr (expr));
- else if (scm_car (expr) == ly_symbol2scm ("id"))
+ else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("id")))
return stencil_traverser (trans, scm_caddr (expr));
else
{
SCM head = scm_car (expr);
- if (head == ly_symbol2scm ("delay-stencil-evaluation"))
+ if (scm_is_eq (head, ly_symbol2scm ("delay-stencil-evaluation")))
{
interpret_stencil_expression (scm_force (scm_cadr (expr)), func, func_arg, o);
return;
}
- if (head == ly_symbol2scm ("transparent-stencil"))
+ if (scm_is_eq (head, ly_symbol2scm ("transparent-stencil")))
return;
- if (head == ly_symbol2scm ("footnote"))
+ if (scm_is_eq (head, ly_symbol2scm ("footnote")))
return;
- if (head == ly_symbol2scm ("translate-stencil"))
+ if (scm_is_eq (head, ly_symbol2scm ("translate-stencil")))
{
o += ly_scm2offset (scm_cadr (expr));
expr = scm_caddr (expr);
}
- else if (head == ly_symbol2scm ("combine-stencil"))
+ else if (scm_is_eq (head, ly_symbol2scm ("combine-stencil")))
{
for (SCM x = scm_cdr (expr); scm_is_pair (x); x = scm_cdr (x))
interpret_stencil_expression (scm_car (x), func, func_arg, o);
return;
}
- else if (head == ly_symbol2scm ("grob-cause"))
+ else if (scm_is_eq (head, ly_symbol2scm ("grob-cause")))
{
SCM grob = scm_cadr (expr);
(*func) (func_arg, scm_list_1 (ly_symbol2scm ("no-origin")));
return;
}
- else if (head == ly_symbol2scm ("color"))
+ else if (scm_is_eq (head, ly_symbol2scm ("color")))
{
SCM color = scm_cadr (expr);
SCM r = scm_car (color);
return;
}
- else if (head == ly_symbol2scm ("id"))
+ else if (scm_is_eq (head, ly_symbol2scm ("id")))
{
SCM id = scm_cadr (expr);
return;
}
- else if (head == ly_symbol2scm ("rotate-stencil"))
+ else if (scm_is_eq (head, ly_symbol2scm ("rotate-stencil")))
{
SCM args = scm_cadr (expr);
SCM angle = scm_car (args);
return;
}
- else if (head == ly_symbol2scm ("scale-stencil"))
+ else if (scm_is_eq (head, ly_symbol2scm ("scale-stencil")))
{
SCM args = scm_cadr (expr);
SCM x_scale = scm_car (args);
{
Font_list *me = (Font_list *) fs;
- if (scm_car (x) == ly_symbol2scm ("placebox"))
+ if (scm_is_eq (scm_car (x), ly_symbol2scm ("placebox")))
{
SCM args = scm_cdr (x);
SCM what = scm_caddr (args);
if (scm_is_pair (what))
{
SCM head = scm_car (what);
- if (ly_symbol2scm ("text") == head)
+ if (scm_is_eq (head, ly_symbol2scm ("text")))
me->fonts_ = scm_cons (scm_cadr (what), me->fonts_);
- else if (head == ly_symbol2scm ("char"))
+ else if (scm_is_eq (head, ly_symbol2scm ("char")))
me->fonts_ = scm_cons (scm_cadr (what), me->fonts_);
}
}
Stencil *s2 = Stencil::unsmob (second);
Stencil result;
- SCM_ASSERT_TYPE (s1 || first == SCM_BOOL_F || first == SCM_EOL,
+ SCM_ASSERT_TYPE (s1 || scm_is_false (first) || scm_is_null (first),
first, SCM_ARG1, __FUNCTION__, "Stencil, #f or ()");
- SCM_ASSERT_TYPE (s2 || second == SCM_BOOL_F || second == SCM_EOL,
+ SCM_ASSERT_TYPE (s2 || scm_is_false (second) || scm_is_null (second),
second, SCM_ARG4, __FUNCTION__, "Stencil, #f or ()");
LY_ASSERT_TYPE (is_axis, axis, 2);
LY_ASSERT_TYPE (is_direction, direction, 3);
Real p = 0.0;
- if (padding != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (padding))
{
LY_ASSERT_TYPE (scm_is_number, padding, 5);
p = scm_to_double (padding);
Stencil *s2 = Stencil::unsmob (second);
Stencil result;
- SCM_ASSERT_TYPE (s1 || first == SCM_BOOL_F || first == SCM_EOL,
+ SCM_ASSERT_TYPE (s1 || scm_is_false (first) || scm_is_null (first),
first, SCM_ARG1, __FUNCTION__, "Stencil, #f or ()");
- SCM_ASSERT_TYPE (s2 || second == SCM_BOOL_F || second == SCM_EOL,
+ SCM_ASSERT_TYPE (s2 || scm_is_false (second) || scm_is_null (second),
second, SCM_ARG4, __FUNCTION__, "Stencil, #f or ()");
LY_ASSERT_TYPE (is_axis, axis, 2);
LY_ASSERT_TYPE (is_direction, direction, 3);
Real p = 0.0;
- if (padding != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (padding))
{
LY_ASSERT_TYPE (scm_is_number, padding, 5);
p = scm_to_double (padding);
expr, SCM_ARG1, __FUNCTION__, "registered stencil expression");
Interval x;
- if (xext != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (xext))
{
LY_ASSERT_TYPE (is_number_pair, xext, 2);
x = ly_scm2interval (xext);
}
Interval y;
- if (yext != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (yext))
{
LY_ASSERT_TYPE (is_number_pair, yext, 3);
y = ly_scm2interval (yext);
bool
Stencil::is_empty () const
{
- return (expr_ == SCM_EOL
+ return (scm_is_null (expr_)
|| dim_.is_empty ());
}
/* should be scm_list_p, but scm_list_p is expensive. */
LY_ASSERT_TYPE (scm_is_pair, proplist, 2);
- if (proplist == SCM_UNDEFINED)
+ if (SCM_UNBNDP (proplist))
proplist = SCM_EOL;
Stream_event *e = new Stream_event (cl, proplist);
Stream_event::internal_in_event_class (SCM class_name)
{
SCM cl = get_property ("class");
- return scm_c_memq (class_name, cl) != SCM_BOOL_F;
+ return scm_is_true (scm_c_memq (class_name, cl));
}
MAKE_SCHEME_CALLBACK (Stream_event, undump, 1);
SCM val = scm_cdr (entry);
if ((Pitch::is_smob (val)
- || (prop == ly_symbol2scm ("element") && Music::is_smob (val))
- || (prop == ly_symbol2scm ("elements") && scm_is_pair (val))
- || (prop == ly_symbol2scm ("pitch-alist") && scm_is_pair (val)))
+ || (scm_is_eq (prop, ly_symbol2scm ("element")) && Music::is_smob (val))
+ || (scm_is_eq (prop, ly_symbol2scm ("elements")) && scm_is_pair (val))
+ || (scm_is_eq (prop, ly_symbol2scm ("pitch-alist")) && scm_is_pair (val)))
&& scm_is_false (scm_assq (prop, mutable_property_alist_)))
mutable_property_alist_
= scm_acons (prop, ly_music_deep_copy (val), mutable_property_alist_);
node->from_list (entry);
children_.push_back (node);
}
- else if (entry == ly_symbol2scm ("SystemStartBrace")
- || entry == ly_symbol2scm ("SystemStartBracket")
- || entry == ly_symbol2scm ("SystemStartBar")
- || entry == ly_symbol2scm ("SystemStartSquare"))
+ else if (scm_is_eq (entry, ly_symbol2scm ("SystemStartBrace"))
+ || scm_is_eq (entry, ly_symbol2scm ("SystemStartBracket"))
+ || scm_is_eq (entry, ly_symbol2scm ("SystemStartBar"))
+ || scm_is_eq (entry, ly_symbol2scm ("SystemStartSquare")))
symbol_ = entry;
else
children_.push_back (new Bracket_nesting_staff (0));
}
Stencil m;
- if (glyph_sym == ly_symbol2scm ("bracket"))
+ if (scm_is_eq (glyph_sym, ly_symbol2scm ("bracket")))
m = staff_bracket (me, len);
- else if (glyph_sym == ly_symbol2scm ("brace"))
+ else if (scm_is_eq (glyph_sym, ly_symbol2scm ("brace")))
m = staff_brace (me, len);
- else if (glyph_sym == ly_symbol2scm ("bar-line"))
+ else if (scm_is_eq (glyph_sym, ly_symbol2scm ("bar-line")))
m = simple_bar (me, len);
- else if (glyph_sym == ly_symbol2scm ("line-bracket"))
+ else if (scm_is_eq (glyph_sym, ly_symbol2scm ("line-bracket")))
m = line_bracket (me, len);
m.translate_axis (ext.center (), Y_AXIS);
Grob *g = entries[j].grob_;
Stencil st = g->get_print_stencil ();
- if (st.expr () == SCM_EOL)
+ if (scm_is_null (st.expr ()))
continue;
Offset o;
bool length_changed = (note_events_.size () != fret_count);
vsize index;
- if (string_fret_finger != SCM_EOL)
+ if (!scm_is_null (string_fret_finger))
for (vsize i = 0; i < fret_count; i++)
{
note_entry = scm_list_ref (string_fret_finger, scm_from_int (i));
string_number = scm_car (note_entry);
- if (string_number != SCM_BOOL_F)
+ if (scm_is_true (string_number))
{
fret = scm_cadr (note_entry);
fret_label = scm_call_3 (fret_procedure,
SCM_BOOL_F);
SCM music_encodings = ly_lily_module_constant ("all-music-font-encodings");
- bool is_music = (scm_memq (encoding, music_encodings) != SCM_BOOL_F);
+ bool is_music = scm_is_true (scm_memq (encoding, music_encodings));
return fm->text_stencil (layout, str, is_music).smobbed_copy ();
}
{
spec.has_manual_position_ = true;
spec.manual_position_ = scm_to_double (scm_car (entry));
- spec.has_manual_delta_y_ = (scm_inexact_p (scm_car (entry)) == SCM_BOOL_T);
+ /* TODO: check whether inexact? is an appropriate condition here */
+ spec.has_manual_delta_y_ = (scm_is_true (scm_inexact_p (scm_car (entry))));
}
if (scm_is_number (scm_cdr (entry)))
SCM pos_scm = tie->get_property ("staff-position");
if (scm_is_number (pos_scm))
{
- has_manual_delta_y_ = (scm_inexact_p (pos_scm) == SCM_BOOL_T);
+ has_manual_delta_y_ = !ly_is_rational (pos_scm);
manual_position_ = scm_to_double (tie->get_property ("staff-position"));
has_manual_position_ = true;
}
time_signature_ = make_item ("TimeSignature", time_cause_);
time_signature_->set_property ("fraction", fr);
- if (last_time_fraction_ == SCM_BOOL_F)
+ if (scm_is_false (last_time_fraction_))
time_signature_->set_property ("break-visibility",
get_property ("initialTimeSignatureVisibility"));
void
Time_signature_engraver::stop_translation_timestep ()
{
- if (time_signature_ && (time_cause_ != SCM_EOL))
+ if (time_signature_ && !scm_is_null (time_cause_))
{
Moment *mp = Moment::unsmob (get_property ("measurePosition"));
if (mp && (mp->main_part_ > Rational (0))
if (global_translator_dict)
global_translator_dict->try_retrieve (sym, &v);
- if (v == SCM_BOOL_F)
+ if (scm_is_false (v))
{
warning (_f ("unknown translator: `%s'", ly_symbol2string (sym).c_str ()));
return 0;
Translator_group *
get_translator_group (SCM sym)
{
- if (sym == ly_symbol2scm ("Engraver_group"))
+ if (scm_is_eq (sym, ly_symbol2scm ("Engraver_group")))
return new Engraver_group ();
- else if (sym == ly_symbol2scm ("Performer_group"))
+ else if (scm_is_eq (sym, ly_symbol2scm ("Performer_group")))
return new Performer_group ();
- else if (sym == ly_symbol2scm ("Score_engraver"))
+ else if (scm_is_eq (sym, ly_symbol2scm ("Score_engraver")))
return new Score_engraver ();
- else if (sym == ly_symbol2scm ("Score_performer"))
+ else if (scm_is_eq (sym, ly_symbol2scm ("Score_performer")))
return new Score_performer ();
error (_f ("fatal error. Couldn't find type: %s",
LY_ASSERT_TYPE (scm_is_string, ttf_file_name, 1);
int i = 0;
- if (idx != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (idx))
{
LY_ASSERT_TYPE (scm_is_integer, idx, 2);
i = scm_to_int (idx);
LY_ASSERT_TYPE (scm_is_string, ttf_file_name, 1);
int i = 0;
- if (idx != SCM_UNDEFINED)
+ if (!SCM_UNBNDP (idx))
{
LY_ASSERT_TYPE (scm_is_integer, idx, 2);
i = scm_to_int (idx);
*/
SCM bracket_vis_prop = me->get_property ("bracket-visibility");
bool bracket_prop = ly_scm2bool (bracket_vis_prop); // Flag, user has set bracket-visibility prop.
- bool bracket = (bracket_vis_prop == ly_symbol2scm ("if-no-beam"));
+ bool bracket = scm_is_eq (bracket_vis_prop, ly_symbol2scm ("if-no-beam"));
if (scm_is_bool (bracket_vis_prop))
bracket_visibility = bracket_prop;
else if (bracket)
for (SCM s = scm_car (beaming); scm_is_pair (s); s = scm_cdr (s))
{
- if (scm_c_memq (scm_car (s), scm_cdr (beaming)) != SCM_BOOL_F)
+ if (scm_is_true (scm_c_memq (scm_car (s), scm_cdr (beaming))))
++count;
}
*/
SCM glyph_name_scm = primitive->get_property ("glyph-name");
- if (glyph_name_scm == SCM_EOL)
+ if (scm_is_null (glyph_name_scm))
{
primitive->programming_error ("Vaticana_ligature:"
" undefined glyph-name ->"
if (prev_primitive) /* urgh, need prev_primitive only here */
{
SCM delta_pitch_scm = prev_primitive->get_property ("delta-position");
- if (delta_pitch_scm != SCM_EOL)
+ if (!scm_is_null (delta_pitch_scm))
delta_pitch = scm_to_int (delta_pitch_scm);
else
{
int delta_pitch;
SCM delta_pitch_scm = primitive->get_property ("delta-position");
- if (delta_pitch_scm != SCM_EOL)
+ if (!scm_is_null (delta_pitch_scm))
delta_pitch = scm_to_int (delta_pitch_scm);
else
{
Real interval;
SCM flexa_height_scm = me->get_property ("flexa-height");
- if (flexa_height_scm != SCM_EOL)
+ if (!scm_is_null (flexa_height_scm))
interval = scm_to_int (flexa_height_scm);
else
{
vaticana_brew_primitive (Grob *me)
{
SCM glyph_name_scm = me->get_property ("glyph-name");
- if (glyph_name_scm == SCM_EOL)
+ if (scm_is_null (glyph_name_scm))
{
me->programming_error ("Vaticana_ligature: "
"undefined glyph-name -> ignoring grob");
SCM delta_pitch_scm = me->get_property ("delta-position");
int delta_pitch;
- if (delta_pitch_scm != SCM_EOL)
+ if (!scm_is_null (delta_pitch_scm))
delta_pitch = scm_to_int (delta_pitch_scm);
else
delta_pitch = 0;
SCM c = scm_car (cs);
if (scm_is_pair (c)
- && scm_car (c) == ly_symbol2scm ("volta")
+ && scm_is_eq (scm_car (c), ly_symbol2scm ("volta"))
&& scm_is_pair (scm_cdr (c)))
{
- if (scm_cadr (c) == SCM_BOOL_F)
+ if (scm_is_false (scm_cadr (c)))
end = true;
else
start_string_ = scm_cadr (c);
SCM current_reps = SCM_EOL;
Context *where = get_outlet ()->where_defined (reps, ¤t_reps);
- if (where
- && (current_reps == SCM_EOL || scm_is_pair (current_reps)))
+ if (where && ly_cheap_is_list (current_reps))
{
current_reps = scm_cons (what, current_reps);
where->set_property (reps, current_reps);
projects / lilypond.git / commitdiff