encoding.
* lily/include/lily-guile.hh: ly_XXX_p -> is_XXX. Changes throughout.
* scm/define-markup-commands.scm (encoded-simple): new markup command.
* lily/parser.yy (markup): take encoding from lexer.
2004-04-10 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ * lily/text-item.cc (interpret_string): new file, select font with
+ encoding.
+
+ * lily/include/lily-guile.hh: ly_XXX_p -> is_XXX. Changes throughout.
+
+ * scm/define-markup-commands.scm (encoded-simple): new markup command.
+
* lily/parser.yy (markup): take encoding from lexer.
2004-04-09 Jan Nieuwenhuizen <janneke@gnu.org>
- * lily/kpath.cc (kpathsea_find_tfm): Do not trigger TMF generation.
+ * lily/kpath.cc (kpathsea_find_tfm): Do not trigger TFM generation.
* scm/output-ps.scm: Remove some cruft.
set_property_on_children (Context * trans, const char * sym, SCM val)
{
trans->set_property (sym, val);
- for (SCM p = trans->context_list_; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = trans->context_list_; is_pair (p); p = ly_cdr (p))
{
Context *trg = unsmob_context (ly_car (p));
set_property_on_children (trg, sym, ly_deep_copy (val));
prev = scm_assoc (scm_cons (scm_int2num (o), scm_int2num (n)), sig);
/* should really be true unless prev == SCM_BOOL_F */
- if (ly_pair_p (prev) && ly_pair_p (ly_cdr (prev)))
+ if (is_pair (prev) && is_pair (ly_cdr (prev)))
{
accbarnum_i = ly_scm2int (ly_cddr (prev));
prev = scm_cons (ly_car (prev), ly_cadr (prev));
/* If an accidental was not found or the accidental was too old */
if (prev == SCM_BOOL_F ||
- (ly_number_p (lazyness) && curbarnum_i > accbarnum_i + ly_scm2int (lazyness)))
+ (is_number (lazyness) && curbarnum_i > accbarnum_i + ly_scm2int (lazyness)))
prev = scm_assoc (scm_int2num (n), sig);
SCM prev_acc = (prev == SCM_BOOL_F) ? scm_int2num (0) : ly_cdr (prev);
- int p = ly_number_p (prev_acc) ? ly_scm2int (prev_acc) : 0;
+ int p = is_number (prev_acc) ? ly_scm2int (prev_acc) : 0;
int num;
- if (a == p && ly_number_p (prev_acc))
+ if (a == p && is_number (prev_acc))
num = 0;
else if ( (abs (a)<abs (p) || p*a<0) && a != 0 )
num = 2;
int number = 0;
*different = false;
- if (ly_pair_p (accidentals) && !ly_symbol_p (ly_car (accidentals)))
+ if (is_pair (accidentals) && !is_symbol (ly_car (accidentals)))
warning (_f ("Accidental typesetting list must begin with context-name: %s",
ly_scm2string (ly_car (accidentals)).to_str0 ()));
- for (; ly_pair_p (accidentals) && origin; accidentals = ly_cdr (accidentals))
+ for (; is_pair (accidentals) && origin; accidentals = ly_cdr (accidentals))
{
// If pair then it is a new accidentals typesetting rule to be checked
SCM rule = ly_car (accidentals);
- if (ly_pair_p (rule))
+ if (is_pair (rule))
{
SCM type = ly_car (rule);
SCM lazyness = ly_cdr (rule);
SCM localsig = origin->get_property ("localKeySignature");
bool same_octave_b =
- ly_eq_p (ly_symbol2scm ("same-octave"), type);
+ is_eq (ly_symbol2scm ("same-octave"), type);
bool any_octave_b =
- ly_eq_p (ly_symbol2scm ("any-octave"), type);
+ is_eq (ly_symbol2scm ("any-octave"), type);
if (same_octave_b || any_octave_b)
{
/*
if symbol then it is a context name. Scan parent contexts to find it.
*/
- else if (ly_symbol_p (rule))
+ else if (is_symbol (rule))
{
Context * dad = origin;
while (dad && !dad->is_alias (rule))
Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
if (mp.main_part_ < Rational (0)
- && ly_number_p (barnum))
+ && is_number (barnum))
barnum = scm_int2num (ly_scm2int (barnum) - 1);
return barnum ;
&& Rhythmic_head::has_interface (info.grob_))
{
if (to_boolean ( get_property ("harmonicAccidentals"))
- || !ly_equal_p (info.grob_->get_property ("style"),
+ || !is_equal (info.grob_->get_property ("style"),
ly_symbol2scm ("harmonic")))
{
Link_array<Grob> *break_reminder,
Link_array<Grob> *real_acc)
{
- for (SCM acs =accs->get_property ("accidental-grobs"); ly_pair_p (acs);
+ for (SCM acs =accs->get_property ("accidental-grobs"); is_pair (acs);
acs =ly_cdr (acs))
- for (SCM s = ly_cdar (acs); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = ly_cdar (acs); is_pair (s); s = ly_cdr (s))
{
Grob *a = unsmob_grob (ly_car (s));
Y-position, they share an Ape, and will be printed in overstrike.
*/
Link_array<Accidental_placement_entry> apes;
- for (SCM s = accs; ly_pair_p (s); s =ly_cdr (s))
+ for (SCM s = accs; is_pair (s); s =ly_cdr (s))
{
Accidental_placement_entry *ape = new Accidental_placement_entry;
ape->notename_ = ly_scm2int (ly_caar (s));
- for (SCM t = ly_cdar (s); ly_pair_p (t); t =ly_cdr (t))
+ for (SCM t = ly_cdar (s); is_pair (t); t =ly_cdr (t))
ape->grobs_.push (unsmob_grob (ly_car (t)));
apes.push (ape);
if (to_boolean (a->get_property ("cautionary")))
{
SCM cstyle = a->get_property ("cautionary-style");
- parens = ly_equal_p (cstyle, ly_symbol2scm ("parentheses"));
+ parens = is_equal (cstyle, ly_symbol2scm ("parentheses"));
}
SCM accs = a->get_property ("accidentals");
SCM scm_style = a->get_property ("style");
- if (!ly_symbol_p (scm_style)
+ if (!is_symbol (scm_style)
&& !parens
&& scm_ilength (accs) == 1)
{
if (caut)
{
SCM cstyle = me->get_property ("cautionary-style");
- parens = ly_equal_p (cstyle, ly_symbol2scm ("parentheses"));
- smaller = ly_equal_p (cstyle, ly_symbol2scm ("smaller"));
+ parens = is_equal (cstyle, ly_symbol2scm ("parentheses"));
+ smaller = is_equal (cstyle, ly_symbol2scm ("smaller"));
}
SCM scm_style = me->get_property ("style");
String style;
- if (ly_symbol_p (scm_style))
+ if (is_symbol (scm_style))
{
style = ly_symbol2string (scm_style);
}
Stencil mol;
for (SCM s = me->get_property ("accidentals");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
int alteration = ly_scm2int (ly_car (s));
String font_char = get_fontcharname (style, alteration);
SCM d = me->get_property ("stacking-dir");
- Direction stacking_dir = ly_number_p (d) ? to_dir (d) : CENTER;
+ Direction stacking_dir = is_number (d) ? to_dir (d) : CENTER;
if (!stacking_dir)
stacking_dir = DOWN;
SCM d = me->get_property ("stacking-dir");
- Direction stacking_dir = ly_number_p (d) ? to_dir (d) : CENTER;
+ Direction stacking_dir = is_number (d) ? to_dir (d) : CENTER;
if (!stacking_dir)
stacking_dir = DOWN;
FIXME: uncommenting freaks out the Y-alignment of
line-of-score.
*/
- if (ly_number_p (align))
+ if (is_number (align))
center_offset = total.linear_combination (ly_scm2double (align));
for (int j = 0 ; j < all_grobs.size (); j++)
{
while (g)
{
- if (ly_number_p (g->get_property ("forced-distance")))
+ if (is_number (g->get_property ("forced-distance")))
return g;
g = g->get_parent (Y_AXIS);
(SCM name),
"Load the font @var{name}. ")
{
- SCM_ASSERT_TYPE (ly_string_p (name), name, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (name), name, SCM_ARG1, __FUNCTION__, "string");
Font_metric * fm = all_fonts_global->find_font (ly_scm2string (name));
key_signature);
/* should really be true unless prev == SCM_BOOL_F */
- if (ly_pair_p (prev) && ly_pair_p (ly_cdr (prev)))
+ if (is_pair (prev) && is_pair (ly_cdr (prev)))
{
prev = scm_cons (ly_car (prev), ly_cadr (prev));
}
prev = scm_assoc (scm_int2num (notename), key_signature);
SCM prev_acc = (prev == SCM_BOOL_F) ? scm_int2num (0) : ly_cdr (prev);
- int sig_alteration = ly_number_p (prev_acc) ? ly_scm2int (prev_acc) : 0;
+ int sig_alteration = is_number (prev_acc) ? ly_scm2int (prev_acc) : 0;
if (alteration == sig_alteration) // no accidental at all needed
return 0;
SCM scm_note_head_style = me->get_property ("note-head-style");
String note_head_style;
- if (ly_symbol_p (scm_note_head_style))
+ if (is_symbol (scm_note_head_style))
{
String note_head_style =
ly_symbol2string (scm_note_head_style);
}
SCM c0 = me->get_property ("c0-position");
- if (ly_number_p (c0))
+ if (is_number (c0))
{
p_min += ly_scm2int (c0);
p_max += ly_scm2int (c0);
SCM key_signature = me->get_property ("key-signature");
SCM scm_accidentals_style = me->get_property ("accidentals-style");
String accidentals_style;
- if (ly_symbol_p (scm_accidentals_style))
+ if (is_symbol (scm_accidentals_style))
{
accidentals_style =
ly_symbol2string (scm_accidentals_style);
Grob *me = unsmob_grob (smob);
Grob * common = me;
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Grob * stem = unsmob_grob (ly_car (s));
common = common->common_refpoint (Staff_symbol_referencer::get_staff_symbol (stem),
Interval heads;
Real my_y = me->relative_coordinate (common, Y_AXIS);
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Grob * stem = unsmob_grob (ly_car (s));
Grob * ss = Staff_symbol_referencer::get_staff_symbol (stem);
Grob *me = unsmob_grob (smob);
Grob * common = me;
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Grob * stem = unsmob_grob (ly_car (s));
common = common->common_refpoint (Staff_symbol_referencer::get_staff_symbol (stem),
Interval heads;
Real my_y = me->relative_coordinate (common, Y_AXIS);
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Grob * stem = unsmob_grob (ly_car (s));
Grob * ss = Staff_symbol_referencer::get_staff_symbol (stem);
void
Auto_beam_engraver::process_music ()
{
- if (ly_string_p (get_property ("whichBar")))
+ if (is_string (get_property ("whichBar")))
{
consider_end (shortest_mom_);
junk_beam ();
Moment now = get_outlet ()->now_mom ();
Moment *splitm = 0;
- for (; ly_pair_p (split_list_); split_list_ = ly_cdr (split_list_))
+ for (; is_pair (split_list_); split_list_ = ly_cdr (split_list_))
{
splitm = unsmob_moment (ly_caar (split_list_));
if ((*splitm + start_moment_) > now)
Axis_group_interface::relative_group_extent (Axis a, Grob *common, SCM elts)
{
Interval r;
- for (SCM s = elts; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = elts; is_pair (s); s = ly_cdr (s))
{
Grob * se = unsmob_grob (ly_car (s));
Interval dims = se->extent (common, a);
SCM axes = me->get_property ("axes");
- if (!ly_pair_p (axes)
+ if (!is_pair (axes)
|| scm_c_memq (sa1, axes) == SCM_BOOL_F
|| scm_c_memq (sa2, axes) == SCM_BOOL_F)
{
if (!has_interface (me))
return childs;
- for (SCM ep = me->get_property ("elements"); ly_pair_p (ep); ep = ly_cdr (ep))
+ for (SCM ep = me->get_property ("elements"); is_pair (ep); ep = ly_cdr (ep))
{
Grob* e = unsmob_grob (ly_car (ep));
if (e)
SCM cb = me->get_property ("balloon-original-callback");
SCM scm_mol = SCM_EOL;
- if (ly_procedure_p (cb))
+ if (is_procedure (cb))
{
scm_mol = scm_call_1 (cb, smob);
}
void
Bar_engraver::process_acknowledged_grobs ()
{
- if (!bar_ && ly_string_p (get_property ("whichBar")))
+ if (!bar_ && is_string (get_property ("whichBar")))
{
create_bar ();
}
SCM s = me->get_property ("glyph");
SCM barsiz_proc = me->get_property ("bar-size-procedure");
- if (ly_string_p (s) && ly_procedure_p (barsiz_proc))
+ if (is_string (s) && is_procedure (barsiz_proc))
{
String str =ly_scm2string (s);
SCM siz = scm_call_1 (barsiz_proc, me->self_scm ());
SCM g = me->get_property ("glyph");
SCM orig = g;
Direction bsd = item->break_status_dir ();
- if (ly_string_p (g) && bsd)
+ if (is_string (g) && bsd)
{
SCM proc = me->get_property ("break-glyph-function");
g = scm_call_2 (proc, g, scm_int2num (bsd));
}
- if (!ly_string_p (g))
+ if (!is_string (g))
{
me->set_property ("print-function", SCM_EOL);
me->set_extent (SCM_EOL, X_AXIS);
// leave y_extent for spanbar?
}
- if (! ly_equal_p (g, orig))
+ if (! is_equal (g, orig))
me->set_property ("glyph", g);
return SCM_UNSPECIFIED;
Grob*me = unsmob_grob (smob);
Real ss = Staff_symbol_referencer::staff_space (me);
SCM size = me->get_property ("bar-size");
- if (ly_number_p (size))
+ if (is_number (size))
return scm_make_real (ly_scm2double (size)*ss);
else if (Staff_symbol_referencer::get_staff_symbol (me))
{
SCM wb = get_property ("whichBar");
- if (ly_string_p (wb))
+ if (is_string (wb))
{
SCM smp = get_property ("measurePosition");
{
SCM bn = get_property ("currentBarNumber");
SCM proc = get_property ("barNumberVisibility");
- if (ly_number_p (bn) && ly_procedure_p (proc)
+ if (is_number (bn) && is_procedure (proc)
&& to_boolean (scm_call_1(proc, bn)))
{
create_items ();
Real slt = Staff_symbol_referencer::line_thickness (me) / ss;
SCM sdy = me->get_property ("least-squares-dy");
- Real dy_mus = ly_number_p (sdy) ? ly_scm2double (sdy) : 0.0;
+ Real dy_mus = is_number (sdy) ? ly_scm2double (sdy) : 0.0;
Real straddle = 0.0;
Real sit = (thickness - slt) / 2;
#if DEBUG_QUANTING
SCM inspect_quants = me->get_property ("inspect-quants");
if (debug_beam_quanting_flag
- && ly_pair_p (inspect_quants))
+ && is_pair (inspect_quants))
{
Drul_array<Real> ins = ly_scm2interval (inspect_quants);
{
SCM func = me->get_property ("space-function");
- if (ly_procedure_p (func))
+ if (is_procedure (func))
{
SCM s = scm_call_2 (func, me->self_scm (), scm_int2num (get_beam_count (me)));
return ly_scm2double (s);
Beam::get_beam_count (Grob *me)
{
int m = 0;
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Grob *stem = unsmob_grob (ly_car (s));
m = m >? (Stem::beam_multiplicity (stem).length () + 1);
(i - lslice[left_dir])* left_dir <= 0 ; i+= left_dir)
{
int count =0;
- for ( SCM s = ly_car (right_beaming); ly_pair_p (s); s = ly_cdr (s))
+ for ( SCM s = ly_car (right_beaming); is_pair (s); s = ly_cdr (s))
{
int k = - right_dir * ly_scm2int (ly_car (s)) + i;
if (scm_c_memq (scm_int2num (k), left_beaming) != SCM_BOOL_F)
SCM this_beaming = this_stem->get_property ("beaming");
Direction this_dir = get_grob_direction (this_stem);
- if (ly_pair_p (last_beaming) && ly_pair_p (this_beaming))
+ if (is_pair (last_beaming) && is_pair (this_beaming))
{
int start_point = position_with_maximal_common_beams
(last_beaming, this_beaming,
new_slice.set_empty ();
SCM s = index_get_cell (this_beaming, d);
- for (; ly_pair_p (s); s = ly_cdr (s))
+ for (; is_pair (s); s = ly_cdr (s))
{
int new_beam_pos =
start_point - this_dir * ly_scm2int (ly_car (s));
{
scm_set_car_x ( this_beaming, SCM_EOL);
SCM s = ly_cdr (this_beaming);
- for (; ly_pair_p (s); s = ly_cdr (s))
+ for (; is_pair (s); s = ly_cdr (s))
{
int np = - this_dir * ly_scm2int (ly_car (s));
scm_set_car_x (s, scm_int2num (np));
Array<int> rfliebertjes;
for (SCM s = left;
- ly_pair_p (s); s =ly_cdr (s))
+ is_pair (s); s =ly_cdr (s))
{
int b = ly_scm2int (ly_car (s));
if (scm_c_memq (ly_car (s), right) != SCM_BOOL_F)
}
}
for (SCM s = right;
- ly_pair_p (s); s =ly_cdr (s))
+ is_pair (s); s =ly_cdr (s))
{
int b = ly_scm2int (ly_car (s));
if (scm_c_memq (ly_car (s), left) == SCM_BOOL_F)
Stencil gapped;
int gap_count = 0;
- if (ly_number_p (me->get_property ("gap-count")))
+ if (is_number (me->get_property ("gap-count")))
{
gap_count = ly_scm2int (me->get_property ("gap-count"));
gapped = Lookup::beam (dydx, w - 2 * gap_length, thick, blot);
#if (DEBUG_QUANTING)
SCM quant_score = me->get_property ("quant-score");
if (debug_beam_quanting_flag
- && ly_string_p (quant_score))
+ && is_string (quant_score))
{
/*
scm_cons (scm_int2num (total[UP]),
scm_int2num (total[DOWN])));
- if (ly_number_p (s) && ly_scm2int (s))
+ if (is_number (s) && ly_scm2int (s))
return to_dir (s);
/* If dir is not determined: get default */
Beam::consider_auto_knees (Grob* me)
{
SCM scm = me->get_property ("auto-knee-gap");
- if (!ly_number_p (scm))
+ if (!is_number (scm))
return ;
Real threshold = ly_scm2double (scm);
{
// one wonders if such genericity is necessary --hwn.
SCM callbacks = me->get_property ("position-callbacks");
- for (SCM i = callbacks; ly_pair_p (i); i = ly_cdr (i))
+ for (SCM i = callbacks; is_pair (i); i = ly_cdr (i))
scm_call_1 (ly_car (i), me->self_scm ());
}
*/
bool is_concave1 = false;
SCM gap = me->get_property ("concaveness-gap");
- if (ly_number_p (gap))
+ if (is_number (gap))
{
Real r1 = ly_scm2double (gap);
Real dy = Stem::chord_start_y (stems.top ())
Real concaveness2 = 0;
SCM thresh = me->get_property ("concaveness-threshold");
Real r2 = infinity_f;
- if (!is_concave1 && ly_number_p (thresh))
+ if (!is_concave1 && is_number (thresh))
{
r2 = ly_scm2double (thresh);
{
Slice l;
- for ( SCM s = ly_car (beaming); ly_pair_p (s) ; s = ly_cdr (s))
+ for ( SCM s = ly_car (beaming); is_pair (s) ; s = ly_cdr (s))
{
if (scm_c_memq (ly_car (s), ly_cdr (beaming)) != SCM_BOOL_F)
bool gap = false;
Real thick =0.0;
- if (ly_number_p (me->get_property ("gap-count"))
+ if (is_number (me->get_property ("gap-count"))
&&ly_scm2int (me->get_property ("gap-count")))
{
gap = true;
Grob *rest = unsmob_grob (element_smob);
Axis a = (Axis) ly_scm2int (axis);
- if (ly_number_p (rest->get_property ("staff-position")))
+ if (is_number (rest->get_property ("staff-position")))
return scm_int2num (0);
assert (a == Y_AXIS);
Drul_array<Real> pos (0, 0);
SCM s = beam->get_property ("positions");
- if (ly_pair_p (s) && ly_number_p (ly_car (s)))
+ if (is_pair (s) && is_number (ly_car (s)))
pos = ly_scm2interval (s);
Real staff_space = Staff_symbol_referencer::staff_space (rest);
Beam::is_knee (Grob* me)
{
SCM k = me->get_property ("knee");
- if (ly_boolean_p (k))
+ if (is_boolean (k))
return ly_scm2bool (k);
bool knee = false;
int d = 0;
- for (SCM s = me->get_property ("stems"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("stems"); is_pair (s); s = ly_cdr (s))
{
Direction dir = get_grob_direction (unsmob_grob (ly_car (s)));
if (d && d != dir)
void
Break_align_engraver::stop_translation_timestep ()
{
- for (SCM p = column_alist_; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = column_alist_; is_pair (p); p = ly_cdr (p))
{
SCM pair = ly_car (p);
add_column (ly_cdr (pair));
return ;
SCM align_name = item->get_property ("break-align-symbol");
- if (!ly_symbol_p (align_name))
+ if (!is_symbol (align_name))
return ;
if (!align_)
Item *me = dynamic_cast<Item*> (grob);
SCM elts = me->get_property ("elements");
SCM order_vec = me->get_property ("break-align-orders");
- if (!ly_vector_p (order_vec)
+ if (!is_vector (order_vec)
|| ly_vector_length (order_vec) < 3)
return Pointer_group_interface__extract_grobs (me, (Grob*)0,
"elements");
Copy in order specified in BREAK-ALIGN-ORDER.
*/
Link_array<Grob> new_elts;
- for (; ly_pair_p (order); order = ly_cdr (order))
+ for (; is_pair (order); order = ly_cdr (order))
{
SCM sym = ly_car (order);
- for (SCM s =elts; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s =elts; is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
if (g && sym == g->get_property ("break-align-symbol"))
Find the first grob with a space-alist entry.
*/
for (SCM s = l->get_property ("elements");
- ly_pair_p (s) ; s = ly_cdr (s))
+ is_pair (s) ; s = ly_cdr (s))
{
Grob *elt = unsmob_grob (ly_car (s));
edge_idx = idx;
SCM l =elt->get_property ("space-alist");
- if (ly_pair_p (l))
+ if (is_pair (l))
{
alist= l;
break;
reason.
*/
for (SCM s = r ? r->get_property ("elements") : SCM_EOL;
- !ly_symbol_p (rsym) && ly_pair_p (s); s = ly_cdr (s))
+ !is_symbol (rsym) && is_pair (s); s = ly_cdr (s))
{
Grob * elt =unsmob_grob (ly_car (s));
edge_idx = next_idx;
SCM entry = SCM_EOL;
- if (ly_symbol_p (rsym))
+ if (is_symbol (rsym))
entry = scm_assq (rsym, alist);
- bool entry_found = ly_pair_p (entry);
+ bool entry_found = is_pair (entry);
if (!entry_found)
{
String sym_string;
- if (ly_symbol_p (rsym))
+ if (is_symbol (rsym))
sym_string = ly_symbol2string (rsym);
String orig_string ;
if (unsmob_grob (src))
return substitute_grob (unsmob_grob (src));
- else if (ly_vector_p (src))
+ else if (is_vector (src))
{
int len = SCM_VECTOR_LENGTH (src);
SCM nv = scm_c_make_vector (len, SCM_UNDEFINED);
do_break_substitution (scm_vector_ref (src, si)));
}
}
- else if (ly_pair_p (src))
+ else if (is_pair (src))
{
/*
UGH! breaks on circular lists.
SCM oldcdr = ly_cdr (src);
if (newcar == SCM_UNDEFINED
- && (ly_pair_p (oldcdr) || oldcdr == SCM_EOL))
+ && (is_pair (oldcdr) || oldcdr == SCM_EOL))
{
/*
This is tail-recursion, ie.
SCM l = SCM_EOL;
SCM * tail = &l;
- for (SCM s = grob_list; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = grob_list; is_pair (s); s = ly_cdr (s))
{
SCM n= substitute_grob (unsmob_grob (ly_car (s)));
int sp_index = len;
int it_index = 0;
- for (SCM s = grob_list; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = grob_list; is_pair (s); s = ly_cdr (s))
{
Grob * g = unsmob_grob (ly_car (s));
SCM l = SCM_EOL;
SCM *tail = &l;
- for (SCM s = alist; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = alist; is_pair (s); s = ly_cdr (s))
{
SCM sym = ly_caar (s);
SCM val = ly_cdar (s);
if (inversion_event)
{
SCM oct = inversion_event->get_property ("octavation");
- if (ly_number_p (oct))
+ if (is_number (oct))
{
Pitch *p = unsmob_pitch (inversion_event->get_property ("pitch"));
int octavation = ly_scm2int (oct);
chord_name_->set_property ("text", markup);
announce_grob (chord_name_, notes_[0]->self_scm ());
SCM s = get_property ("chordChanges");
- if (to_boolean (s) && ly_pair_p (last_chord_)
- && ly_equal_p (chord_as_scm, last_chord_))
+ if (to_boolean (s) && is_pair (last_chord_)
+ && is_equal (chord_as_scm, last_chord_))
chord_name_->set_property ("begin-of-line-visible", SCM_BOOL_T);
last_chord_ = chord_as_scm;
if (item)
{
if (Bar_line::has_interface (info.grob_)
- && ly_string_p (get_property ("clefGlyph")))
+ && is_string (get_property ("clefGlyph")))
create_clef ();
}
}
clef_ = c;
SCM cpos = get_property ("clefPosition");
- if (ly_number_p (cpos))
+ if (is_number (cpos))
Staff_symbol_referencer::set_position (clef_, ly_scm2int (cpos));
SCM oct = get_property ("clefOctavation");
- if (ly_number_p (oct) && ly_scm2int (oct))
+ if (is_number (oct) && ly_scm2int (oct))
{
Item * g = make_item ("OctavateEight");
SCM glyph = s->get_property ("glyph-name");
- if (ly_string_p (glyph))
+ if (is_string (glyph))
{
String str = ly_scm2string (glyph);
{
Grob *me = unsmob_grob (smob);
SCM glyph_scm = me->get_property ("glyph-name");
- if (!ly_string_p (glyph_scm))
+ if (!is_string (glyph_scm))
return SCM_EOL;
String glyph = String (ly_scm2string (glyph_scm));
{
SCM c0scm = get_property ("middleCPosition");
- int c0 = ly_number_p (c0scm) ? ly_scm2int (c0scm) : 0;
+ int c0 = is_number (c0scm) ? ly_scm2int (c0scm) : 0;
int pmax = INT_MIN;
int pmin = INT_MAX;
SCM shape_scm = me->get_property ("style");
String shape;
- if (ly_symbol_p (shape_scm))
+ if (is_symbol (shape_scm))
{
shape = ly_symbol2string (shape_scm);
}
Grob *commonx = left_bound->common_refpoint (right_bound, X_AXIS);
SCM cols =me->get_property ("columns");
- if (!ly_pair_p (cols))
+ if (!is_pair (cols))
{
me->warning ("junking empty cluster");
me->suicide ();
line with the center of the note heads?
*/
- for (SCM s = cols; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = cols; is_pair (s); s = ly_cdr (s))
{
Grob * col = unsmob_grob (ly_car (s));
Interval yext = col->extent (commony, Y_AXIS);
{
Spanner * next = orig->broken_intos_[spanner->get_break_index () + 1];
SCM cols = next->get_property ("columns");
- if (ly_pair_p (cols))
+ if (is_pair (cols))
{
Grob *next_commony = common_refpoint_of_list (cols, next, Y_AXIS);
Grob * col = unsmob_grob (ly_car (scm_last_pair (cols)));
// also for all associated grobs (NoteSpacing, SeparationItem).
Grob *sl = Staff_symbol_referencer::get_staff_symbol (item);
for (SCM tail = parent->get_property ("elements");
- ly_pair_p (tail);
+ is_pair (tail);
tail = ly_cdr (tail))
{
Item *sibling = unsmob_item (ly_car (tail));
int pos = pit->steps ();
SCM c0 = get_property ("middleCPosition");
- if (ly_number_p (c0))
+ if (is_number (c0))
pos += ly_scm2int (c0);
note->set_property ("staff-position", scm_int2num (pos));
}
SCM sym = ly_cadr (mod);
- if (ly_string_p (sym))
+ if (is_string (sym))
sym = scm_string_to_symbol (sym);
if (ly_symbol2scm ("consists") == tag
SCM mods = scm_reverse_x (scm_list_copy (accept_mods_),
user_mod);
SCM acc = SCM_EOL;
- for (SCM s = mods; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = mods; is_pair (s); s = ly_cdr (s))
{
SCM tag = ly_caar (s);
SCM sym = ly_cadar (s);
Link_array<Context_def>
Context_def::path_to_acceptable_context (SCM type_sym, Music_output_def* odef) const
{
- assert (ly_symbol_p (type_sym));
+ assert (is_symbol (type_sym));
SCM accepted = get_accepted (SCM_EOL);
Link_array<Context_def> accepteds;
- for (SCM s = accepted; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = accepted; is_pair (s); s = ly_cdr (s))
{
Context_def *t = unsmob_context_def (odef->find_context_def (ly_car (s)));
if (!t)
/*
don't check aliases, because \context Staff should not create RhythmicStaff.
*/
- if (ly_equal_p (accepteds[i]->get_context_name (), type_sym))
+ if (is_equal (accepteds[i]->get_context_name (), type_sym))
{
best_result.push (accepteds[i]);
return best_result;
SCM mods = scm_reverse_x (scm_list_copy (translator_mods_),
user_mod);
- for (SCM s = mods; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = mods; is_pair (s); s = ly_cdr (s))
{
SCM tag = ly_caar (s);
SCM arg = ly_cadar (s);
- if (ly_string_p (arg))
+ if (is_string (arg))
arg = scm_string_to_symbol (arg);
if (ly_symbol2scm ("consists") == tag)
SCM
filter_performers (SCM l)
{
- for (SCM *tail = &l; ly_pair_p (*tail); tail = SCM_CDRLOC (*tail))
+ for (SCM *tail = &l; is_pair (*tail); tail = SCM_CDRLOC (*tail))
{
if (dynamic_cast<Performer*> (unsmob_translator (ly_car (*tail))))
{
SCM
filter_engravers (SCM l)
{
- for (SCM *tail = &l; ly_pair_p (*tail) ; tail = SCM_CDRLOC (*tail))
+ for (SCM *tail = &l; is_pair (*tail) ; tail = SCM_CDRLOC (*tail))
{
if (dynamic_cast<Engraver*> (unsmob_translator (ly_car (*tail))))
{
l = scm_cons (scm_cons (ly_symbol2scm ("property-ops"), property_ops_), l);
l = scm_cons (scm_cons (ly_symbol2scm ("context-name"), context_name_), l);
- if (ly_symbol_p (translator_group_type_))
+ if (is_symbol (translator_group_type_))
l = scm_cons (scm_cons (ly_symbol2scm ("group-type"), translator_group_type_), l);
return l;
return unsmob_context_def (tr->definition_)->get_context_name ();
}
-LY_DEFINE (ly_context_pushpop_property, "ly:context-pushpop-property",
+LY_DEFINE (is_contextushpop_property, "ly:context-pushpop-property",
3, 1, 0, (SCM context, SCM grob, SCM eltprop, SCM val),
"Do a single @code{\\override} or @code{\\revert} operation "
"in @var{context}. The grob definition @code{grob} is extended "
{
Context *tg = unsmob_context (context);
SCM_ASSERT_TYPE (tg, context, SCM_ARG1, __FUNCTION__, "context");
- SCM_ASSERT_TYPE (ly_symbol_p (grob), grob, SCM_ARG2, __FUNCTION__, "symbol");
- SCM_ASSERT_TYPE (ly_symbol_p (eltprop), eltprop, SCM_ARG3, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (grob), grob, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (eltprop), eltprop, SCM_ARG3, __FUNCTION__, "symbol");
execute_pushpop_property (tg, grob, eltprop, val);
return SCM_UNDEFINED;
}
-LY_DEFINE (ly_context_property, "ly:context-property",
+LY_DEFINE (is_contextroperty, "ly:context-property",
2, 0, 0, (SCM c, SCM name),
"Return the value of @var{name} from context @var{c}")
{
Context *t = unsmob_context (c);
Context * tr= (t);
SCM_ASSERT_TYPE (tr, c, SCM_ARG1, __FUNCTION__, "Translator group");
- SCM_ASSERT_TYPE (ly_symbol_p (name), name, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (name), name, SCM_ARG2, __FUNCTION__, "symbol");
return tr->internal_get_property (name);
}
{
Context *tr = unsmob_context (context);
SCM_ASSERT_TYPE (tr, context, SCM_ARG1, __FUNCTION__, "Context");
- SCM_ASSERT_TYPE (ly_symbol_p (name), name, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (name), name, SCM_ARG2, __FUNCTION__, "symbol");
tr->internal_set_property (name, val);
return SCM_UNSPECIFIED;
}
-LY_DEFINE (ly_context_property_where_defined, "ly:context-property-where-defined",
+LY_DEFINE (is_contextroperty_where_defined, "ly:context-property-where-defined",
2, 0, 0, (SCM context, SCM name),
"Return the context above @var{context} "
"where @var{name} is defined.")
{
Context *tr = unsmob_context (context);
SCM_ASSERT_TYPE (tr, context, SCM_ARG1, __FUNCTION__, "Context");
- SCM_ASSERT_TYPE (ly_symbol_p (name), name, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (name), name, SCM_ARG2, __FUNCTION__, "symbol");
tr = tr->where_defined (name);
if (tr)
{
Context *tr = unsmob_context (context);
SCM_ASSERT_TYPE (tr, context, SCM_ARG1, __FUNCTION__, "Context");
- SCM_ASSERT_TYPE (ly_symbol_p (name), name, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (name), name, SCM_ARG2, __FUNCTION__, "symbol");
tr->unset_property (name);
return SCM_UNSPECIFIED;
}
-LY_DEFINE (ly_context_parent, "ly:context-parent",
+LY_DEFINE (is_contextarent, "ly:context-parent",
1, 0, 0, (SCM context),
"Return the parent of @var{context}, @code{#f} if none.")
{
{
Context *tr = unsmob_context (context);
SCM_ASSERT_TYPE (tr, context, SCM_ARG1, __FUNCTION__, "context");
- SCM_ASSERT_TYPE (ly_symbol_p (name), name, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (name), name, SCM_ARG2, __FUNCTION__, "symbol");
while (tr)
{
/*
What is this used for? Should remove? --hwn
*/
-LY_DEFINE (ly_context_properties, "ly:context-properties",
+LY_DEFINE (is_contextroperties, "ly:context-properties",
1, 0, 0, (SCM context),
"Return all properties of @var{context} in an alist.")
{
String c_id;
SCM ci = get_music ()->get_property ("context-id");
- if (ly_string_p (ci))
+ if (is_string (ci))
c_id = ly_scm2string (ci);
SCM ops = get_music ()->get_property ("property-operations");
void
Context::check_removal ()
{
- for (SCM p = context_list_; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = context_list_; is_pair (p); p = ly_cdr (p))
{
Context *trg = unsmob_context (ly_car (p));
return this;
Context* r = 0;
- for (SCM p = context_list_; !r && ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = context_list_; !r && is_pair (p); p = ly_cdr (p))
{
Context * t = unsmob_context (ly_car (p));
SCM
default_child_context_name (Context const *tg)
{
- return ly_pair_p (tg->accepts_list_)
+ return is_pair (tg->accepts_list_)
? ly_car (scm_last_pair (tg->accepts_list_))
: SCM_EOL;
}
bool
Context::is_bottom_context () const
{
- return !ly_symbol_p (default_child_context_name (this));
+ return !is_symbol (default_child_context_name (this));
}
Context*
Context::is_alias (SCM sym) const
{
if (sym == ly_symbol2scm ("Bottom")
- && !ly_pair_p (accepts_list_))
+ && !is_pair (accepts_list_))
return true;
if (sym == unsmob_context_def (definition_)->get_context_name ())
return true;
Context * found = 0;
for (SCM s = where->context_list_;
- !found && ly_pair_p (s); s = ly_cdr (s))
+ !found && is_pair (s); s = ly_cdr (s))
{
Context * tr = unsmob_context (ly_car (s));
void
Custos_engraver::process_acknowledged_grobs ()
{
- if (ly_string_p (get_property ("whichBar")))
+ if (is_string (get_property ("whichBar")))
custos_permitted = true;
if (custos_permitted)
int p = pitches_[i].steps ();
SCM c0 = get_property ("middleCPosition");
- if (ly_number_p (c0))
+ if (is_number (c0))
p += ly_scm2int (c0);
SCM scm_style = me->get_property ("style");
String style;
- if (ly_symbol_p (scm_style))
+ if (is_symbol (scm_style))
{
style = ly_symbol2string (scm_style);
}
SCM c = sc->get_property ("dot-count");
- if (ly_number_p (c))
+ if (is_number (c))
{
Stencil d = Font_interface::get_default_font (sc)->find_by_name (String ("dots-dot"));
Real dw = d.extent (X_AXIS).length ();
if (scm_hash_table_p (tab) == SCM_BOOL_T)
defn = scm_hashq_ref (tab, drum_type, SCM_EOL);
- if (ly_pair_p (defn))
+ if (is_pair (defn))
{
SCM pos = ly_caddr (defn);
SCM style =ly_car (defn);
if (scm_integer_p (pos) == SCM_BOOL_T)
note->set_property ("staff-position", pos);
- if (ly_symbol_p (style))
+ if (is_symbol (style))
note->set_property ("style", style);
- if (ly_string_p (script))
+ if (is_string (script))
{
Item *p = make_item ("Script");
SCM desc = SCM_EOL;
SCM sym = n->get_property ("drum-type");
SCM defn = SCM_EOL;
- if (ly_symbol_p (sym)
+ if (is_symbol (sym)
&& (scm_hash_table_p (tab) == SCM_BOOL_T))
defn = scm_hashq_ref (tab, sym, SCM_EOL);
bool compress = false;
if (num != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (num), length, SCM_ARG3, __FUNCTION__, "integer");
+ SCM_ASSERT_TYPE (is_number (num), length, SCM_ARG3, __FUNCTION__, "integer");
compress = true;
}
else
if (den != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (den), length, SCM_ARG4, __FUNCTION__, "integer");
+ SCM_ASSERT_TYPE (is_number (den), length, SCM_ARG4, __FUNCTION__, "integer");
compress = true;
}
else
1, 0, 0, (SCM d),
"The 2-logarithm of 1/@var{d}.")
{
- SCM_ASSERT_TYPE (ly_number_p (d), d, SCM_ARG1, __FUNCTION__, "integer");
+ SCM_ASSERT_TYPE (is_number (d), d, SCM_ARG1, __FUNCTION__, "integer");
int log = intlog2 (ly_scm2int (d));
return scm_int2num (log);
}
start_type = "crescendo";
SCM s = get_property ((start_type + "Spanner").to_str0 ());
- if (!ly_symbol_p (s) || s == ly_symbol2scm ("hairpin"))
+ if (!is_symbol (s) || s == ly_symbol2scm ("hairpin"))
{
cresc_ = make_spanner ("Hairpin");
cresc_->set_property ("grow-direction",
/*
FIXME: use get_markup () to check type.
*/
- if (ly_string_p (s) || ly_pair_p (s))
+ if (is_string (s) || is_pair (s))
{
cresc_->set_property ("edge-text",
scm_cons (s, scm_makfrom0str ("")));
if (script_ && !script_->get_parent (X_AXIS))
{
SCM head = scm_last_pair (i.grob_->get_property ("note-heads"));
- if (ly_pair_p (head))
+ if (is_pair (head))
script_->set_parent (unsmob_grob (ly_car (head)), X_AXIS);
}
DynamicText doesn't really have a script-priority field.
*/
- if (ly_number_p (p)
+ if (is_number (p)
&& ly_scm2int (p) < ly_scm2int (script_->get_property ("script-priority")))
{
Side_position_interface::add_support (line_spanner_, i.grob_);
SCM proc = get_property ("dynamicAbsoluteVolumeFunction");
SCM svolume = SCM_EOL;
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
{
// urg
svolume = scm_call_1 (proc, script_req_->get_property ("text"));
*/
SCM min = get_property ("midiMinimumVolume");
SCM max = get_property ("midiMaximumVolume");
- if (ly_number_p (min) || ly_number_p (max))
+ if (is_number (min) || is_number (max))
{
Interval iv (0, 1);
- if (ly_number_p (min))
+ if (is_number (min))
iv[MIN] = ly_scm2double (min);
- if (ly_number_p (max))
+ if (is_number (max))
iv[MAX] = ly_scm2double (max);
volume = iv[MIN] + iv.length () * volume;
}
*/
SCM s = get_property ("midiInstrument");
- if (!ly_string_p (s))
+ if (!is_string (s))
s = get_property ("instrument");
- if (!ly_string_p (s))
+ if (!is_string (s))
s = scm_makfrom0str ("piano");
SCM eq = get_property ("instrumentEqualizer");
- if (ly_procedure_p (eq))
+ if (is_procedure (eq))
{
s = scm_call_1 (eq, s);
}
SCM meta = info.grob_->internal_get_property (meta_sym);
SCM nm = scm_assoc (name_sym, meta);
- if (ly_pair_p (nm))
+ if (is_pair (nm))
nm = ly_cdr (nm);
else
{
scm_hashq_set_x (tab, nm, acklist);
}
- for (SCM p = acklist; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = acklist; is_pair (p); p = ly_cdr (p))
{
Translator * t = unsmob_translator (ly_car (p));
Engraver * eng = dynamic_cast<Engraver*> (t);
{
SCM ack_ifs = scm_assoc (ly_symbol2scm ("interfaces-acked"), tr->translator_description ());
ack_ifs = ly_cdr (ack_ifs);
- for (SCM s = ifaces; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = ifaces; is_pair (s); s = ly_cdr (s))
if (scm_c_memq (ly_car (s), ack_ifs) != SCM_BOOL_F)
return true;
return false;
SCM ifaces = ly_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta_alist));
SCM l = SCM_EOL;
- for (SCM s = gravlist; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = gravlist; is_pair (s); s = ly_cdr (s))
{
Translator* tr = unsmob_translator (ly_car (s));
if (engraver_valid (tr, ifaces))
(tg->*ptr) ();
}
- for (SCM s = c->context_list_ ; ly_pair_p (s);
+ for (SCM s = c->context_list_ ; is_pair (s);
s =ly_cdr (s))
{
recurse_down_engravers (unsmob_context (ly_car (s)), ptr, context_first);
void
engraver_each (SCM list, Engraver_method method)
{
- for (SCM p = list; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = list; is_pair (p); p = ly_cdr (p))
{
Engraver * e = dynamic_cast<Engraver*>(unsmob_translator (ly_car (p)));
if (e)
if (last_processed_mom_ < Moment (0))
{
for (SCM s = dynamic_cast<Music_sequence *> (get_music ())->music_list ();
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Music *mus = unsmob_music (ly_car (s));
new_pit = new_pit.to_relative_octave (last);
SCM check = get_property ("absolute-octave");
- if (ly_number_p (check) &&
+ if (is_number (check) &&
new_pit.get_octave () != ly_scm2int (check))
{
Pitch expected_pit (ly_scm2int (check),
SCM newlist = SCM_EOL;
Pitch *p = unsmob_pitch (pit);
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
SCM key = ly_caar (s);
SCM alter = ly_cdar (s);
- if (ly_pair_p (key))
+ if (is_pair (key))
{
Pitch orig (ly_scm2int (ly_car (key)),
ly_scm2int (ly_cdr (key)),
newlist = scm_cons (scm_cons (key, scm_int2num (orig.get_alteration ())),
newlist);
}
- else if (ly_number_p (key))
+ else if (is_number (key))
{
Pitch orig (0, ly_scm2int (key), ly_scm2int (alter));
orig = orig.transposed (*p);
alist_equal_p (SCM a, SCM b)
{
for (SCM s = a;
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
SCM key = ly_caar (s);
SCM val = ly_cdar (s);
SCM l = scm_assoc (key, b);
if (l == SCM_BOOL_F
- || !ly_equal_p ( ly_cdr (l), val))
+ || !is_equal ( ly_cdr (l), val))
return false;
}
if (!sp->get_bound (RIGHT))
{
SCM heads = sp->get_property ("heads");
- if (ly_pair_p (heads))
+ if (is_pair (heads))
{
Item* it = dynamic_cast<Item*> (unsmob_grob (ly_car (heads)));
if (it)
else if (figures_.size ())
{
SCM proc = get_property ("bassFigureFormatFunction");
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
{
SCM l = SCM_EOL;
SCM * t = &l;
// Hmm
int priority = 200;
SCM s = fingering->get_property ("script-priority");
- if (ly_number_p (s))
+ if (is_number (s))
priority = ly_scm2int (s);
/* See script-engraver.cc */
{
Font_metric *fm = unsmob_metrics (font);
SCM_ASSERT_TYPE (fm, font, SCM_ARG1, __FUNCTION__, "font-metric");
- SCM_ASSERT_TYPE (ly_string_p (name), name, SCM_ARG2, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (name), name, SCM_ARG2, __FUNCTION__, "string");
Stencil m = fm->find_by_name (ly_scm2string (name));
{
Font_metric *fm = unsmob_metrics (font);
SCM_ASSERT_TYPE (fm, font, SCM_ARG1, __FUNCTION__, "font-metric");
- SCM_ASSERT_TYPE (ly_number_p (index), index, SCM_ARG2, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (index), index, SCM_ARG2, __FUNCTION__, "number");
return fm->get_ascii_char_stencil (ly_scm2int (index)).smobbed_copy ();
}
Modified_font_metric*fm = dynamic_cast<Modified_font_metric*>
(unsmob_metrics (font));
SCM_ASSERT_TYPE (fm, font, SCM_ARG1, __FUNCTION__, "modified font metric");
- SCM_ASSERT_TYPE (ly_string_p (text), text, SCM_ARG2, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (text), text, SCM_ARG2, __FUNCTION__, "string");
b = fm->text_dimension (ly_scm2string (text));
*/
Font_metric*
get_font_by_design_size (Paper_def* paper, Real requested,
- SCM font_vector)
+ SCM font_vector, SCM input_encoding_name)
{
int n = SCM_VECTOR_LENGTH (font_vector);
Real size = 1e6;
}
Font_metric *fm = unsmob_metrics (scm_force (SCM_VECTOR_REF (font_vector, i)));
- return paper->find_scaled_font (fm, requested / size);
+ return paper->find_scaled_font (fm, requested / size, input_encoding_name);
}
Font_metric*
get_font_by_mag_step (Paper_def* paper, Real requested_step,
- SCM font_vector, Real default_size)
+ SCM font_vector, Real default_size, SCM input_encoding_name)
{
return get_font_by_design_size (paper,
default_size * pow (2.0, requested_step / 6.0),
- font_vector);
+ font_vector, input_encoding_name);
}
Font_metric *
-select_font (Paper_def *paper, SCM chain)
+select_encoded_font (Paper_def *paper, SCM chain, SCM encoding_name)
{
SCM name = ly_assoc_chain (ly_symbol2scm ("font-name"), chain);
- if (!ly_pair_p (name) || !ly_string_p (ly_cdr (name)))
+ if (!is_pair (name) || !is_string (ly_cdr (name)))
{
SCM fonts = paper->lookup_variable (ly_symbol2scm ("fonts"));
name = properties_to_font_size_family (fonts, chain);
else
name = ly_cdr (name);
-
- if (ly_string_p (name))
+ if (is_string (name))
{
SCM mag = ly_assoc_chain (ly_symbol2scm ("font-magnification"), chain);
- Real rmag = ly_pair_p (mag) ? robust_scm2double (ly_cdr (mag), 1.0) : 1;
+ Real rmag = is_pair (mag) ? robust_scm2double (ly_cdr (mag), 1.0) : 1;
Font_metric * fm = all_fonts_global->find_font (ly_scm2string (name));
- return paper->find_scaled_font (fm, rmag);
+ return paper->find_scaled_font (fm, rmag, encoding_name);
}
else if (scm_instance_p (name))
{
SCM font_size = ly_assoc_chain (ly_symbol2scm ("font-size"), chain);
Real req = 0.0;
- if (ly_pair_p (font_size))
+ if (is_pair (font_size))
req = ly_scm2double (ly_cdr (font_size));
return get_font_by_mag_step (paper, req,
- vec, ly_scm2double (base_size));
+ vec, ly_scm2double (base_size), encoding_name);
}
assert (0);
}
+
+Font_metric *
+select_font (Paper_def *paper, SCM chain)
+{
+ return select_encoded_font (paper, chain, SCM_EOL);
+}
if (gi.origin_trans_->daddy_context_ != daddy_context_)
return ;
- if (ly_number_p (sz) && ly_scm2double (sz))
+ if (is_number (sz) && ly_scm2double (sz))
{
Real font_size = ly_scm2double (sz);
SCM busy = get_property ("busyGrobs");
Moment now = now_mom ();
- while (ly_pair_p (busy) && unsmob_moment (ly_caar (busy))->main_part_ == now.main_part_)
+ while (is_pair (busy) && unsmob_moment (ly_caar (busy))->main_part_ == now.main_part_)
busy = ly_cdr (busy);
- while (ly_pair_p (busy))
+ while (is_pair (busy))
{
Grob *g = unsmob_grob (ly_cdar (busy));
if (Rhythmic_head::has_interface (g))
if (!strlen (doc))
return ;
- if (!ly_vector_p (doc_hash_table ))
+ if (!is_vector (doc_hash_table ))
doc_hash_table = scm_make_vector (scm_int2num (59), SCM_EOL);
String s = String (" - ") + "LilyPond procedure: " + fname + " " + varlist
Score_context*
Global_context::get_score_context () const
{
- return (ly_pair_p (context_list_))
+ return (is_pair (context_list_))
? dynamic_cast<Score_context*> (unsmob_context (ly_car (context_list_)))
: 0;
}
{
SCM lst = get_property ("finalizations");
set_property ("finalizations" , SCM_EOL);
- for (SCM s = lst ; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = lst ; is_pair (s); s = ly_cdr (s))
{
scm_primitive_eval (ly_car (s)); // TODO: make safe.
}
if (pc->original_)
{
SCM pen = pc->get_property ("penalty");
- if (ly_number_p (pen) && fabs (ly_scm2double (pen)) < 10000)
+ if (is_number (pen) && fabs (ly_scm2double (pen)) < 10000)
{
break_penalties += ly_scm2double (pen);
}
LY_DEFINE (ly_add_interface, "ly:add-interface", 3,0,0, (SCM a, SCM b, SCM c),
"Add an interface description.")
{
- SCM_ASSERT_TYPE (ly_symbol_p (a), a, SCM_ARG1, __FUNCTION__, "symbol");
- SCM_ASSERT_TYPE (ly_string_p (b), b, SCM_ARG2, __FUNCTION__, "string");
- SCM_ASSERT_TYPE (ly_list_p (c), c, SCM_ARG3, __FUNCTION__, "list of syms");
- if (!ly_vector_p (all_ifaces))
+ SCM_ASSERT_TYPE (is_symbol (a), a, SCM_ARG1, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_string (b), b, SCM_ARG2, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_list (c), c, SCM_ARG3, __FUNCTION__, "list of syms");
+ if (!is_vector (all_ifaces))
all_ifaces = scm_make_vector (scm_int2num (40), SCM_EOL);
SCM entry = scm_list_n (a, b, c, SCM_UNDEFINED);
SCM ifs = me->get_property ("interfaces");
bool found = false;
- for (; !found && ly_pair_p (ifs); ifs =ly_cdr (ifs))
+ for (; !found && is_pair (ifs); ifs =ly_cdr (ifs))
{
SCM iface = scm_hashq_ref (all_ifaces , ly_car (ifs), SCM_BOOL_F);
if (iface == SCM_BOOL_F)
Moment now = now_mom ();
SCM start_busy = get_property ("busyGrobs");
SCM busy = start_busy;
- while (ly_pair_p (busy) && *unsmob_moment (ly_caar (busy)) == now)
+ while (is_pair (busy) && *unsmob_moment (ly_caar (busy)) == now)
{
busy = ly_cdr (busy);
}
SCM start_busy = get_property ("busyGrobs");
SCM busy = start_busy;
- while (ly_pair_p (busy) && *unsmob_moment (ly_caar (busy)) < now)
+ while (is_pair (busy) && *unsmob_moment (ly_caar (busy)) < now)
{
/*
The grob-pq-engraver is not water tight, and stuff like
s = scm_sloppy_assq (sym, immutable_property_alist_);
- if (internal_type_checking_global_b && ly_pair_p (s))
+ if (internal_type_checking_global_b && is_pair (s))
{
if (!type_check_assignment (sym, ly_cdr (s),
ly_symbol2scm ("backend-type?")))
{
Grob * sc = unsmob_grob (grob);
SCM_ASSERT_TYPE (sc, grob, SCM_ARG1, __FUNCTION__, "grob");
- SCM_ASSERT_TYPE (ly_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
if (!type_check_assignment (sym, val, ly_symbol2scm ("backend-type?")))
error ("typecheck failed");
{
Grob *sc = unsmob_grob (grob);
SCM_ASSERT_TYPE (sc, grob, SCM_ARG1, __FUNCTION__, "grob");
- SCM_ASSERT_TYPE (ly_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
return sc->internal_get_property (sym);
}
{
Grob *me = unsmob_grob (g);
SCM_ASSERT_TYPE (me, g, SCM_ARG1, __FUNCTION__, "grob");
- SCM_ASSERT_TYPE (ly_number_p (d), d, SCM_ARG2, __FUNCTION__, "dimension");
+ SCM_ASSERT_TYPE (is_number (d), d, SCM_ARG2, __FUNCTION__, "dimension");
SCM_ASSERT_TYPE (is_axis (a), a, SCM_ARG3, __FUNCTION__, "axis");
me->translate_axis (ly_scm2double (d), Axis (ly_scm2int (a)));
return SCM_UNDEFINED;
}
-LY_DEFINE (ly_spanner_p, "ly:spanner?",
+LY_DEFINE (is_spanner, "ly:spanner?",
1, 0, 0, (SCM g),
"Is @var{g} a spanner object?")
{
return ly_bool2scm (b);
}
-LY_DEFINE (ly_item_p, "ly:item?",
+LY_DEFINE (is_item, "ly:item?",
1, 0, 0, (SCM g),
"Is @var{g} an @code{Item} object?")
{
#endif
SCM meta = get_property ("meta");
- if (ly_pair_p (meta))
+ if (is_pair (meta))
{
SCM ifs = scm_assoc (ly_symbol2scm ("interfaces"), meta);
if (is_number_pair (xt))
cb = xt;
else if (cb != SCM_BOOL_F
- && !ly_procedure_p (cb) && !ly_pair_p (cb)
- && ly_procedure_p (get_property ("print-function")))
+ && !is_procedure (cb) && !is_pair (cb)
+ && is_procedure (get_property ("print-function")))
cb = stencil_extent_proc;
dim_cache_[a].dimension_ = cb;
status_= busy;
- for (SCM d = get_property ("dependencies"); ly_pair_p (d);
+ for (SCM d = get_property ("dependencies"); is_pair (d);
d = ly_cdr (d))
{
unsmob_grob (ly_car (d))
SCM proc = internal_get_property (funcname);
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
scm_call_1 (proc, this->self_scm ());
status_= final;
SCM proc = get_property ("print-function");
SCM mol = SCM_EOL;
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
mol = scm_apply_0 (proc, scm_list_n (this->self_scm (), SCM_UNDEFINED));
Stencil *m = unsmob_stencil (mol);
because some Spanners have enormously long lists in their
properties.
*/
- for (SCM s = mutable_property_alist_; ly_pair_p (s);
+ for (SCM s = mutable_property_alist_; is_pair (s);
s = ly_cdr (s))
{
sp->substitute_one_mutable_property (ly_caar (s),
bool
Grob::is_empty (Axis a)const
{
- return ! (ly_pair_p (dim_cache_[a].dimension_) ||
- ly_procedure_p (dim_cache_[a].dimension_));
+ return ! (is_pair (dim_cache_[a].dimension_) ||
+ is_procedure (dim_cache_[a].dimension_));
}
Interval
Dimension_cache * d = (Dimension_cache *)&dim_cache_[a];
Interval ext ;
- if (ly_pair_p (d->dimension_))
+ if (is_pair (d->dimension_))
;
- else if (ly_procedure_p (d->dimension_))
+ else if (is_procedure (d->dimension_))
{
/*
FIXME: add doco on types, and should typecheck maybe?
else
return ext;
- if (!ly_pair_p (d->dimension_))
+ if (!is_pair (d->dimension_))
return ext;
ext = ly_scm2interval (d->dimension_);
/*
signs ?
*/
- if (ly_pair_p (extra))
+ if (is_pair (extra))
{
ext[BIGGER] += ly_scm2double (ly_cdr (extra));
ext[SMALLER] += ly_scm2double (ly_car (extra));
extra = get_property (a == X_AXIS
? "minimum-X-extent"
: "minimum-Y-extent");
- if (ly_pair_p (extra))
+ if (is_pair (extra))
{
ext.unite (Interval (ly_scm2double (ly_car (extra)),
ly_scm2double (ly_cdr (extra))));
Grob *
common_refpoint_of_list (SCM elist, Grob *common, Axis a)
{
- for (; ly_pair_p (elist); elist = ly_cdr (elist))
+ for (; is_pair (elist); elist = ly_cdr (elist))
{
Grob * s = unsmob_grob (ly_car (elist));
if (!s)
{
SCM meta = get_property ("meta");
SCM nm = scm_assoc (ly_symbol2scm ("name"), meta);
- nm = (ly_pair_p (nm)) ? ly_cdr (nm) : SCM_EOL;
- return ly_symbol_p (nm) ? ly_symbol2string (nm) : classname (this);
+ nm = (is_pair (nm)) ? ly_cdr (nm) : SCM_EOL;
+ return is_symbol (nm) ? ly_symbol2string (nm) : classname (this);
}
void
{
Link_array<Grob> arr;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
SCM e = ly_car (s);
arr.push (unsmob_grob (e));
{
Spanner*sp = dynamic_cast<Spanner*> (me);
SCM worth = me->get_property ("items-worth-living");
- if (ly_pair_p (worth))
+ if (is_pair (worth))
return ;
if (!to_boolean (me->get_property ("remove-first"))
if (!sp->get_bound (RIGHT))
{
SCM heads = sp->get_property ("heads");
- if (ly_pair_p (heads))
+ if (is_pair (heads))
{
Item* it = dynamic_cast<Item*> (unsmob_grob (ly_car (heads)));
if (it)
{
Link_array<T> arr;
- for (SCM s = elt->get_property (name); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = elt->get_property (name); is_pair (s); s = ly_cdr (s))
{
SCM e = ly_car (s);
arr.push (dynamic_cast<T*> (unsmob_grob (e)));
{
return scm_acons(key, val, scm_assoc_remove_x (alist, key));
}
-inline bool ly_pair_p (SCM x) { return SCM_NFALSEP (scm_pair_p (x)); }
-inline bool ly_symbol_p (SCM x) { return SCM_SYMBOLP (x); }
-inline bool ly_boolean_p (SCM x) { return SCM_BOOLP (x); }
-inline bool ly_char_p (SCM x) { return SCM_CHARP (x); }
-inline bool ly_number_p (SCM x) { return SCM_NUMBERP (x); }
-inline bool ly_string_p (SCM x) { return SCM_STRINGP (x); }
-inline bool ly_vector_p (SCM x) { return SCM_VECTORP (x); }
-inline bool ly_list_p (SCM x) { return SCM_NFALSEP (scm_list_p (x)); }
-inline bool ly_procedure_p (SCM x) { return SCM_NFALSEP (scm_procedure_p (x)); }
-inline bool ly_eq_p (SCM x, SCM y) { return SCM_EQ_P (x, y); }
-inline bool ly_equal_p (SCM x, SCM y) {
+inline bool is_pair (SCM x) { return SCM_NFALSEP (scm_pair_p (x)); }
+inline bool is_symbol (SCM x) { return SCM_SYMBOLP (x); }
+inline bool is_boolean (SCM x) { return SCM_BOOLP (x); }
+inline bool is_char (SCM x) { return SCM_CHARP (x); }
+inline bool is_number (SCM x) { return SCM_NUMBERP (x); }
+inline bool is_string (SCM x) { return SCM_STRINGP (x); }
+inline bool is_vector (SCM x) { return SCM_VECTORP (x); }
+inline bool is_list (SCM x) { return SCM_NFALSEP (scm_list_p (x)); }
+inline bool is_procedure (SCM x) { return SCM_NFALSEP (scm_procedure_p (x)); }
+inline bool is_eq (SCM x, SCM y) { return SCM_EQ_P (x, y); }
+inline bool is_equal (SCM x, SCM y) {
return SCM_NFALSEP (scm_equal_p (x, y));
}
SCM ly_modules_lookup (SCM modules, SCM sym);
SCM ly_module_symbols (SCM mod);
void ly_reexport_module (SCM mod);
-inline bool ly_module_p (SCM x) { return SCM_MODULEP(x); }
+inline bool is_module (SCM x) { return SCM_MODULEP(x); }
void ly_clear_anonymous_modules ();
void reinit ();
Interval line_dimensions_int (int) const;
void output_settings (Paper_outputter*) const;
- Font_metric *find_scaled_font (Font_metric *fm, Real mag);
+ Font_metric *find_scaled_font (Font_metric *fm, Real mag, SCM enc_name);
Real get_dimension (SCM symbol) const;
friend int yyparse (void*);
};
Paper_def * unsmob_paper (SCM x);
+Font_metric *select_encoded_font (Paper_def *paper, SCM input_encoding, SCM chain);
Font_metric *select_font (Paper_def *paper, SCM chain);
#endif /* PAPER_DEF_HH */
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (interpret_markup, (SCM, SCM, SCM));
+ DECLARE_SCHEME_CALLBACK (interpret_string, (SCM, SCM, SCM, SCM));
static bool has_interface (Grob*);
static bool markup_p (SCM) ;
scm_module_define (global_lily_module, ly_symbol2scm ("point-and-click"), val);
- store_locations_global_b =ly_procedure_p (val);
+ store_locations_global_b =is_procedure (val);
return SCM_UNSPECIFIED;
}
{
Input *ip = unsmob_input (sip);
SCM_ASSERT_TYPE (ip, sip, SCM_ARG1, __FUNCTION__, "input location");
- SCM_ASSERT_TYPE (ly_string_p (msg), msg, SCM_ARG2, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (msg), msg, SCM_ARG2, __FUNCTION__, "string");
String m = ly_scm2string (msg);
ip->message (m);
Also create text if barlines in other groups. This allows
a name to be attached to lyrics or chords.
*/
- if (ly_string_p (get_property ("whichBar")))
+ if (is_string (get_property ("whichBar")))
create_text ();
}
more complicated things.
*/
SCM vis = get_property ("break-visibility");
- if (ly_procedure_p (vis))
+ if (is_procedure (vis))
{
SCM args = scm_list_n (scm_int2num (break_status_dir ()), SCM_UNDEFINED);
SCM result = scm_apply_0 (vis, args);
if (!def)
{
SCM vis = get_property ("explicitKeySignatureVisibility");
- if (ly_procedure_p (vis))
+ if (is_procedure (vis))
item_->set_property ("break-visibility",vis);
}
}
}
}
else if (Bar_line::has_interface (info.grob_)
- && ly_pair_p (get_property ("keySignature")))
+ && is_pair (get_property ("keySignature")))
{
create_key (true);
}
Key_engraver::read_ev (Music const * r)
{
SCM p = r->get_property ("pitch-alist");
- if (!ly_pair_p (p))
+ if (!is_pair (p))
return;
SCM n = scm_list_copy (p);
SCM accs = SCM_EOL;
for (SCM s = get_property ("keyAccidentalOrder");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
- if (ly_pair_p (scm_member (ly_car (s), n)))
+ if (is_pair (scm_member (ly_car (s), n)))
{
accs = scm_cons (ly_car (s), accs);
n = scm_delete_x (ly_car (s), n);
}
}
- for (SCM s = n ; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = n ; is_pair (s); s = ly_cdr (s))
if (ly_scm2int (ly_cdar (s)))
accs = scm_cons (ly_car (s), accs);
int
alteration_pos (SCM what, int alter, int c0p)
{
- if (ly_pair_p (what))
+ if (is_pair (what))
return ly_scm2int (ly_car (what)) * 7 + ly_scm2int (ly_cdr (what)) + c0p;
int p = ly_scm2int (what);
SCM scm_style = me->get_property ("style");
String style;
- if (ly_symbol_p (scm_style))
+ if (is_symbol (scm_style))
{
style = ly_symbol2string (scm_style);
}
SCM c0s = me->get_property ("c0-position");
int c0p = 0;
- if (ly_number_p (c0s))
+ if (is_number (c0s))
c0p = ly_scm2int (c0s);
/*
*/
Font_metric *fm = Font_interface::get_default_font (me);
- for (SCM s = newas; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = newas; is_pair (s); s = ly_cdr (s))
{
int alteration = ly_scm2int (ly_cdar (s));
String font_char =
mol.add_at_edge (X_AXIS, LEFT, Lookup::blank (Box (x,y)), 0, 0);
Stencil natural;
- if (ly_pair_p (old))
+ if (is_pair (old))
natural=Font_interface::get_default_font (me)->
find_by_name (String ("accidentals-") + style + String ("0"));
- for (; ly_pair_p (old); old = ly_cdr (old))
+ for (; is_pair (old); old = ly_cdr (old))
{
SCM found = scm_assoc (ly_caar (old), newas);
if (found == SCM_BOOL_F
"Read the file @var{name}, and return its contents in a string. "
"The file is looked up using the search path and kpathsea.")
{
- SCM_ASSERT_TYPE (ly_string_p (name), name, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (name), name, SCM_ARG1, __FUNCTION__, "string");
return scm_makfrom0str
(kpathsea_gulp_file_to_string (ly_scm2string (name)).to_str0 ());
}
s = s.left_string (s.length () - 1);
SCM sid = lookup_identifier (s);
- if (ly_string_p (sid)) {
+ if (is_string (sid)) {
new_input (ly_scm2string (sid), &global_input_file->sources_);
yy_pop_state ();
} else {
String str (YYText () + 1);
SCM s = lookup_markup_command (str);
- if (ly_pair_p (s) && ly_symbol_p (ly_cdr (s)) ) {
+ if (is_pair (s) && is_symbol (ly_cdr (s)) ) {
yylval.scm = ly_car(s);
SCM tag = ly_cdr(s);
if (tag == ly_symbol2scm("markup0"))
SCM sym = ly_symbol2scm (str.to_str0 ());
if ((YYSTATE == notes) || (YYSTATE == chords)) {
SCM handle = SCM_BOOL_F;
- if (ly_pair_p (pitchname_tab_stack_))
+ if (is_pair (pitchname_tab_stack_))
handle = scm_hashq_get_handle (ly_car (pitchname_tab_stack_), sym);
- if (ly_pair_p (handle)) {
+ if (is_pair (handle)) {
yylval.scm = ly_cdr (handle);
if (unsmob_pitch (yylval.scm))
return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
- else if (ly_symbol_p (yylval.scm))
+ else if (is_symbol (yylval.scm))
return DRUM_PITCH;
}
else if ((handle = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
String
ly_symbol2string (SCM s)
{
- assert (ly_symbol_p (s));
+ assert (is_symbol (s));
return String ((Byte*)SCM_STRING_CHARS (s), (int) SCM_STRING_LENGTH (s));
}
"Read the file @var{name}, and return its contents in a string. "
"The file is looked up using the search path.")
{
- SCM_ASSERT_TYPE (ly_string_p (name), name, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (name), name, SCM_ARG1, __FUNCTION__, "string");
return scm_makfrom0str (gulp_file_to_string (ly_scm2string (name)).to_str0 ());
}
String
ly_scm2string (SCM s)
{
- assert (ly_string_p (s));
+ assert (is_string (s));
char *p = SCM_STRING_CHARS (s);
String r (p);
char *new_str;
size_t len;
- SCM_ASSERT_TYPE (ly_string_p (str), str, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (str), str, SCM_ARG1, __FUNCTION__, "string");
len = SCM_STRING_LENGTH (str);
new_str = (char *) malloc ((len + 1) * sizeof (char));
LY_DEFINE (ly_warning,"ly:warn", 1, 0, 0,
(SCM str), "Scheme callable function to issue the warning @code{msg}.")
{
- SCM_ASSERT_TYPE (ly_string_p (str), str, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (str), str, SCM_ARG1, __FUNCTION__, "string");
progress_indication ("\n");
warning ("lily-guile: " + ly_scm2string (str));
return SCM_BOOL_T;
}
-LY_DEFINE (ly_dir_p, "ly:dir?", 1,0, 0, (SCM s),
+LY_DEFINE (is_dir, "ly:dir?", 1,0, 0, (SCM s),
"type predicate. A direction is @code{-1}, @code{0} or "
"@code{1}, where @code{-1} represents "
"left or down and @code{1} represents right or up.")
{
- if (ly_number_p (s))
+ if (is_number (s))
{
int i = ly_scm2int (s);
return (i>= -1 && i <= 1) ? SCM_BOOL_T : SCM_BOOL_F;
bool
is_number_pair (SCM p)
{
- return ly_pair_p (p) && ly_number_p (ly_car (p)) && ly_number_p (ly_cdr (p));
+ return is_pair (p) && is_number (ly_car (p)) && is_number (ly_cdr (p));
}
typedef void (*Void_fptr) ();
bool
is_direction (SCM s)
{
- if (ly_number_p (s))
+ if (is_number (s))
{
int i = ly_scm2int (s);
return i>= -1 && i <= 1;
bool
is_axis (SCM s)
{
- if (ly_number_p (s))
+ if (is_number (s))
{
int i = ly_scm2int (s);
return i== 0 || i == 1;
bool
to_boolean (SCM s)
{
- return ly_boolean_p (s) && ly_scm2bool (s);
+ return is_boolean (s) && ly_scm2bool (s);
}
/* Appendable list L: the cdr contains the list, the car the last cons
1, 0, 0, (SCM s),
"Convert @var{num} to a string without generating many decimals.")
{
- SCM_ASSERT_TYPE (ly_number_p (s), s, SCM_ARG1, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (s), s, SCM_ARG1, __FUNCTION__, "number");
char str[400]; // ugh.
-LY_DEFINE (ly_dimension_p, "ly:dimension?", 1, 0, 0, (SCM d),
+LY_DEFINE (is_dimension, "ly:dimension?", 1, 0, 0, (SCM d),
"Return @var{d} is a number. Used to distinguish length "
"variables from normal numbers.")
{
SCM
ly_deep_copy (SCM src)
{
- if (ly_pair_p (src))
+ if (is_pair (src))
return scm_cons (ly_deep_copy (ly_car (src)), ly_deep_copy (ly_cdr (src)));
- else if (ly_vector_p (src))
+ else if (is_vector (src))
{
int len = SCM_VECTOR_LENGTH (src);
SCM nv = scm_c_make_vector (len, SCM_UNDEFINED);
SCM
ly_assoc_chain (SCM key, SCM achain)
{
- if (ly_pair_p (achain))
+ if (is_pair (achain))
{
SCM handle = scm_assoc (key, ly_car (achain));
- if (ly_pair_p (handle))
+ if (is_pair (handle))
return handle;
else
return ly_assoc_chain (key, ly_cdr (achain));
SCM
ly_assoc_cdr (SCM key, SCM alist)
{
- if (ly_pair_p (alist))
+ if (is_pair (alist))
{
SCM trykey = ly_caar (alist);
- if (ly_pair_p (trykey) && to_boolean (scm_equal_p (key, ly_cdr (trykey))))
+ if (is_pair (trykey) && to_boolean (scm_equal_p (key, ly_cdr (trykey))))
return ly_car (alist);
else
return ly_assoc_cdr (key, ly_cdr (alist));
{
SCM s = lst;
k--;
- for (; ly_pair_p (s) && k--; s = ly_cdr (s))
+ for (; is_pair (s) && k--; s = ly_cdr (s))
;
- if (ly_pair_p (s))
+ if (is_pair (s))
scm_set_cdr_x (s, SCM_EOL);
}
return lst;
if (val == SCM_EOL || val == SCM_BOOL_F)
return ok;
- if (!ly_symbol_p (sym))
+ if (!is_symbol (sym))
#if 0
return false;
#else
SCM type = scm_object_property (sym, type_symbol);
- if (type != SCM_EOL && !ly_procedure_p (type))
+ if (type != SCM_EOL && !is_procedure (type))
{
warning (_f ("Can't find property type-check for `%s' (%s).",
ly_symbol2string (sym).to_str0 (),
else
{
if (val != SCM_EOL
- && ly_procedure_p (type)
+ && is_procedure (type)
&& scm_call_1 (type, val) == SCM_BOOL_F)
{
SCM errport = scm_current_error_port ();
ly_unique (SCM list)
{
SCM unique = SCM_EOL;
- for (SCM i = list; ly_pair_p (i); i = ly_cdr (i))
+ for (SCM i = list; is_pair (i); i = ly_cdr (i))
{
- if (!ly_pair_p (ly_cdr (i))
- || !ly_equal_p (ly_car (i), ly_cadr (i)))
+ if (!is_pair (ly_cdr (i))
+ || !is_equal (ly_car (i), ly_cadr (i)))
unique = scm_cons (ly_car (i), unique);
}
return scm_reverse_x (unique, SCM_EOL);
{
SCM before = SCM_EOL;
SCM after = list;
- for (; ly_pair_p (after);)
+ for (; is_pair (after);)
{
SCM i = ly_car (after);
after = ly_cdr (after);
- if (ly_equal_p (i, s))
+ if (is_equal (i, s))
break;
before = scm_cons (i, before);
}
SCM p = scm_current_output_port ();
scm_puts ("(", p);
- for (; ly_pair_p (s); s =ly_cdr (s))
+ for (; is_pair (s); s =ly_cdr (s))
{
scm_display (ly_car (s), p);
scm_puts (" ", p);
{
Slice s;
s.set_empty ();
- for (; ly_pair_p (l); l = ly_cdr (l))
- if (ly_number_p (ly_car (l)))
+ for (; is_pair (l); l = ly_cdr (l))
+ if (is_number (ly_car (l)))
s.add_point (ly_scm2int (ly_car (l)));
return s;
}
SCM
robust_list_ref (int i, SCM l)
{
- while (i-- > 0 && ly_pair_p (ly_cdr (l)))
+ while (i-- > 0 && is_pair (ly_cdr (l)))
l = ly_cdr (l);
return ly_car (l);
}
Real
robust_scm2double (SCM k, double x)
{
- if (ly_number_p (k))
+ if (is_number (k))
x = ly_scm2double (k);
return x;
}
return scm_make_vector (scm_int2num (0), SCM_EOL);
SCM tab = scm_make_vector (scm_int2num (i), SCM_EOL);
- for (SCM s = alist; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = alist; is_pair (s); s = ly_cdr (s))
{
SCM pt = ly_cdar (s);
scm_hashq_set_x (tab, ly_caar (s), pt);
SCM type = me->get_property ("style");
SCM dash_fraction = me->get_property ("dash-fraction");
- if (ly_number_p (dash_fraction) || type == ly_symbol2scm ("dotted-line"))
+ if (is_number (dash_fraction) || type == ly_symbol2scm ("dotted-line"))
{
Real fraction
{
Offset dz = to -from ;
SCM type = me->get_property ("style");
- if (ly_symbol_p (type)
+ if (is_symbol (type)
&& (type == ly_symbol2scm ("line")
|| type == ly_symbol2scm ("dashed-line")
|| type == ly_symbol2scm ("dotted-line")
? zigzag_stencil (me, from, to)
: Line_interface::line (me, from, to);
}
- else if (ly_symbol_p (type)
+ else if (is_symbol (type)
&& type == ly_symbol2scm ("trill"))
{
SCM alist_chain = Font_interface::text_font_alist_chain (me);
{
SCM_ASSERT_TYPE (is_axis (a), a, SCM_ARG1, __FUNCTION__, "axis") ;
SCM_ASSERT_TYPE (is_number_pair (iv), iv, SCM_ARG2, __FUNCTION__, "number pair") ;
- SCM_ASSERT_TYPE (ly_number_p (t), a, SCM_ARG3, __FUNCTION__, "number") ;
- SCM_ASSERT_TYPE (ly_number_p (p), a, SCM_ARG4, __FUNCTION__, "number") ;
+ SCM_ASSERT_TYPE (is_number (t), a, SCM_ARG3, __FUNCTION__, "number") ;
+ SCM_ASSERT_TYPE (is_number (p), a, SCM_ARG4, __FUNCTION__, "number") ;
return Lookup::bracket ((Axis)ly_scm2int (a), ly_scm2interval (iv),
{
SCM_ASSERT_TYPE (is_number_pair (xext), xext, SCM_ARG1, __FUNCTION__, "number pair") ;
SCM_ASSERT_TYPE (is_number_pair (yext), yext, SCM_ARG2, __FUNCTION__, "number pair") ;
- SCM_ASSERT_TYPE (ly_number_p (blot), blot, SCM_ARG3, __FUNCTION__, "number") ;
+ SCM_ASSERT_TYPE (is_number (blot), blot, SCM_ARG3, __FUNCTION__, "number") ;
return Lookup::round_filled_box (Box (ly_scm2interval (xext), ly_scm2interval (yext)),
ly_scm2double (blot)).smobbed_copy ();
SCM s = anon_modules;
anon_modules = SCM_EOL;
- for (; ly_pair_p (s) ; s = ly_cdr (s))
+ for (; is_pair (s) ; s = ly_cdr (s))
{
SCM tab= scm_c_make_hash_table (2);
/* UGH. */
SCM melisma_properties = tr->get_property ("melismaBusyProperties");
bool busy = false;
- for (; ly_pair_p (melisma_properties);
+ for (; is_pair (melisma_properties);
melisma_properties = ly_cdr (melisma_properties))
busy = busy || to_boolean (tr->internal_get_property (ly_car (melisma_properties)));
SCM grobs = tr->get_property ("busyGrobs");
Moment now = tr->now_mom ();
- for (; ly_pair_p (grobs); grobs = ly_cdr (grobs))
+ for (; is_pair (grobs); grobs = ly_cdr (grobs))
{
SCM grob = ly_cdar (grobs);
Moment end =*unsmob_moment (ly_caar (grobs));
Lyric_combine_music::get_music () const
{
SCM l = get_property ("elements");
- if (!ly_pair_p (l))
+ if (!is_pair (l))
return 0;
return unsmob_music (ly_car (l));
}
Lyric_combine_music::get_lyrics () const
{
SCM l = get_property ("elements");
- if (!ly_pair_p (l))
+ if (!is_pair (l))
return 0;
l = ly_cdr (l);
- if (!ly_pair_p (l))
+ if (!is_pair (l))
return 0;
return unsmob_music (ly_car (l));
}
SCM voice = lyrics->get_property ("associatedVoice");
String nm = lyrics->id_string_;
- if (ly_string_p (voice))
+ if (is_string (voice))
nm = ly_scm2string (voice);
else
{
get_current_note_head (Context * voice)
{
for (SCM s = voice->get_property ("busyGrobs");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Item*g = dynamic_cast<Item*> (unsmob_grob (ly_cdar (s)));
{
// FIXME: won't work with fancy lyrics
if (lreqs_.size ()
- && ly_string_p (lreqs_[0]->get_property ("text"))
+ && is_string (lreqs_[0]->get_property ("text"))
&& ly_scm2string (lreqs_[0]->get_property ("text")).length ())
{
audio_ = new Audio_text (Audio_text::LYRIC,
SCM m = mark_ev_->get_property ("label");
SCM proc = get_property ("markFormatter");
if (!Text_item::markup_p (m) &&
- ly_procedure_p (proc))
+ is_procedure (proc))
{
- if (!ly_number_p (m))
+ if (!is_number (m))
m = get_property ("rehearsalMark");
if (scm_integer_p (m) == SCM_BOOL_T
scm_int2num (mark_count));
}
- if (ly_number_p (m))
+ if (is_number (m))
m = scm_call_2 (proc, m, daddy_context_->self_scm ());
else
warning ("rehearsalMark does not have integer value.");
return;
SCM grouping = get_property ("beatGrouping");
- if (ly_pair_p (grouping))
+ if (is_pair (grouping))
{
Moment *measpos = unsmob_moment (get_property ("measurePosition"));
Rational mp = measpos->main_part_;
Rational bl = beatlen->main_part_;
Rational where (0);
- for (SCM s = grouping; ly_pair_p (s);
+ for (SCM s = grouping; is_pair (s);
where += Rational (ly_scm2int (ly_car (s))) * bl,
s = ly_cdr (s)
)
= ly_scm2int (get_property ("currentBarNumber"));
}
- bar_seen_ = ly_string_p (get_property ("whichBar"));
+ bar_seen_ = is_string (get_property ("whichBar"));
}
void
{
SCM thres = get_property ("restNumberThreshold");
int t = 1;
- if (ly_number_p (thres))
+ if (is_number (thres))
t = ly_scm2int (thres);
if (num <= t)
int measures = 0;
SCM m (me->get_property ("measure-count"));
- if (ly_number_p (m))
+ if (is_number (m))
{
measures = ly_scm2int (m);
}
{
int measures = 0;
SCM m (me->get_property ("measure-count"));
- if (ly_number_p (m))
+ if (is_number (m))
{
measures = ly_scm2int (m);
}
}
Stencil mol;
- for (SCM s = mols; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = mols; is_pair (s); s = ly_cdr (s))
{
mol.add_at_edge (X_AXIS, LEFT, *unsmob_stencil (ly_car (s)), inner_padding, 0);
}
SCM ctor = m->get_property ("iterator-ctor") ;
SCM iter = SCM_EOL;
- if (ly_procedure_p (ctor))
+ if (is_procedure (ctor))
{
iter = scm_call_0 (ctor);
p = unsmob_iterator (iter);
scm_gc_unprotect_object (translator_tab_->self_scm ());
scope_= ly_make_anonymous_module ();
- if (ly_module_p (s.scope_))
+ if (is_module (s.scope_))
ly_import_module (scope_, s.scope_);
}
{
Music_output_def *op = unsmob_music_output_def (pap);
SCM_ASSERT_TYPE (op, pap, SCM_ARG1, __FUNCTION__, "Paper");
- SCM_ASSERT_TYPE (ly_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
SCM var = ly_module_lookup (op->scope_, sym);
if (SCM_VARIABLEP (var))
void
transpose_music_list (SCM l, Pitch rq)
{
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
unsmob_music (ly_car (s))->transpose (rq);
}
Moment cumulative;
Moment last_len;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
Moment l = unsmob_music (ly_car (s))->get_length ();
if (last_len.grace_part_ && l.main_part_)
Music_sequence::maximum_length (SCM l)
{
Moment dur = 0;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
Music * m = unsmob_music (ly_car (s));
Moment l = m->get_length ();
int count=0;
Pitch last = p;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
if (Music *m = unsmob_music (ly_car (s)))
{
void
compress_music_list (SCM l, Moment m)
{
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
unsmob_music (ly_car (s))->compress (m);
}
{
Moment m;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
m = m <? unsmob_music (ly_car (s))->start_mom ();
}
{
Moment m;
- for (SCM s = l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = l; is_pair (s); s = ly_cdr (s))
{
Music * mus = unsmob_music (ly_car (s));
Moment l = mus->get_length ();
Music::name () const
{
SCM nm = get_property ("name");
- if (ly_symbol_p (nm))
+ if (is_symbol (nm))
{
return ly_symbol2string (nm);
}
SCM lst = get_property ("length");
if (unsmob_moment (lst))
return *unsmob_moment (lst);
- else if (ly_procedure_p (lst))
+ else if (is_procedure (lst))
{
SCM res = scm_call_1 (lst, self_scm ());
return *unsmob_moment (res);
Music::start_mom () const
{
SCM lst = get_property ("start-moment-function");
- if (ly_procedure_p (lst))
+ if (is_procedure (lst))
{
SCM res = scm_call_1 (lst, self_scm ());
return *unsmob_moment (res);
print_alist (SCM a, SCM port)
{
/* SCM_EOL -> catch malformed lists. */
- for (SCM s = a; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = a; is_pair (s); s = ly_cdr (s))
{
scm_display (ly_caar (s), port);
scm_puts (" = ", port);
Music* m = unsmob_music (s);
SCM nm = m->get_property ("name");
- if (ly_symbol_p (nm) || ly_string_p (nm))
+ if (is_symbol (nm) || is_string (nm))
scm_display (nm, p);
else
scm_puts (classname (m),p);
{
Music * sc = unsmob_music (mus);
SCM_ASSERT_TYPE (sc, mus, SCM_ARG1, __FUNCTION__, "music");
- SCM_ASSERT_TYPE (ly_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
return sc->internal_get_property (sym);
}
{
Music * sc = unsmob_music (mus);
SCM_ASSERT_TYPE (sc, mus, SCM_ARG1, __FUNCTION__, "music");
- SCM_ASSERT_TYPE (ly_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
+ SCM_ASSERT_TYPE (is_symbol (sym), sym, SCM_ARG2, __FUNCTION__, "symbol");
bool ok = type_check_assignment (sym, val, ly_symbol2scm ("music-type?"));
if (ok)
"for creating music objects. "
)
{
- SCM_ASSERT_TYPE (ly_string_p (type), type, SCM_ARG1, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE (is_string (type), type, SCM_ARG1, __FUNCTION__, "string");
SCM s = make_music (ly_scm2string (type))->self_scm ();
unsmob_music (s)->immutable_property_alist_ = props;
scm_gc_unprotect_object (s);
"of music objects.")
{
if (scm_list_p (lst) == SCM_BOOL_T)
- while (ly_pair_p (lst))
+ while (is_pair (lst))
{
if (!unsmob_music (ly_car (lst)))
return SCM_BOOL_F;
copy = unsmob_music (m)->clone ()->self_scm ();
scm_gc_unprotect_object (copy);
}
- else if (ly_pair_p (m))
+ else if (is_pair (m))
copy = scm_cons (ly_deep_mus_copy (ly_car (m)),
ly_deep_mus_copy (ly_cdr (m)));
return copy;
{
ly_reexport_module (scm_current_module ());
scm_set_current_module (module);
- for (SCM s = scopes_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = scopes_; is_pair (s); s = ly_cdr (s))
{
/* UGH. how to do this more neatly? */
SCM expr
My_lily_lexer::lookup_identifier (String s)
{
SCM sym = ly_symbol2scm (s.to_str0());
- for (SCM s = scopes_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = scopes_; is_pair (s); s = ly_cdr (s))
{
SCM var = ly_module_lookup (ly_car (s), sym);
if (var != SCM_BOOL_F)
void
My_lily_lexer::set_identifier (SCM name, SCM s)
{
- assert (ly_string_p (name));
+ assert (is_string (name));
if (lookup_keyword (ly_scm2string (name)) >= 0)
{
SCM al = p->translator_tab_->to_alist ();
SCM l = SCM_EOL;
- for (SCM s = al ; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = al ; is_pair (s); s = ly_cdr (s))
{
Context_def * td = unsmob_context_def (ly_cdar (s));
l = scm_cons (scm_cons (ly_caar (s), td->to_alist ()), l);
SCM arts = note_ev->get_property ("articulations");
- for (SCM s = arts; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = arts; is_pair (s); s = ly_cdr (s))
{
Music * m = unsmob_music (ly_car (s));
sc->set_property ("direction-source", stem_->self_scm ());
SCM follow = scm_assoc (ly_symbol2scm ("follow-into-staff"), articulations_[i].description_);
- if (ly_pair_p (follow) && to_boolean (ly_cdr (follow)))
+ if (is_pair (follow) && to_boolean (ly_cdr (follow)))
{
sc->add_offset_callback (Side_position_interface::quantised_position_proc, Y_AXIS);
sc->set_property ("staff-padding" , SCM_EOL);
{
SCM voice_name = get_music ()->get_property ("associated-context");
- if (ly_string_p (voice_name))
+ if (is_string (voice_name))
{
Context *t = get_outlet ();
while (t && t->daddy_context_)
/* Do not merge notes typeset in different style. */
- if ( !ly_equal_p (nu->get_property ("style"),
+ if ( !is_equal (nu->get_property ("style"),
nd->get_property ("style") ) )
merge_possible = false;
while (flip (&d) != UP);
Link_array<Grob> done;
- for (; ly_pair_p (hand); hand =ly_cdr (hand))
+ for (; is_pair (hand); hand =ly_cdr (hand))
{
Grob * s = unsmob_grob (ly_caar (hand));
Real amount = ly_scm2double (ly_cdar (hand));
s->translate_axis (amount *wid, X_AXIS);
done.push (s);
}
- for (; ly_pair_p (autos); autos =ly_cdr (autos))
+ for (; is_pair (autos); autos =ly_cdr (autos))
{
Grob * s = unsmob_grob (ly_caar (autos));
Real amount = ly_scm2double (ly_cdar (autos));
Drul_array<Link_array<Grob> > clash_groups;
SCM s = me->get_property ("elements");
- for (; ly_pair_p (s); s = ly_cdr (s))
+ for (; is_pair (s); s = ly_cdr (s))
{
SCM car = ly_car (s);
SCM sh
= clashes[i]->get_property ("horizontal-shift");
- if (ly_number_p (sh))
+ if (is_number (sh))
shift.push (ly_scm2int (sh));
else
shift.push (0);
SCM tups = SCM_EOL;
SCM s = me->get_property ("elements");
- for (; ly_pair_p (s); s = ly_cdr (s))
+ for (; is_pair (s); s = ly_cdr (s))
{
Grob * se = unsmob_grob (ly_car (s));
SCM force = se->get_property ("force-hshift");
- if (ly_number_p (force))
+ if (is_number (force))
{
tups = scm_cons (scm_cons (se->self_scm (), force),
tups);
SCM s1 = p1->get_property ("horizontal-shift");
SCM s2 = p2->get_property ("horizontal-shift");
- int h1 = (ly_number_p (s1))? ly_scm2int (s1) :0;
- int h2 = (ly_number_p (s2)) ? ly_scm2int (s2):0;
+ int h1 = (is_number (s1))? ly_scm2int (s1) :0;
+ int h2 = (is_number (s2)) ? ly_scm2int (s2):0;
return h1 - h2;
}
iv.set_empty ();
SCM h = me->get_property ("note-heads");
- for (; ly_pair_p (h); h = ly_cdr (h))
+ for (; is_pair (h); h = ly_cdr (h))
{
Grob *se = unsmob_grob (ly_car (h));
Grob *stem = unsmob_grob (me->get_property ("stem"));
if (stem && Stem::has_interface (stem))
return Stem::get_direction (stem);
- else if (ly_pair_p (me->get_property ("note-heads")))
+ else if (is_pair (me->get_property ("note-heads")))
return (Direction)sign (head_positions_interval (me).center ());
programming_error ("Note column without heads and stem!");
bool both = false;
if (Rest::has_interface (h))
{
- if (ly_pair_p (me->get_property ("note-heads")))
+ if (is_pair (me->get_property ("note-heads")))
both = true;
else
me->set_property ("rest", h->self_scm ());
Note_column::translate_rests (Grob*me, int dy)
{
Grob * r = unsmob_grob (me->get_property ("rest"));
- if (r && !ly_number_p (r->get_property ("staff-position")))
+ if (r && !is_number (r->get_property ("staff-position")))
{
r->translate_axis (dy * Staff_symbol_referencer::staff_space (r)/2.0, Y_AXIS);
}
{
SCM heads = me->get_property ("note-heads");
Grob * acc = 0;
- for (;ly_pair_p (heads); heads =ly_cdr (heads))
+ for (;is_pair (heads); heads =ly_cdr (heads))
{
Grob * h = unsmob_grob (ly_car (heads));
acc = h ? unsmob_grob (h->get_property ("accidental-grob")) : 0;
internal_print (Grob *me, bool with_ledgers)
{
SCM style = me->get_property ("style");
- if (!ly_symbol_p (style))
+ if (!is_symbol (style))
{
return Stencil ();
}
SCM idx = scm_int2num (pit->get_notename ());
SCM names = me->get_property ("note-names");
SCM charstr = SCM_EOL;
- if (ly_vector_p (names))
+ if (is_vector (names))
charstr = scm_vector_ref (names, idx);
else
{
if (brewer == Note_head::print_proc)
{
SCM style = me->get_property ("style");
- if (!ly_symbol_p (style))
+ if (!is_symbol (style))
{
return 0.0;
}
Fallback
*/
SCM v = me->get_property ("stem-attachment-function");
- if (!ly_procedure_p (v))
+ if (!is_procedure (v))
return 0.0;
SCM result = scm_call_2 (v, me->self_scm (), scm_int2num (a));
- if (!ly_pair_p (result))
+ if (!is_pair (result))
return 0.0;
result = (a == X_AXIS) ? ly_car (result) : ly_cdr (result);
Note_head::get_balltype (Grob*me)
{
SCM s = me->get_property ("duration-log");
- return ly_number_p (s) ? ly_scm2int (s) <? 2 : 0;
+ return is_number (s) ? ly_scm2int (s) <? 2 : 0;
}
ADD_INTERFACE (Note_head,"note-head-interface",
int pos = pit ? pit->steps () : 0;
SCM c0 = get_property ("middleCPosition");
- if (ly_number_p (c0))
+ if (is_number (c0))
pos += ly_scm2int (c0);
note->set_property ("staff-position", scm_int2num (pos));
Interval left_head_wid;
do
{
- for (SCM s = props[d]; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = props[d]; is_pair (s); s = ly_cdr (s))
{
Item * it= dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
Item *mincol = 0;
int min_rank = INT_MAX;
bool prune = false;
- for (SCM s = right ; ly_pair_p (s) ; s = ly_cdr (s))
+ for (SCM s = right ; is_pair (s) ; s = ly_cdr (s))
{
Item * ri = unsmob_item (ly_car (s));
{
// I'm a lazy bum. We could do this in-place.
SCM newright = SCM_EOL;
- for (SCM s = right ; ly_pair_p (s) ; s =ly_cdr (s))
+ for (SCM s = right ; is_pair (s) ; s =ly_cdr (s))
{
if (unsmob_item (ly_car (s))->get_column () == mincol)
newright = scm_cons (ly_car (s), newright);
do
{
- for (SCM s = props[d]; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = props[d]; is_pair (s); s = ly_cdr (s))
{
Item * it= dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
Interval ext;
if (Note_column::has_interface (b))
{
- for (SCM s = b->get_property ("note-heads"); ly_pair_p (s); s =ly_cdr (s))
+ for (SCM s = b->get_property ("note-heads"); is_pair (s); s =ly_cdr (s))
ext.unite (unsmob_grob (ly_car (s))->extent (common, X_AXIS));
}
{
finished_= span_;
span_ = 0;
- if (ly_string_p (ott))
+ if (is_string (ott))
{
span_ = make_spanner ("OttavaBracket");
span_->set_property ("text", ott);
- if (ly_procedure_p (pred))
+ if (is_procedure (pred))
{
/*
should typecheck pred.
"Return a vector with line numbers of page breaks.")
{
SCM_ASSERT_TYPE (scm_pair_p (lines), lines, SCM_ARG1, __FUNCTION__, "list");
- SCM_ASSERT_TYPE (ly_number_p (book), book, SCM_ARG2, __FUNCTION__, "real");
- SCM_ASSERT_TYPE (ly_number_p (text), text, SCM_ARG2, __FUNCTION__, "real");
- SCM_ASSERT_TYPE (ly_number_p (first), first, SCM_ARG2, __FUNCTION__, "real");
- SCM_ASSERT_TYPE (ly_number_p (last), last, SCM_ARG2, __FUNCTION__, "real");
+ SCM_ASSERT_TYPE (is_number (book), book, SCM_ARG2, __FUNCTION__, "real");
+ SCM_ASSERT_TYPE (is_number (text), text, SCM_ARG2, __FUNCTION__, "real");
+ SCM_ASSERT_TYPE (is_number (first), first, SCM_ARG2, __FUNCTION__, "real");
+ SCM_ASSERT_TYPE (is_number (last), last, SCM_ARG2, __FUNCTION__, "real");
return c_ragged_page_breaks (lines,
ly_scm2double (book), ly_scm2double (text),
bool
Paper_column::is_used (Grob*me)
{
- return ly_pair_p (me->get_property ("elements")) || Item::is_breakable (me)
- || ly_pair_p (me->get_property ("bounded-by-me"))
+ return is_pair (me->get_property ("elements")) || Item::is_breakable (me)
+ || is_pair (me->get_property ("bounded-by-me"))
;
}
SCM c = me->get_property ("bounded-by-me");
SCM *ptrptr = &c;
- while (ly_pair_p (*ptrptr))
+ while (is_pair (*ptrptr))
{
Grob * g = unsmob_grob (ly_car (*ptrptr));
Font_metric *
-Paper_def::find_scaled_font (Font_metric *f, Real m)
+Paper_def::find_scaled_font (Font_metric *f, Real m, SCM input_enc_name)
{
SCM sizes = scm_hashq_ref (scaled_fonts_, f->self_scm (), SCM_BOOL_F);
if (sizes != SCM_BOOL_F)
{
SCM met = scm_assoc (scm_make_real (m), sizes);
- if (ly_pair_p (met))
+ if (is_pair (met))
return unsmob_metrics (ly_cdr (met));
}
else
*/
SCM l = SCM_EOL;
SCM *t = &l;
- for (SCM s = vf->get_font_list (); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = vf->get_font_list (); is_pair (s); s = ly_cdr (s))
{
Font_metric*scaled
- = find_scaled_font (unsmob_metrics (ly_car (s)), m);
+ = find_scaled_font (unsmob_metrics (ly_car (s)), m, input_enc_name);
*t = scm_cons (scaled->self_scm (), SCM_EOL);
t = SCM_CDRLOC(*t);
}
else
{
SCM scale_var = ly_module_lookup (scope_, ly_symbol2scm ("outputscale"));
- SCM coding_var = ly_module_lookup (scope_, ly_symbol2scm ("inputencoding"));
+ if (!is_symbol (input_enc_name))
+ {
+ SCM var = ly_module_lookup (scope_, ly_symbol2scm ("inputencoding"));
+ input_enc_name = scm_variable_ref (var);
+ }
m /= ly_scm2double (scm_variable_ref (scale_var));
- val = Modified_font_metric::make_scaled_font_metric (scm_variable_ref (coding_var),
- f, m);
+ val = Modified_font_metric::make_scaled_font_metric (input_enc_name, f, m);
}
sizes = scm_acons (scm_make_real (m), val, sizes);
SCM func = ly_scheme_function ("hash-table->alist");
SCM l = SCM_EOL;
- for (SCM s = scm_call_1 (func, scaled_fonts_); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = scm_call_1 (func, scaled_fonts_); is_pair (s); s = ly_cdr (s))
{
SCM entry = ly_car (s);
- for (SCM t = ly_cdr (entry); ly_pair_p (t); t = ly_cdr (t))
+ for (SCM t = ly_cdr (entry); is_pair (t); t = ly_cdr (t))
{
Font_metric *fm= unsmob_metrics (ly_cdar (t));
}
SCM between = SCM_EOL;
- for (SCM s = pl->stencils (); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = pl->stencils (); is_pair (s); s = ly_cdr (s))
{
Stencil *stil = unsmob_stencil (ly_car (s));
if (stil)
{
while (1)
{
- if (!ly_pair_p (expr))
+ if (!is_pair (expr))
return;
SCM head =ly_car (expr);
tag_music (Music *m, SCM tag, Input ip)
{
SCM tags = m->get_property ("tags");
- if (ly_symbol_p (tag))
+ if (is_symbol (tag))
tags = scm_cons (tag, tags);
- else if (ly_list_p (tag))
+ else if (is_list (tag))
tags = ly_append2 (tag, tags);
else
ip.warning (_ ("Tag must be symbol or list of symbols."));
make_simple_markup (SCM encoding, SCM a)
{
SCM simple = ly_scheme_function ("simple-markup");
- SCM markup =
if (gh_symbol_p (encoding))
{
return scm_list_3 (ly_scheme_function ("encoded-simple-markup"),
void
set_music_properties (Music *p, SCM a)
{
- for (SCM k = a; ly_pair_p (k); k = ly_cdr (k))
+ for (SCM k = a; is_pair (k); k = ly_cdr (k))
p->internal_set_property (ly_caar (k), ly_cdar (k));
}
bool
ly_input_procedure_p (SCM x)
{
- return ly_procedure_p (x)
- || (ly_pair_p (x) && ly_procedure_p (ly_car (x)));
+ return is_procedure (x)
+ || (is_pair (x) && is_procedure (ly_car (x)));
}
Music*
| score_block {
Score *sc = $1;
- SCM head = ly_module_p (sc->header_) ? sc->header_ : THIS->input_file_->header_.to_SCM ();
+ SCM head = is_module (sc->header_) ? sc->header_ : THIS->input_file_->header_.to_SCM ();
Path p = split_path (THIS->output_basename_);
int *c = &THIS->input_file_->score_count_;
| context_def_spec_body GROBDESCRIPTIONS embedded_scm {
Context_def*td = unsmob_context_def ($$);
- for (SCM p = $3; ly_pair_p (p); p = ly_cdr (p)) {
+ for (SCM p = $3; is_pair (p); p = ly_cdr (p)) {
SCM tag = ly_caar (p);
/* TODO: should make new tag "grob-definition" ? */
guh.
*/
SCM check_funcs = ly_scheme_function ("toplevel-music-functions");
- for (; ly_pair_p (check_funcs); check_funcs = ly_cdr (check_funcs))
+ for (; is_pair (check_funcs); check_funcs = ly_cdr (check_funcs))
m = scm_call_1 (ly_car (check_funcs), m);
$$->music_ = m;
SCM s = $$;
SCM c = scm_cons ($2->self_scm (), SCM_EOL);
scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
- if (ly_pair_p (ly_cdr (s)))
+ if (is_pair (ly_cdr (s)))
scm_set_cdr_x (ly_cdr (s), c); /* append */
else
scm_set_car_x (s, c); /* set first cons */
{
Music *beg = $4;
int times = $3;
- SCM alts = ly_pair_p ($5) ? ly_car ($5) : SCM_EOL;
+ SCM alts = is_pair ($5) ? ly_car ($5) : SCM_EOL;
if (times < scm_ilength (alts)) {
unsmob_music (ly_car (alts))
->origin ()->warning (
r->set_property ("repeat-count", scm_int2num (times >? 1));
r-> set_property ("elements",alts);
- if (ly_equal_p ($2, scm_makfrom0str ("tremolo"))) {
+ if (is_equal ($2, scm_makfrom0str ("tremolo"))) {
/*
TODO: move this code to Scheme.
*/
SCM es = $1->get_property ("elements");
SCM postevs = scm_reverse_x ($3, SCM_EOL);
- for (SCM s = es; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = es; is_pair (s); s = ly_cdr (s))
unsmob_music (ly_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
if ($2 % 2 || $3 % 2)
n->set_property ("force-accidental", SCM_BOOL_T);
- if (ly_pair_p ($4)) {
+ if (is_pair ($4)) {
SCM arts = scm_reverse_x ($4, SCM_EOL);
n->set_property ("articulations", arts);
}
n->set_property ("drum-type", $1);
n->set_spot (THIS->here_input ());
- if (ly_pair_p ($2)) {
+ if (is_pair ($2)) {
SCM arts = scm_reverse_x ($2, SCM_EOL);
n->set_property ("articulations", arts);
}
evs = scm_hash_ref (tab, key, SCM_BOOL_F);
}
Music *quote = 0;
- if (ly_vector_p (evs))
+ if (is_vector (evs))
{
quote = MY_MAKE_MUSIC ("QuoteMusic");
quote->set_property ("duration", $3);
| script_abbreviation {
SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
- if (ly_string_p (s))
+ if (is_string (s))
a->set_property ("articulation-type", s);
else THIS->parser_error (_ ("Expecting string as script definition"));
$$ = a;
Music *m = unsmob_music ($1);
if ($2) {
SCM salter = m->get_property ("alteration");
- int alter = ly_number_p (salter) ? ly_scm2int (salter) : 0;
+ int alter = is_number (salter) ? ly_scm2int (salter) : 0;
m->set_property ("alteration",
scm_int2num (alter + $2));
} else {
n->set_property ("pitch", $1);
n->set_property ("duration", $5);
- if (ly_number_p ($4))
+ if (is_number ($4))
{
int q = ly_scm2int ($4);
n->set_property ("absolute-octave", scm_int2num (q-1));
Music *m = unsmob_music ($1);
Input i = THIS->pop_spot ();
m->set_spot (i);
- for (SCM s = m->get_property ("elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = m->get_property ("elements"); is_pair (s); s = ly_cdr (s))
{
unsmob_music (ly_car (s))->set_property ("duration", $2);
}
int
My_lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
{
- if (ly_string_p (sid)) {
+ if (is_string (sid)) {
*destination = sid;
return STRING_IDENTIFIER;
- } else if (ly_number_p (sid)) {
+ } else if (is_number (sid)) {
*destination = sid;
return NUMBER_IDENTIFIER;
} else if (unsmob_context_def (sid)) {
bool itc = internal_type_checking_global_b;
/* UGH.
*/
- bool autobeam = ly_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
+ bool autobeam = is_equal (symbol, ly_symbol2scm ("autoBeamSettings"));
if (autobeam)
internal_type_checking_global_b = false;
m->set_property ("grob-property", grob_sym);
scm_gc_unprotect_object (m->self_scm ());
csm->set_property ("context-type",
- ly_symbol_p (type) ? type : scm_string_to_symbol (type));
+ is_symbol (type) ? type : scm_string_to_symbol (type));
csm->set_property ("property-operations", ops);
- if (ly_string_p (id))
+ if (is_string (id))
csm->set_property ("context-id", id);
return csm;
}
Moment now = get_outlet ()->now_mom ();
Moment *splitm = 0;
- for (; ly_pair_p (split_list_); split_list_ = ly_cdr (split_list_))
+ for (; is_pair (split_list_); split_list_ = ly_cdr (split_list_))
{
splitm = unsmob_moment (ly_caar (split_list_));
if (splitm && *splitm + start_moment_ > now)
solo1 ();
else if (tag == ly_symbol2scm ("solo2"))
solo2 ();
- else if (ly_symbol_p (tag))
+ else if (is_symbol (tag))
{
String s = "Unknown split directive: "
- + (ly_symbol_p (tag) ? ly_symbol2string (tag) : String ("not a symbol"));
+ + (is_symbol (tag) ? ly_symbol2string (tag) : String ("not a symbol"));
programming_error (s);
}
}
{
Audio_element_info info = announce_infos_[j];
- for (SCM p = get_simple_trans_list (); ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = get_simple_trans_list (); is_pair (p); p = ly_cdr (p))
{
Translator * t = unsmob_translator (ly_car (p));
Performer * eng = dynamic_cast<Performer*> (t);
void
performer_each (SCM list, Performer_method method)
{
- for (SCM p = list; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = list; is_pair (p); p = ly_cdr (p))
{
Performer * e = dynamic_cast<Performer*>(unsmob_translator (ly_car (p)));
if (e)
for (Pedal_info*p = info_list_; p->name_; p ++)
{
String nm = p->name_ + String ("Event");
- if (ly_equal_p (m->get_property ("name") ,
+ if (is_equal (m->get_property ("name") ,
scm_str2symbol(nm.to_str0())))
{
Direction d = to_dir (m->get_property ("span-direction"));
}
}
- if (ly_string_p (s))
+ if (is_string (s))
{
String propname = String (p->name_) + "Pedal";
for (Pedal_info*p = info_alist_; p->name_; p ++)
{
String nm = p->name_ + String ("Event");
- if (ly_equal_p (r->get_property ("name") ,
+ if (is_equal (r->get_property ("name") ,
scm_str2symbol (nm.to_str0())))
{
Direction d = to_dir (r->get_property ("span-direction"));
Pitch_squash_engraver::acknowledge_grob (Grob_info i)
{
SCM newpos = get_property ("squashedPosition");
- if (ly_number_p (newpos)
+ if (is_number (newpos)
&& Note_head::has_interface (i.grob_))
{
i.grob_->set_property ("staff-position", newpos);
Property_iterator::process (Moment m)
{
SCM sym = get_music ()->get_property ("symbol");
- if (ly_symbol_p (sym))
+ if (is_symbol (sym))
{
SCM val = get_music ()->get_property ("value");
bool ok= true;
start_moment_ = now;
event_vector_ = get_music ()->get_property ("quoted-events");
- if (ly_vector_p (event_vector_))
+ if (is_vector (event_vector_))
{
event_idx_ = binsearch_scm_vector (event_vector_, now.smobbed_copy (), &moment_less);
end_idx_ = binsearch_scm_vector (event_vector_, stop.smobbed_copy (), &moment_less);
event_idx_++;
}
- if (ly_pair_p (entry))
+ if (is_pair (entry))
{
Pitch * quote_pitch = unsmob_pitch (ly_cdar (entry));
Pitch * me_pitch = unsmob_pitch (get_outlet ()->get_property ("instrumentTransposition"));
- for (SCM s = ly_cdr (entry); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = ly_cdr (entry); is_pair (s); s = ly_cdr (s))
{
SCM ev_acc = ly_car (s);
void
Recording_group_engraver::start ()
{
- if (!ly_pair_p (accumulator_))
+ if (!is_pair (accumulator_))
accumulator_ = scm_cons (SCM_EOL, SCM_EOL);
- if (!ly_pair_p (ly_car (accumulator_)))
+ if (!is_pair (ly_car (accumulator_)))
{
/*
Need to store transposition for every moment; transposition changes during pieces.
Engraver_group_engraver::finalize ();
SCM proc = get_property ("recordEventSequence");
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
scm_call_2 (proc, daddy_context_->self_scm (), ly_cdr (accumulator_));
accumulator_ = SCM_EOL;
bool start = false;
bool end = false;
bool volta_found = false;
- while (ly_pair_p (cs))
+ while (is_pair (cs))
{
SCM command = ly_car (cs);
if (command == ly_symbol2scm ("start-repeat"))
start = true;
else if (command == ly_symbol2scm ("end-repeat"))
end = true;
- else if (ly_pair_p (command) && ly_car (command) == ly_symbol2scm ("volta"))
+ else if (is_pair (command) && ly_car (command) == ly_symbol2scm ("volta"))
volta_found = true;
cs = ly_cdr (cs);
}
*/
SCM wb = get_property ("whichBar");
SCM db = get_property ("defaultBarType");
- if (!ly_string_p (wb) || ly_equal_p (db, wb))
+ if (!is_string (wb) || is_equal (db, wb))
{
- if (s != "" || (volta_found && !ly_string_p (wb)))
+ if (s != "" || (volta_found && !is_string (wb)))
{
daddy_context_->set_property ("whichBar", scm_makfrom0str (s.to_str0 ()));
}
{
lily_1_8_compatibility_used = true;
- for (SCM s = alternatives (); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = alternatives (); is_pair (s); s = ly_cdr (s))
unsmob_music (ly_car (s))->to_relative_octave (p);
}
int done =0;
SCM p = alternatives ();
- while (ly_pair_p (p) && done < repeat_count ())
+ while (is_pair (p) && done < repeat_count ())
{
m = m + unsmob_music (ly_car (p))->get_length ();
done ++;
Moment m;
SCM p = alternatives ();
- while (ly_pair_p (p))
+ while (is_pair (p))
{
m = m + unsmob_music (ly_car (p))->get_length ();
p = ly_cdr (p);
Link_array<Grob> rests;
Link_array<Grob> notes;
- for (SCM s = elts; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = elts; is_pair (s); s = ly_cdr (s))
{
Grob * e = unsmob_grob (ly_car (s));
if (unsmob_grob (e->get_property ("rest")))
{
int pos= p->steps ();
SCM c0 = get_property ("middleCPosition");
- if (ly_number_p (c0))
+ if (is_number (c0))
pos += ly_scm2int (c0);
rest_->set_property ("staff-position", scm_int2num (pos));
Grob* me = unsmob_grob (smob);
SCM balltype_scm = me->get_property ("duration-log");
- if (!ly_number_p (balltype_scm))
+ if (!is_number (balltype_scm))
return Stencil ().smobbed_copy ();
int balltype = ly_scm2int (balltype_scm);
String style;
SCM style_scm = me->get_property ("style");
- if (ly_symbol_p (style_scm))
+ if (is_symbol (style_scm))
style = ly_scm2string (scm_symbol_to_string (style_scm));
Font_metric *fm = Font_interface::get_default_font (me);
Rest::polyphonic_offset_callback (SCM smob, SCM)
{
Grob* me = unsmob_grob (smob);
- if (ly_number_p (me->get_property ("staff-position")))
+ if (is_number (me->get_property ("staff-position")))
return scm_make_real (0);
Direction d = get_grob_direction (me);
Rhythmic_head::duration_log (Grob*me)
{
SCM s = me->get_property ("duration-log");
- return ly_number_p (s) ? ly_scm2int (s) : 0;
+ return is_number (s) ? ly_scm2int (s) : 0;
}
ADD_INTERFACE (Rhythmic_head,"rhythmic-head-interface",
coding_vector_ = scm_call_1 (ly_scheme_function ("get-coding-vector"),
scm_makfrom0str (coding_scheme_.to_str0 ()));
- if (!ly_vector_p (coding_vector_))
+ if (!is_vector (coding_vector_))
{
programming_error ("get-coding-vector should return vector");
coding_vector_ = scm_c_make_vector (256, ly_symbol2scm (".notdef"));
Box char_box;
- if (!ly_symbol_p (sym))
+ if (!is_symbol (sym))
continue;
char const * chars = SCM_SYMBOL_CHARS(sym);
{
int k = 0;
for (int i = SCM_VECTOR_LENGTH (src); i--;)
- for (SCM s = scm_vector_ref (src, SCM_MAKINUM (i)); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = scm_vector_ref (src, SCM_MAKINUM (i)); is_pair (s); s = ly_cdr (s))
{
scm_hashq_set_x (dest, ly_caar (s), ly_cdar (s));
k++;
Scheme_hash_table::try_retrieve (SCM k, SCM *v)
{
SCM handle = scm_hashq_get_handle (hash_tab_, k);
- if (ly_pair_p (handle))
+ if (is_pair (handle))
{
*v = ly_cdr (handle);
return true;
bool
Scheme_hash_table::contains (SCM k) const
{
- return ly_pair_p (scm_hashq_get_handle (hash_tab_, k));
+ return is_pair (scm_hashq_get_handle (hash_tab_, k));
}
void
Scheme_hash_table::set (SCM k, SCM v)
{
- assert (ly_symbol_p (k));
+ assert (is_symbol (k));
SCM handle = scm_hashq_create_handle_x (hash_tab_, k, SCM_UNDEFINED);
if (ly_cdr (handle) == SCM_UNDEFINED)
{
{
SCM l = SCM_EOL;
for (int i = SCM_VECTOR_LENGTH (hash_tab_); i--;)
- for (SCM s = scm_vector_ref (hash_tab_, scm_int2num (i)); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = scm_vector_ref (hash_tab_, scm_int2num (i)); is_pair (s); s = ly_cdr (s))
{
l = scm_acons (ly_caar (s), ly_cdar (s), l);
}
gotcha = true;
SCM pen = command_column_->get_property ("penalty");
- Real total_penalty = ly_number_p (pen)
+ Real total_penalty = is_number (pen)
? ly_scm2double (pen)
: 0.0;
SCM rpen = r->get_property ("penalty");
- if (ly_number_p (rpen))
+ if (is_number (rpen))
total_penalty += ly_scm2double (rpen);
if (total_penalty > 10000.0) // ugh. arbitrary.
defs_.push (s.defs_[i]->clone ());
header_ = ly_make_anonymous_module ();
- if (ly_module_p (s.header_))
+ if (is_module (s.header_))
ly_import_module (header_, s.header_);
}
{
Global_context *g = dynamic_cast<Global_context*> (unsmob_context (context));
SCM_ASSERT_TYPE (g, context, SCM_ARG1, __FUNCTION__, "Global context");
- SCM_ASSERT_TYPE (ly_string_p (outname), outname, SCM_ARG2, __FUNCTION__, "output filename");
+ SCM_ASSERT_TYPE (is_string (outname), outname, SCM_ARG2, __FUNCTION__, "output filename");
Music_output *output = g->get_output ();
progress_indication ("\n");
Script_column::add_staff_sided (Grob *me, Item *i)
{
SCM p = i->get_property ("script-priority");
- if (!ly_number_p (p))
+ if (!is_number (p))
return;
Pointer_group_interface::add_grob (me, ly_symbol2scm ("scripts"),i);
Drul_array<SCM> scripts (SCM_EOL, SCM_EOL);
Link_array<Grob> staff_sided;
- for (SCM s = me->get_property ("scripts"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("scripts"); is_pair (s); s = ly_cdr (s))
{
Grob *sc = unsmob_grob (ly_car (s));
ss = scm_stable_sort_x (ss, grob_script_priority_less_proc);
Grob * last = 0;
- for (SCM s = ss; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = ss; is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
if (last)
This is necessary for part-combining.
*/
for (int j = 0; j < scripts_.size (); j++)
- if (ly_equal_p (scripts_[j]. event_->get_property ("articulation-type"),
+ if (is_equal (scripts_[j]. event_->get_property ("articulation-type"),
r->get_property ("articulation-type")
))
return true;
if (g->internal_get_property (sym) == SCM_EOL)
{
SCM entry = scm_assoc (sym,alist);
- if (ly_pair_p (entry))
+ if (is_pair (entry))
{
g->internal_set_property (sym, ly_cdr (entry));
}
int prio =0;
SCM sprio = scm_assoc (ly_symbol2scm ("script-priority"), art);
- if (ly_pair_p (sprio))
+ if (is_pair (sprio))
prio = ly_scm2int (ly_cdr (sprio));
Grob * sc = scripts_[i].script_;
SCM follow = scm_assoc (ly_symbol2scm ("follow-into-staff"), scripts_[i].description_);
- if (ly_pair_p (follow) && to_boolean (ly_cdr (follow)))
+ if (is_pair (follow) && to_boolean (ly_cdr (follow)))
{
sc->add_offset_callback (Side_position_interface::quantised_position_proc, Y_AXIS);
sc->set_property ("staff-padding", SCM_EOL);
Script_interface::get_stencil (Grob * me, Direction d)
{
SCM s = me->get_property ("script-stencil");
- assert (ly_pair_p (s));
+ assert (is_pair (s));
SCM key = ly_car (s);
if (key == ly_symbol2scm ("feta"))
{
SCM name_entry = ly_cdr (s);
- SCM str = (ly_pair_p (name_entry)) ? index_get_cell (name_entry, d) : name_entry;
+ SCM str = (is_pair (name_entry)) ? index_get_cell (name_entry, d) : name_entry;
return Font_interface::get_default_font (me)->find_by_name ("scripts-" +
ly_scm2string (str));
}
SCM sym= (a == X_AXIS) ? ly_symbol2scm ("self-alignment-X"): ly_symbol2scm ("self-alignment-Y");
SCM align_prop (me->internal_get_property (sym));
- if (!ly_number_p (align_prop))
+ if (!is_number (align_prop))
return scm_int2num (0);
Real x = 0.0;
SCM sym= (a == X_AXIS) ? ly_symbol2scm ("self-alignment-X"): ly_symbol2scm ("self-alignment-Y");
SCM align (me->internal_get_property (sym));
- if (ly_number_p (align))
+ if (is_number (align))
{
Interval ext (me->extent (me,a));
return;
- for (; ly_pair_p (next); next = ly_cdr (next))
+ for (; is_pair (next); next = ly_cdr (next))
{
Item *l = dynamic_cast<Item*> (unsmob_grob (ly_car ( next)));
Item *lb = l->find_prebroken_piece (RIGHT);
*/
Real padding = robust_scm2double (me->get_property ("padding"), 0.1);
- for (SCM s = me->get_property ("elements"); ly_pair_p (s) && ly_pair_p (ly_cdr (s)); s = ly_cdr (s))
+ for (SCM s = me->get_property ("elements"); is_pair (s) && is_pair (ly_cdr (s)); s = ly_cdr (s))
{
/*
Order of elements is reversed!
Paper_column * pc = item->get_column ();
- for (SCM s = me->get_property ("conditional-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("conditional-elements"); is_pair (s); s = ly_cdr (s))
{
SCM elt = ly_car (s);
if (!unsmob_grob (elt))
Paper_column * pc = item->get_column ();
Interval w;
- for (SCM s = me->get_property ("elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("elements"); is_pair (s); s = ly_cdr (s))
{
SCM elt = ly_car (s);
if (!unsmob_grob (elt))
last_ext->set_empty ();
Grob *last_grob = 0;
for (SCM s = separation_item->get_property ("elements");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Grob * break_item = unsmob_grob (ly_car (s));
- if (!ly_symbol_p (break_item->get_property ("break-align-symbol")))
+ if (!is_symbol (break_item->get_property ("break-align-symbol")))
continue;
Interval ext = break_item->extent (col, X_AXIS);
Invariant for the data structure.
- if (ly_pair_p (cursor_))
+ if (is_pair (cursor_))
iter_->music_ == unsmob_music (ly_car (cursor_))
else
iter_ == 0;
Grace_fixup *head = 0;
Grace_fixup **tail = &head;
- for (; ly_pair_p (cursor); cursor = ly_cdr (cursor))
+ for (; is_pair (cursor); cursor = ly_cdr (cursor))
{
Music *mus = unsmob_music (ly_car (cursor));
Moment s = mus->start_mom ();
cursor_ = get_music_list ();
iter_ = 0;
- if (ly_pair_p (cursor_))
+ if (is_pair (cursor_))
{
Music *m = unsmob_music (ly_car (cursor_));
iter_ = unsmob_iterator (get_iterator (m));
cursor_ = ly_cdr (cursor_);
iter_->quit ();
- if (ly_pair_p (cursor_))
+ if (is_pair (cursor_))
iter_ = unsmob_iterator (get_iterator (unsmob_music (ly_car (cursor_))));
else
iter_ = 0;
Grob * st = Staff_symbol_referencer::get_staff_symbol (me);
bool include_staff = (st
&& a == Y_AXIS
- && ly_number_p (me->get_property ("staff-padding")));
+ && is_number (me->get_property ("staff-padding")));
Interval dim;
if (include_staff)
*/
Grob * st = Staff_symbol_referencer::get_staff_symbol (me);
if (st && a == Y_AXIS
- && ly_number_p (me->get_property ("staff-padding")))
+ && is_number (me->get_property ("staff-padding")))
{
Real padding=
Staff_symbol_referencer::staff_space (me)
Link_array<Grob> cols (icols);
for (int i = cols.size (); i--;)
- if (ly_pair_p (cols[i]->get_property ("between-cols")))
+ if (is_pair (cols[i]->get_property ("between-cols")))
{
loose_cols_.push (cols[i]);
cols.del (i);
Spring_smob *spring = 0;
for (SCM s = cols[i]->get_property ("ideal-distances");
- !spring && ly_pair_p (s);
+ !spring && is_pair (s);
s = ly_cdr (s))
{
Spring_smob *sp = unsmob_spring (ly_car (s));
for (int i=0; i < cols.size () - 1; i++)
{
for (SCM s = Spaceable_grob::get_minimum_distances (cols[i]);
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Grob * other = unsmob_grob (ly_caar (s));
int oi = cols.find_index (other);
for (int i = sz; i--; )
{
SCM p = positions->cols_[i]->get_property ( "penalty");
- if (ly_number_p (p))
+ if (is_number (p))
{
if (ly_scm2double (p) < -9999)
break_satisfy = break_satisfy && (i == 0 || i == sz -1);
void
Simultaneous_music_iterator::derived_substitute (Context *f,Context *t)
{
- for (SCM s = children_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; is_pair (s); s = ly_cdr (s))
unsmob_iterator (ly_car (s))-> substitute_outlet (f,t);
}
children_list_ = SCM_EOL;
SCM * tail = &children_list_;
- for (; ly_pair_p (i); i = ly_cdr (i), j++)
+ for (; is_pair (i); i = ly_cdr (i), j++)
{
Music *mus = unsmob_music (ly_car (i));
Simultaneous_music_iterator::process (Moment until)
{
SCM *proc = &children_list_;
- while (ly_pair_p (*proc))
+ while (is_pair (*proc))
{
Music_iterator * i = unsmob_iterator (ly_car (*proc));
if (i->run_always ()
Moment next;
next.set_infinite (1);
- for (SCM s = children_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; is_pair (s); s = ly_cdr (s))
{
Music_iterator * it = unsmob_iterator (ly_car (s));
next = next <? it->pending_moment ();
Simultaneous_music_iterator::ok () const
{
bool run_always_ok = false;
- for (SCM s = children_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; is_pair (s); s = ly_cdr (s))
{
Music_iterator * it = unsmob_iterator (ly_car (s));
if (!it->run_always ())
bool
Simultaneous_music_iterator::run_always () const
{
- for (SCM s = children_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; is_pair (s); s = ly_cdr (s))
{
Music_iterator * it = unsmob_iterator (ly_car (s));
if (it->run_always ())
Simultaneous_music_iterator::try_music_in_children (Music *m) const
{
Music_iterator * b=0;
- for (SCM s = children_list_; !b && ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; !b && is_pair (s); s = ly_cdr (s))
b =unsmob_iterator (ly_car (s))->try_music (m);
return b;
}
void
Simultaneous_music_iterator::do_quit ()
{
- for (SCM s = children_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = children_list_; is_pair (s); s = ly_cdr (s))
unsmob_iterator (ly_car (s))->quit ();
}
return SCM_UNSPECIFIED;
}
set_extremities (me);
- if (!ly_pair_p (me->get_property ("control-points")))
+ if (!is_pair (me->get_property ("control-points")))
set_control_points (me);
return SCM_UNSPECIFIED;
}
Avoid too steep slurs.
*/
SCM s = me->get_property ("slope-limit");
- if (ly_number_p (s))
+ if (is_number (s))
{
Array<Offset> encompass = get_encompass_offsets (me);
Drul_array<Offset> attachment;
SCM att = me->get_property ("attachment");
/*
*/
- if (!ly_pair_p (att))
+ if (!is_pair (att))
{
programming_error ("attachment is not a cons?!");
att = scm_cons (SCM_EOL, SCM_EOL);
do
{
- if (!ly_symbol_p (index_get_cell (att, dir)))
+ if (!is_symbol (index_get_cell (att, dir)))
{
SCM p = me->get_property ("extremity-function");
SCM res = ly_symbol2scm ("head");
- if (ly_procedure_p (p))
+ if (is_procedure (p))
res = scm_call_2 (p, me->self_scm (), scm_int2num (dir));
- if (ly_symbol_p (res))
+ if (is_symbol (res))
index_set_cell (att, dir, res);
}
}
{
SCM cols = me->get_property ("note-columns");
- if (!ly_pair_p (cols))
+ if (!is_pair (cols))
{
programming_error ("No note-columns in slur?");
me->suicide ();
Grob **common)
{
SCM s = me->get_property ("attachment");
- if (!ly_pair_p (s) || !ly_symbol_p (index_get_cell (s, dir)))
+ if (!is_pair (s) || !is_symbol (index_get_cell (s, dir)))
{
s = set_extremities (me);
}
TODO: replace dashed with generic property.
*/
SCM d = me->get_property ("dashed");
- if (ly_number_p (d))
+ if (is_number (d))
a = Lookup::dashed_slur (one, thick, thick * robust_scm2double (d, 0));
else
a = Lookup::slur (one, get_grob_direction (me) * base_thick * ss / 10.0,
SCM ssb = me->get_property ("beautiful");
Real sb = 0;
- if (ly_number_p (ssb))
+ if (is_number (ssb))
sb = ly_scm2double (ssb);
bb.minimise_enclosed_area (sb, details);
SCM sbf = scm_assq (ly_symbol2scm ("force-blowfit"), details);
Real bff = 1.0;
- if (ly_pair_p (sbf) && ly_number_p (ly_cdr (sbf)))
+ if (is_pair (sbf) && is_number (ly_cdr (sbf)))
bff = ly_scm2double (ly_cdr (sbf));
bb.curve_.control_[1][Y_AXIS] *= bff;
int i = 0;
SCM attach = me->get_property ("attachment");
- if (!ly_pair_p (attach))
+ if (!is_pair (attach))
attach = set_extremities (me);
if (!get_grob_direction (me)
- || ! ly_symbol_p (index_get_cell (attach, LEFT))
- || ! ly_symbol_p (index_get_cell (attach, RIGHT)))
+ || ! is_symbol (index_get_cell (attach, LEFT))
+ || ! is_symbol (index_get_cell (attach, RIGHT)))
set_extremities (me);
- if (!ly_pair_p (me->get_property ("control-points")))
+ if (!is_pair (me->get_property ("control-points")))
set_control_points (me);
// set_control_points may suicide
SCM mins = get_minimum_distances (me);
SCM newdist = scm_make_real (d);
- for (SCM s = mins; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = mins; is_pair (s); s = ly_cdr (s))
{
SCM dist = ly_car (s);
if (ly_car (dist) == p->self_scm ())
#ifndef NDEBUG
SCM mins = me->get_property ("ideal-distances");
- for (SCM s = mins; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = mins; is_pair (s); s = ly_cdr (s))
{
Spring_smob * sp = unsmob_spring(ly_car (s));
if (sp->other_ == p)
such a borderline case.)
*/
- if (!ly_pair_p (lns) || !ly_pair_p (rns))
+ if (!is_pair (lns) || !is_pair (rns))
return false;
Item * l_neighbor = dynamic_cast<Item*> (unsmob_grob (ly_car (lns)));
in any case, we don't want to move bar lines.
*/
- for (SCM e = c->get_property ("elements"); ly_pair_p (e); e = ly_cdr (e))
+ for (SCM e = c->get_property ("elements"); is_pair (e); e = ly_cdr (e))
{
Grob * g = unsmob_grob (ly_car (e));
if (g && Break_align_interface::has_interface (g))
{
- for (SCM s = g->get_property ("elements"); ly_pair_p (s);
+ for (SCM s = g->get_property ("elements"); is_pair (s);
s = ly_cdr (s))
{
Grob *h = unsmob_grob (ly_car (s));
if (loose_column (cols->elem (i-1), c, cols->elem (i+1)))
{
SCM lns = c->get_property ("left-neighbors");
- lns = ly_pair_p (lns) ? ly_car (lns) : SCM_BOOL_F;
+ lns = is_pair (lns) ? ly_car (lns) : SCM_BOOL_F;
SCM rns = c->get_property ("right-neighbors");
- rns = ly_pair_p (rns) ? ly_car (rns) : SCM_BOOL_F;
+ rns = is_pair (rns) ? ly_car (rns) : SCM_BOOL_F;
/*
Either object can be non existent, if the score ends
Item *rc = dynamic_cast<Item*> (d == LEFT ? c : next_door[RIGHT]);
for (SCM s = lc->get_property ("spacing-wishes");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Grob *sp = unsmob_grob (ly_car (s));
if (Note_spacing::left_column (sp) != lc
SCM wishes= cols[i]->get_property ("spacing-wishes");
- for (SCM s =wishes; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s =wishes; is_pair (s); s = ly_cdr (s))
{
Item * wish = dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
*/
int maxrank = 0;
SCM left_neighs = rc->get_property ("left-neighbors");
- if (ly_pair_p (left_neighs)
+ if (is_pair (left_neighs)
&& unsmob_grob (ly_car (left_neighs)))
{
Item * it = dynamic_cast<Item*> (unsmob_grob (ly_car (left_neighs)));
}
}
- if (ly_pair_p (right_neighbors))
+ if (is_pair (right_neighbors))
{
cols[i]->set_property ("right-neighbors", right_neighbors);
}
sloppy with typnig left/right-neighbors should take list, but paper-column found instead.
*/
SCM ln = cols[i] ->get_property ("left-neighbors");
- if (!ly_pair_p (ln) && i )
+ if (!is_pair (ln) && i )
{
cols[i]->set_property ("left-neighbors", scm_cons (cols[i-1]->self_scm (), SCM_EOL));
}
SCM rn = cols[i] ->get_property ("right-neighbors");
- if (!ly_pair_p (rn) && i < cols.size () - 1)
+ if (!is_pair (rn) && i < cols.size () - 1)
{
cols[i]->set_property ("right-neighbors", scm_cons (cols[i + 1]->self_scm (), SCM_EOL));
}
happens after the current note (this is set in the grob
property SPACING-SEQUENCE.
*/
- for (SCM s = seq; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = seq; is_pair (s); s = ly_cdr (s))
{
Grob * wish = unsmob_grob (ly_car (s));
if (dt == Moment (0,0))
{
for (SCM s = l->get_property ("spacing-wishes");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Item * spacing_grob = dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
for (int i=0; i < arpeggios_.size (); i ++)
{
for (SCM s = arpeggios_[i]->get_property ("stems");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
Group_interface::add_thing (span_arpeggio_, ly_symbol2scm ("stems"), ly_car (s));
for (SCM s = arpeggios_[i]->get_property ("side-support-elements");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
Group_interface::add_thing (span_arpeggio_, ly_symbol2scm ("side-support-elements"), ly_car (s));
/*
SCM vissym =ly_symbol2scm ("break-visibility");
SCM vis = bars_[0]->internal_get_property (vissym);
- if (ly_equal_p (spanbar_->internal_get_property (vissym), vis))
+ if (is_equal (spanbar_->internal_get_property (vissym), vis))
spanbar_->internal_set_property (vissym, vis);
typeset_grob (spanbar_);
/* compute common refpoint of elements */
Grob *refp = me;
- for (SCM elts = first_elt; ly_pair_p (elts); elts = ly_cdr (elts))
+ for (SCM elts = first_elt; is_pair (elts); elts = ly_cdr (elts))
{
SCM smobbed_staff_bar = ly_car (elts);
Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
/* glyph may not be a string, when ME is killed by Hara Kiri in
between. */
- if (!ly_string_p (glyph))
+ if (!is_string (glyph))
return SCM_EOL;
String glyph_string = ly_scm2string (glyph);
Stencil span_bar_mol;
Interval prev_extent;
- for (SCM elts = first_elt; ly_pair_p (elts); elts = ly_cdr (elts))
+ for (SCM elts = first_elt; is_pair (elts); elts = ly_cdr (elts))
{
SCM smobbed_staff_bar = ly_car (elts);
Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
/* TODO: filter all hara-kiried out of ELEMENS list, and then
optionally do suicide. Call this cleanage function from
center_on_spanned_callback () as well. */
- if (!ly_pair_p (me->get_property ("elements")))
+ if (!is_pair (me->get_property ("elements")))
{
me->suicide ();
}
{
SCM gl = me->get_property ("glyph");
- if (ly_string_p (gl))
+ if (is_string (gl))
return ;
for (SCM s = me->get_property ("elements");
- !ly_string_p (gl) && ly_pair_p (s); s = ly_cdr (s))
+ !is_string (gl) && is_pair (s); s = ly_cdr (s))
{
gl = unsmob_grob (ly_car (s))
->get_property ("glyph");
}
- if (!ly_string_p (gl))
+ if (!is_string (gl))
{
me->suicide ();
return;
// mustn't ask Score for instrument: it will return piano!
SCM minstr = get_property ("midiInstrument");
- if (!ly_string_p (minstr)
+ if (!is_string (minstr)
|| ly_scm2string (minstr) == instrument_string_)
return "";
{
SCM glyph = bar_grob->get_property ("glyph");
- String glyph_string = ly_string_p (glyph) ? ly_scm2string (glyph) : "";
+ String glyph_string = is_string (glyph) ? ly_scm2string (glyph) : "";
if (glyph_string.left_string (1) == "|" || glyph_string.left_string (1) == ".")
{
SCM sz = Bar_line::get_staff_bar_size (bar_grob->self_scm ());
Real max_corr =0.0;
for (SCM s = me->get_property ("right-items");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Grob * g = unsmob_grob (ly_car (s));
max_corr = max_corr >? next_note_correction (me, g, bar_size);
for (SCM t = g->get_property ("elements");
- ly_pair_p (t); t = ly_cdr (t))
+ is_pair (t); t = ly_cdr (t))
max_corr = max_corr >? next_note_correction (me, unsmob_grob (ly_car (t)), bar_size);
}
Item * me_item = dynamic_cast<Item*> (me);
for (SCM s = me->get_property ("left-items");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
Grob * cand = unsmob_grob (ly_car (s));
if (cand && Separation_item::has_interface (cand))
if (me_item->break_status_dir () == CENTER)
{
SCM nndef = scm_sloppy_assq (ly_symbol2scm ("next-note"), alist);
- if (ly_pair_p (nndef))
+ if (is_pair (nndef))
space_def = nndef;
}
- if (!ly_pair_p (space_def))
+ if (!is_pair (space_def))
{
programming_error ("Unknown prefatory spacing. ");
return;
SCM pos = me->get_property ("staff-position");
Real off = 0.0;
- if (ly_number_p (pos))
+ if (is_number (pos))
{
Real space = Staff_symbol_referencer::staff_space (me);
off = ly_scm2double (pos) * space / 2.0;
do
{
SCM width_scm = me->get_property ("width");
- if (d == RIGHT && ly_number_p (width_scm))
+ if (d == RIGHT && is_number (width_scm))
{
/*
don't multiply by Staff_symbol_referencer::staff_space (me),
Staff_symbol::line_count (Grob*me)
{
SCM c = me->get_property ("line-count");
- if (ly_number_p (c))
+ if (is_number (c))
return ly_scm2int (c);
else
return 0;
{
SCM stanza = get_property ("stanza");
- if (ly_string_p (stanza) && stanza != last_stanza_)
+ if (is_string (stanza) && stanza != last_stanza_)
{
last_stanza_ = stanza;
int requested_type = ly_scm2int (tremolo_ev_->get_property ("tremolo-type"));
SCM f = get_property ("tremoloFlags");
if (!requested_type)
- if (ly_number_p (f))
+ if (is_number (f))
requested_type = ly_scm2int (f);
else
requested_type = 8;
toDO: junk these properties.
*/
SCM prop = get_property ("stemLeftBeamCount");
- if (ly_number_p (prop))
+ if (is_number (prop))
{
Stem::set_beaming (stem_,ly_scm2int (prop),LEFT);
daddy_context_->unset_property (ly_symbol2scm ("stemLeftBeamCount"));
}
prop = get_property ("stemRightBeamCount");
- if (ly_number_p (prop))
+ if (is_number (prop))
{
Stem::set_beaming (stem_,ly_scm2int (prop), RIGHT);
daddy_context_->unset_property (ly_symbol2scm ("stemRightBeamCount"));
int tremolo_flags = 0;
SCM s = me->get_property ("flag-count");
- if (ly_number_p (s))
+ if (is_number (s))
tremolo_flags = ly_scm2int (s);
if (!tremolo_flags)
Real beamthickness = 0.0;
SCM sbt = (beam) ? beam->get_property ("thickness") : SCM_EOL ;
- if (ly_number_p (sbt))
+ if (is_number (sbt))
{
beamthickness = ly_scm2double (sbt) * ss;
}
{
SCM pair = me->get_property ("beaming");
- if (!ly_pair_p (pair))
+ if (!is_pair (pair))
{
pair = scm_cons (SCM_EOL, SCM_EOL);
me->set_property ("beaming", pair);
{
SCM p =me->get_property ("stem-end-position");
Real pos;
- if (!ly_number_p (p))
+ if (!is_number (p))
{
pos = get_default_stem_end_position (me);
me->set_property ("stem-end-position", scm_make_real (pos));
Drul_array<Grob *> exthead;
exthead[LEFT] = exthead[RIGHT] =0;
- for (SCM s = me->get_property ("note-heads"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("note-heads"); is_pair (s); s = ly_cdr (s))
{
Grob * n = unsmob_grob (ly_car (s));
Stem::note_head_positions (Grob *me)
{
Array<int> ps ;
- for (SCM s = me->get_property ("note-heads"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("note-heads"); is_pair (s); s = ly_cdr (s))
{
Grob * n = unsmob_grob (ly_car (s));
int p = Staff_symbol_referencer::get_rounded_position (n);
Real length = 7; // WARNING: IN HALF SPACES
SCM scm_len = me->get_property ("length");
- if (ly_number_p (scm_len))
+ if (is_number (scm_len))
{
length = ly_scm2double (scm_len);
}
else
{
s = me->get_property ("lengths");
- if (ly_pair_p (s))
+ if (is_pair (s))
{
length = 2* ly_scm2double (robust_list_ref (durlog -2, s));
}
if (dir * head_positions (me)[dir] >= 0)
{
SCM sshorten = me->get_property ("stem-shorten");
- SCM scm_shorten = ly_pair_p (sshorten) ?
+ SCM scm_shorten = is_pair (sshorten) ?
robust_list_ref ((duration_log (me) - 2) >? 0, sshorten): SCM_EOL;
Real shorten = 2* robust_scm2double (scm_shorten,0);
Stem::duration_log (Grob*me)
{
SCM s = me->get_property ("duration-log");
- return (ly_number_p (s)) ? ly_scm2int (s) : 2;
+ return (is_number (s)) ? ly_scm2int (s) : 2;
}
void
String flag_style;
SCM flag_style_scm = me->get_property ("flag-style");
- if (ly_symbol_p (flag_style_scm))
+ if (is_symbol (flag_style_scm))
{
flag_style = ly_symbol2string (flag_style_scm);
}
}
SCM stroke_style_scm = me->get_property ("stroke-style");
- if (ly_string_p (stroke_style_scm))
+ if (is_string (stroke_style_scm))
{
String stroke_style = ly_scm2string (stroke_style_scm);
if (!stroke_style.is_empty ())
{
/* Return cached info if available */
SCM scm_info = me->get_property ("stem-info");
- if (!ly_pair_p (scm_info))
+ if (!is_pair (scm_info))
{
calc_stem_info (me);
scm_info = me->get_property ("stem-info");
{
Stencil *s = unsmob_stencil (stil);
SCM_ASSERT_TYPE (s, stil, SCM_ARG1, __FUNCTION__, "stencil");
- SCM_ASSERT_TYPE (ly_number_p (amount), amount, SCM_ARG2, __FUNCTION__, "number pair");
+ SCM_ASSERT_TYPE (is_number (amount), amount, SCM_ARG2, __FUNCTION__, "number pair");
SCM_ASSERT_TYPE (is_axis (axis), axis, SCM_ARG3, __FUNCTION__, "axis");
SCM new_s = s->smobbed_copy ();
Real p = 0.0;
if (padding != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (padding), padding, SCM_ARG5, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (padding), padding, SCM_ARG5, __FUNCTION__, "number");
p = ly_scm2double (padding);
}
Real m = 0.0;
if (minimum != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (minimum), minimum, SCM_ARG6, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (minimum), minimum, SCM_ARG6, __FUNCTION__, "number");
m = ly_scm2double (minimum);
}
Real p = 0.0;
if (padding != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (padding), padding, SCM_ARG5, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (padding), padding, SCM_ARG5, __FUNCTION__, "number");
p = ly_scm2double (padding);
}
Real m = 0.0;
if (minimum != SCM_UNDEFINED)
{
- SCM_ASSERT_TYPE (ly_number_p (minimum), minimum, SCM_ARG6, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (minimum), minimum, SCM_ARG6, __FUNCTION__, "number");
m = ly_scm2double (minimum);
}
{
SCM_ASSERT_TYPE (unsmob_stencil (stil), stil, SCM_ARG1, __FUNCTION__, "stencil");
SCM_ASSERT_TYPE (is_axis (axis), axis, SCM_ARG2, __FUNCTION__, "axis");
- SCM_ASSERT_TYPE (ly_number_p (dir), dir, SCM_ARG3, __FUNCTION__, "number");
+ SCM_ASSERT_TYPE (is_number (dir), dir, SCM_ARG3, __FUNCTION__, "number");
unsmob_stencil (stil)->align_to ((Axis)ly_scm2int (axis),
ly_scm2double (dir));
Stencil mol;
SCM glyph = e->get_property ("text");
- if (!ly_string_p (glyph))
+ if (!is_string (glyph))
return mol.smobbed_copy ();
String text = ly_scm2string (glyph);
/*
UGH UGH
*/
- if (ly_string_p (gl) && ly_equal_p (gl, scm_makfrom0str ("brace"))
- && ly_string_p (my_gl) && ly_equal_p (my_gl, scm_makfrom0str ("bracket")))
+ if (is_string (gl) && is_equal (gl, scm_makfrom0str ("brace"))
+ && is_string (my_gl) && is_equal (my_gl, scm_makfrom0str ("bracket")))
inf.grob_->translate_axis (-0.8, X_AXIS); // ugh
- else if (ly_string_p (gl) && ly_equal_p (gl, scm_makfrom0str ("bracket"))
- && ly_string_p (my_gl) && ly_equal_p (my_gl, scm_makfrom0str ("bracket")))
+ else if (is_string (gl) && is_equal (gl, scm_makfrom0str ("bracket"))
+ && is_string (my_gl) && is_equal (my_gl, scm_makfrom0str ("bracket")))
{
inf.grob_->translate_axis ( -0.8, X_AXIS); // ugh
inf.grob_->set_property ("arch-height",
{
Grob * me = unsmob_grob (smob);
SCM gl = me->get_property ("glyph");
- if (ly_equal_p (gl,scm_makfrom0str ("bar-line")))
+ if (is_equal (gl,scm_makfrom0str ("bar-line")))
{
int count = 0;
*/
SCM elts = me->get_property ("elements");
Grob *common = common_refpoint_of_list (elts, me, Y_AXIS);
- for (SCM s = elts; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = elts; is_pair (s); s = ly_cdr (s))
{
Interval v = unsmob_grob (ly_car (s))->extent (common, Y_AXIS);
Grob * me = unsmob_grob (smob);
SCM s = me->get_property ("glyph");
- if (!ly_string_p (s))
+ if (!is_string (s))
return SCM_EOL;
SCM gsym = scm_string_to_symbol (s) ;
{
int k =0;
for (SCM s = get_property ("all-elements");
- ly_pair_p (s); s = ly_cdr (s))
+ is_pair (s); s = ly_cdr (s))
{
if (dynamic_cast<Spanner*> (unsmob_grob (ly_car (s))))
k++;
static void
fixup_refpoints (SCM s)
{
- for (; ly_pair_p (s); s = ly_cdr (s))
+ for (; is_pair (s); s = ly_cdr (s))
{
Grob::fixup_refpoint (ly_car (s));
}
SCM
System::get_lines ()
{
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
if (g->internal_has_interface (ly_symbol2scm ("only-prebreak-interface")))
{
Grob *se = broken_intos_[i];
SCM all = se->get_property ("all-elements");
- for (SCM s = all; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = all; is_pair (s); s = ly_cdr (s))
fixup_refpoint (ly_car (s));
count += scm_ilength (all);
}
*/
fixup_refpoints (get_property ("all-elements"));
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
unsmob_grob (ly_car (s))->handle_broken_dependencies ();
handle_broken_dependencies ();
do
{
SCM between = loose->get_property ("between-cols");
- if (!ly_pair_p (between))
+ if (!is_pair (between))
break;
{
Grob *me = this;
SCM cs = me->get_property ("columns");
- Grob * prev = ly_pair_p (cs) ? unsmob_grob (ly_car (cs)) : 0;
+ Grob * prev = is_pair (cs) ? unsmob_grob (ly_car (cs)) : 0;
p->rank_ = prev ? Paper_column::get_rank (prev) + 1 : 0;
void
System::pre_processing ()
{
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
unsmob_grob (ly_car (s))->discretionary_processing ();
if (verbose_global_b)
progress_indication (_f ("Grob count %d", element_count ()));
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
unsmob_grob (ly_car (s))->handle_prebroken_dependencies ();
fixup_refpoints (get_property ("all-elements"));
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
{
Grob* sc = unsmob_grob (ly_car (s));
sc->calculate_dependencies (PRECALCED, PRECALCING, ly_symbol2scm ("before-line-breaking-callback"));
}
progress_indication ("\n" + _ ("Calculating line breaks...") + " ");
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
{
Grob * e = unsmob_grob (ly_car (s));
SCM proc = e->get_property ("spacing-procedure");
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
scm_call_1 (proc, e->self_scm ());
}
}
void
System::post_processing ()
{
- for (SCM s = get_property ("all-elements"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = get_property ("all-elements"); is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
g->calculate_dependencies (POSTCALCED, POSTCALCING,
all = uniquify_list (all);
this->get_stencil ();
- for (SCM s = all; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = all; is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
g->get_stencil ();
SCM all = get_property ("all-elements");
for (int i = LAYER_COUNT; i--;)
- for (SCM s = all; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = all; is_pair (s); s = ly_cdr (s))
{
Grob *g = unsmob_grob (ly_car (s));
Stencil *stil = g->get_stencil ();
SCM between = ly_symbol2scm ("between-system-string");
SCM inter = g->internal_get_property (between);
- if (ly_string_p (inter))
+ if (is_string (inter))
stencils = scm_cons (scm_cons (between, inter), stencils);
}
r = r->get_column ();
SCM s = get_property ("columns");
- while (ly_pair_p (s) && ly_car (s) != r->self_scm ())
+ while (is_pair (s) && ly_car (s) != r->self_scm ())
s = ly_cdr (s);
- if (ly_pair_p (s))
+ if (is_pair (s))
s = ly_cdr (s);
- while (ly_pair_p (s) && ly_car (s) != l->self_scm ())
+ while (is_pair (s) && ly_car (s) != l->self_scm ())
{
Paper_column*c = dynamic_cast<Paper_column*> (unsmob_grob (ly_car (s)));
if (Item::is_breakable (c) && !c->system_)
Music * tabstring_event=0;
for (SCM s =event->get_property ("articulations");
- !tabstring_event && ly_pair_p (s); s = ly_cdr (s))
+ !tabstring_event && is_pair (s); s = ly_cdr (s))
{
Music * art = unsmob_music (ly_car (s));
SCM scm_pitch = event->get_property ("pitch");
SCM proc = get_property ("tablatureFormat");
SCM min_fret_scm = get_property ("minimumFret");
- int min_fret = ly_number_p (min_fret_scm) ? ly_scm2int (min_fret_scm) : 0;
+ int min_fret = is_number (min_fret_scm) ? ly_scm2int (min_fret_scm) : 0;
while (!string_found)
{
// Hmm
int priority = 200;
SCM s = text->get_property ("script-priority");
- if (ly_number_p (s))
+ if (is_number (s))
priority = ly_scm2int (s);
/* see script-engraver.cc */
#include "paper-def.hh"
#include "scaled-font-metric.hh"
-MAKE_SCHEME_CALLBACK (Text_item, interpret_markup, 3)
+MAKE_SCHEME_CALLBACK (Text_item, interpret_string, 4)
SCM
-Text_item::interpret_markup (SCM paper, SCM props, SCM markup)
+Text_item::interpret_string (SCM paper, SCM props, SCM encoding, SCM markup)
{
- if (ly_string_p (markup))
+ Paper_def *pap = unsmob_paper (paper);
+
+ SCM_ASSERT_TYPE(pap, paper, SCM_ARG1, __FUNCTION__, "Paper definition");
+ SCM_ASSERT_TYPE(is_string (markup), markup, SCM_ARG3, __FUNCTION__, "string");
+ SCM_ASSERT_TYPE(encoding == SCM_EOL
+ || is_symbol (encoding), encoding, SCM_ARG2, __FUNCTION__, "symbol");
+
+ String str = ly_scm2string (markup);
+ Font_metric *fm = select_encoded_font (pap, props, encoding);
+ SCM lst = SCM_EOL;
+ Box b;
+ if (Modified_font_metric* mf = dynamic_cast<Modified_font_metric*> (fm))
{
- String str = ly_scm2string (markup);
-
- Paper_def *pap = unsmob_paper (paper);
- Font_metric *fm = select_font (pap, props);
- SCM lst = SCM_EOL;
- Box b;
- if (Modified_font_metric* mf = dynamic_cast<Modified_font_metric*> (fm))
- {
- lst = scm_list_3 (ly_symbol2scm ("text"),
- mf->self_scm (),
- markup);
+ lst = scm_list_3 (ly_symbol2scm ("text"),
+ mf->self_scm (),
+ markup);
- b = mf->text_dimension (str);
- }
- else
- {
- /* ARGH. */
- programming_error ("Must have Modified_font_metric for text.");
- }
+ b = mf->text_dimension (str);
+ }
+ else
+ {
+ /* ARGH. */
+ programming_error ("Must have Modified_font_metric for text.");
+ }
- return Stencil (b, lst).smobbed_copy ();
+ return Stencil (b, lst).smobbed_copy ();
+}
+
+
+MAKE_SCHEME_CALLBACK (Text_item, interpret_markup, 3)
+SCM
+Text_item::interpret_markup (SCM paper, SCM props, SCM markup)
+{
+ if (is_string (markup))
+ {
+ return interpret_string (paper, props, markup, SCM_EOL);
}
- else if (ly_pair_p (markup))
+ else if (is_pair (markup))
{
SCM func = ly_car (markup);
SCM args = ly_cdr (markup);
Text_item::markup_p (SCM x)
{
return
- ly_string_p (x) ||
- (ly_pair_p (x)
+ is_string (x) ||
+ (is_pair (x)
&& SCM_BOOL_F != scm_object_property (ly_car (x), ly_symbol2scm ("markup-signature")));
}
SCM properties = Font_interface::text_font_alist_chain (me);
SCM edge_text = me->get_property ("edge-text");
Drul_array<Stencil> edge;
- if (ly_pair_p (edge_text))
+ if (is_pair (edge_text))
{
Direction d = LEFT;
do
SCM sym = ly_symbol2scm (s.to_str0 ());
SCM idx = scm_hash_ref (encoding_table_, sym, SCM_BOOL_F);
- if (ly_char_p (idx))
+ if (is_char (idx))
{
return (unsigned char) ly_scm2char (idx);
}
maybe should check positions too.
*/
if (right_mus && left_mus
- && ly_equal_p (right_mus->get_property ("pitch"),
+ && is_equal (right_mus->get_property ("pitch"),
left_mus->get_property ("pitch")))
{
Grob * p = make_spanner ("Tie");
Music * left_mus = heads_to_tie_[i].event_;
if (right_mus && left_mus
- && ly_equal_p (right_mus->get_property ("pitch"),
+ && is_equal (right_mus->get_property ("pitch"),
left_mus->get_property ("pitch")))
{
an->tie_to (th);
{
SCM c = me->get_property ("head-pair");
- if (ly_pair_p (c))
+ if (is_pair (c))
return unsmob_grob (index_get_cell (c, d));
else
return 0;
Grob*me = unsmob_grob (smob);
SCM cp = me->get_property ("control-points");
- if (!ly_pair_p (cp)) // list is more accurate
+ if (!is_pair (cp)) // list is more accurate
{
cp = get_control_points (smob);
me->set_property ("control-points", cp);
}
- if (!ly_pair_p (cp))
+ if (!is_pair (cp))
return Stencil ().smobbed_copy ();
Real thick
SCM fr= get_property ("timeSignatureFraction");
if (!time_signature_
&& last_time_fraction_ != fr
- && ly_pair_p (fr))
+ && is_pair (fr))
{
int den = ly_scm2int (ly_cdr (fr));
if (den != (1 << intlog2 (den)))
Time_signature_performer::create_audio_elements ()
{
SCM fr = get_property ("timeSignatureFraction");
- if (ly_pair_p (fr) && !ly_equal_p (fr, prev_fraction_))
+ if (is_pair (fr) && !is_equal (fr, prev_fraction_))
{
prev_fraction_ = fr;
int b = ly_scm2int (ly_car (fr));
SCM frac = me->get_property ("fraction");
int n = 4;
int d = 4;
- if (ly_pair_p (frac))
+ if (is_pair (frac))
{
n = ly_scm2int (ly_car (frac));
d = ly_scm2int (ly_cdr (frac));
}
Stencil m;
- if (ly_symbol_p (st))
+ if (is_symbol (st))
{
String style (ly_scm2string (scm_symbol_to_string (st)));
if (style[0]=='1')
Moment now = now_mom ();
/* Set the first bar of the score? */
- if (!ly_string_p (which))
+ if (!is_string (which))
which = (now.main_part_ || now.main_part_ == last_moment_.main_part_)
? SCM_EOL : scm_makfrom0str ("|");
SCM which = get_property ("whichBar");
/* Set the first bar of the score? */
- if (!ly_string_p (which))
+ if (!is_string (which))
which = SCM_EOL;
Moment mp = measure_position ();
->set_property ("measure-length", mlen.smobbed_copy ());
}
- if (!ly_string_p (which) && to_boolean (automatic_bars))
+ if (!is_string (which) && to_boolean (automatic_bars))
{
SCM always = get_property ("barAlways");
SCM barn = get_property ("currentBarNumber");
int b = 0;
- if (ly_number_p (barn))
+ if (is_number (barn))
{
b = ly_scm2int (barn);
}
{
SCM l = global_translator_dict ? global_translator_dict->to_alist () : SCM_EOL;
- for (SCM s =l; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s =l; is_pair (s); s = ly_cdr (s))
{
scm_set_car_x (s, ly_cdar (s));
}
void
translator_each (SCM list, Translator_method method)
{
- for (SCM p = list; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = list; is_pair (p); p = ly_cdr (p))
(unsmob_translator (ly_car (p))->*method) ();
}
SCM ack_ifs = scm_assoc (ly_symbol2scm ("events-accepted"),
tr->translator_description ());
ack_ifs = ly_cdr (ack_ifs);
- for (SCM s = ifaces; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = ifaces; is_pair (s); s = ly_cdr (s))
if (scm_c_memq (ly_car (s), ack_ifs) != SCM_BOOL_F)
return true;
return false;
find_accept_translators (SCM gravlist, SCM ifaces)
{
SCM l = SCM_EOL;
- for (SCM s = gravlist; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = gravlist; is_pair (s); s = ly_cdr (s))
{
Translator* tr = unsmob_translator (ly_car (s));
if (translator_accepts_any_of (tr, ifaces))
SCM name = scm_sloppy_assq (ly_symbol2scm ("name"),
m->get_property_alist (false));
- if (!ly_pair_p (name))
+ if (!is_pair (name))
return false;
name = ly_cdr (name);
scm_hashq_set_x (tab, name, accept_list);
}
- for (SCM p = accept_list; ly_pair_p (p); p = ly_cdr (p))
+ for (SCM p = accept_list; is_pair (p); p = ly_cdr (p))
{
Translator * t = unsmob_translator (ly_car (p));
if (t && t->try_music (m))
names_to_translators (SCM namelist, Context*tg)
{
SCM l = SCM_EOL;
- for (SCM s = namelist; ly_pair_p (s) ; s = ly_cdr (s))
+ for (SCM s = namelist; is_pair (s) ; s = ly_cdr (s))
{
Translator * t = get_translator (ly_car (s));
if (!t)
(tg->*ptr) ();
}
- for (SCM s = c->context_list_ ; ly_pair_p (s);
+ for (SCM s = c->context_list_ ; is_pair (s);
s =ly_cdr (s))
{
recurse_over_translators (unsmob_context (ly_car (s)), ptr, dir);
execute_pushpop_property (Context * trg,
SCM prop, SCM eltprop, SCM val)
{
- if (ly_symbol_p (prop) && ly_symbol_p (eltprop))
+ if (is_symbol (prop) && is_symbol (eltprop))
{
if (val != SCM_UNDEFINED)
{
else
prev = trg->internal_get_property (prop);
- if (!ly_pair_p (prev))
+ if (!is_pair (prev))
{
programming_error ("Grob definition should be cons.");
return ;
SCM prev_alist = ly_car (prev);
- if (ly_pair_p (prev_alist) || prev_alist == SCM_EOL)
+ if (is_pair (prev_alist) || prev_alist == SCM_EOL)
{
bool ok = type_check_assignment (eltprop, val, ly_symbol2scm ("backend-type?"));
while (prev_alist != daddy)
{
- if (ly_equal_p (ly_caar (prev_alist), eltprop))
+ if (is_equal (ly_caar (prev_alist), eltprop))
{
prev_alist = ly_cdr (prev_alist);
break ;
apply_property_operations (Context *tg, SCM pre_init_ops)
{
SCM correct_order = scm_reverse (pre_init_ops);
- for (SCM s = correct_order; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = correct_order; is_pair (s); s = ly_cdr (s))
{
SCM entry = ly_car (s);
SCM type = ly_car (entry);
if (type == ly_symbol2scm ("push") || type == ly_symbol2scm ("poppush"))
{
SCM val = ly_cddr (entry);
- val = ly_pair_p (val) ? ly_car (val) : SCM_UNDEFINED;
+ val = is_pair (val) ? ly_car (val) : SCM_UNDEFINED;
execute_pushpop_property (tg, ly_car (entry), ly_cadr (entry), val);
}
SCM
updated_grob_properties (Context * tg, SCM sym)
{
- assert (ly_symbol_p (sym));
+ assert (is_symbol (sym));
tg = tg->where_defined (sym);
if (!tg)
SCM props = tg->internal_get_property (sym);
- if (!ly_pair_p (props))
+ if (!is_pair (props))
{
programming_error ("grob props not a pair?");
return SCM_EOL;
SCM lp = me->get_property ("left-position");
SCM rp = me->get_property ("right-position");
- if (!ly_number_p (rp) || !ly_number_p (lp))
+ if (!is_number (rp) || !is_number (lp))
after_line_breaking (smob);
}
Fixme: the type of this prop is sucky.
*/
SCM bracket = me->get_property ("bracket-visibility");
- if (ly_boolean_p (bracket))
+ if (is_boolean (bracket))
{
bracket_visibility = ly_scm2bool (bracket);
}
bracket_visibility = !par_beam;
SCM numb = me->get_property ("number-visibility");
- if (ly_boolean_p (numb))
+ if (is_boolean (numb))
{
number_visibility = ly_scm2bool (numb);
}
Paper_def *pap = me->get_paper ();
Stencil num;
- if (ly_string_p (number) && number_visibility)
+ if (is_string (number) && number_visibility)
{
SCM properties = Font_interface::text_font_alist_chain (me);
SCM snum = Text_item::interpret_markup (pap->self_scm (), properties, number);
SCM lp = me->get_property ("left-position");
SCM rp = me->get_property ("right-position");
- if (ly_number_p (lp) && !ly_number_p (rp))
+ if (is_number (lp) && !is_number (rp))
{
rp = scm_make_real (ly_scm2double (lp) + dy);
}
- else if (ly_number_p (rp) && !ly_number_p (lp))
+ else if (is_number (rp) && !is_number (lp))
{
lp = scm_make_real (ly_scm2double (rp) - dy);
}
- else if (!ly_number_p (rp) && !ly_number_p (lp))
+ else if (!is_number (rp) && !is_number (lp))
{
lp = scm_make_real (offset);
rp = scm_make_real (offset +dy);
Tuplet_bracket::get_default_dir (Grob*me)
{
Drul_array<int> dirs (0,0);
- for (SCM s = me->get_property ("note-columns"); ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("note-columns"); is_pair (s); s = ly_cdr (s))
{
Grob * nc = unsmob_grob (ly_car (s));
Direction d = Note_column::dir (nc);
SCM proc = get_property ("tupletNumberFormatFunction");
- if (ly_procedure_p (proc))
+ if (is_procedure (proc))
{
SCM t = scm_apply_0 (proc, scm_list_n (time_scaled_musics_[i]->self_scm (), SCM_UNDEFINED));
glep->set_property ("text", t);
Context * where = get_outlet ()->where_defined (reps);
if (where
- && current_reps == SCM_EOL || ly_pair_p (current_reps))
+ && current_reps == SCM_EOL || is_pair (current_reps))
{
current_reps = scm_cons (what, current_reps);
where->internal_set_property (reps, current_reps);
SCM name_list = SCM_EOL;
SCM *name_tail = &name_list;
- for (SCM s = font_list; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list; is_pair (s); s = ly_cdr (s))
{
if (Font_metric *fm = unsmob_metrics (ly_car (s)))
{
*tail = scm_cons (ly_car (s),SCM_EOL);
tail = SCM_CDRLOC (*tail);
- if (!ly_number_p (mag))
+ if (!is_number (mag))
/* Ugh. */
mag = ly_cdr (fm->description_);
Virtual_font_metric::count () const
{
int k = 0;
- for (SCM s = font_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; is_pair (s); s = ly_cdr (s))
k += unsmob_metrics (ly_car (s))->count ();
return k;
}
Virtual_font_metric::find_by_name (String glyph) const
{
Stencil m;
- for (SCM s = font_list_; m.is_empty () && ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; m.is_empty () && is_pair (s); s = ly_cdr (s))
{
m = unsmob_metrics (ly_car (s))->find_by_name (glyph);
}
Virtual_font_metric::get_indexed_wxwy (int code) const
{
int total = 0;
- for (SCM s = font_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; is_pair (s); s = ly_cdr (s))
{
Font_metric *fm = unsmob_metrics (ly_car (s));
if (code < total + fm->count ())
Virtual_font_metric::get_indexed_char (int code) const
{
int total = 0;
- for (SCM s = font_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; is_pair (s); s = ly_cdr (s))
{
Font_metric *fm = unsmob_metrics (ly_car (s));
if (code < total + fm->count ())
{
Stencil m;
int total = 0;
- for (SCM s = font_list_; m.is_empty () && ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; m.is_empty () && is_pair (s); s = ly_cdr (s))
{
Font_metric *m =unsmob_metrics (ly_car (s));
int k = m->name_to_index (glyph);
Stencil m ;
int total = 0;
- for (SCM s = font_list_; ly_pair_p (s); s = ly_cdr (s))
+ for (SCM s = font_list_; is_pair (s); s = ly_cdr (s))
{
Font_metric *fm = unsmob_metrics (ly_car (s));
if (code < total + fm->count ())
SCM glyph = endbar->get_property ("glyph");
String str;
- if (ly_string_p (glyph))
+ if (is_string (glyph))
str = ly_scm2string (glyph);
else
return SCM_EOL;
volta engraver in score context or somesuch.
*/
- if (!ly_pair_p (staffs))
+ if (!is_pair (staffs))
{
programming_error ("Huh? Volta engraver can't find staffs?");
return false;
bool end = false;
start_string_ = SCM_EOL;
- while (ly_pair_p (cs))
+ while (is_pair (cs))
{
SCM c = ly_car (cs);
- if (ly_pair_p (c)
+ if (is_pair (c)
&& ly_car (c) == ly_symbol2scm ("volta")
- && ly_pair_p (ly_cdr (c)))
+ && is_pair (ly_cdr (c)))
{
if (ly_cadr (c) == SCM_BOOL_F)
end = true;
}
if (volta_span_ &&
- (ly_string_p (start_string_) || ly_pair_p (start_string_)))
+ (is_string (start_string_) || is_pair (start_string_)))
{
warning (_ ("Already have a volta spanner. Stopping that one prematurely."));
}
if (!volta_span_ &&
- (ly_string_p (start_string_) || ly_pair_p (start_string_)))
+ (is_string (start_string_) || is_pair (start_string_)))
{
started_mom_ = now_mom () ;
;; syntax, description and example.
-(def-markup-command (word paper props str) (string?)
- "A single word."
- (interpret-markup paper props str))
(def-markup-command (simple paper props str) (string?)
- "A simple text-string; @code{\\markup @{ foo @}} is equivalent with
+ "A simple text string; @code{\\markup @{ foo @}} is equivalent with
@code{\\markup @{ \\simple #\"foo\" @}}."
- (interpret-markup paper props
- (make-word-markup str)))
+ (interpret-markup paper props str))
+
+(def-markup-command (encoded-simple paper props sym str) (symbol? string?)
+ "A text string, encoded with encoding @var{sym}."
+ (Text_item::interpret_string paper props sym str))
;; TODO: use font recoding.
;; (make-line-markup
projects / lilypond.git / commitdiff