+1.5.11
+======
+
+* Allow breaks at measures starting with grace notes.
+
+* Bugfix: don't give up when there is one entirely unspaceable
+measure/line.
+
+* Some GH deprecation.
+
+* Midi module: add timestamps.
+
+*
+
1.5.11.jcn1
===========
MAJOR_VERSION=1
MINOR_VERSION=5
PATCH_LEVEL=11
-MY_PATCH_LEVEL=jcn1
+MY_PATCH_LEVEL=jcn2
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
return m;
}
- SCM at = (gh_list (ly_symbol2scm ("char"),
+ SCM at = (scm_listify (ly_symbol2scm ("char"),
gh_int2scm (cm->code),
SCM_UNDEFINED));
SCM thr = me->get_grob_property ("threshold");
if (gh_pair_p (thr))
{
- threshold[SMALLER] = gh_scm2double (gh_car (thr));
- threshold[BIGGER] = gh_scm2double (gh_cdr (thr));
+ threshold[SMALLER] = gh_scm2double (ly_car (thr));
+ threshold[BIGGER] = gh_scm2double (ly_cdr (thr));
}
// todo: fucks up if item both in Halign & Valign.
SCM min_dims = e->remove_grob_property ("minimum-space");
if (gh_pair_p (min_dims) &&
- gh_number_p (gh_car (min_dims))
- && gh_number_p (gh_cdr (min_dims)))
+ gh_number_p (ly_car (min_dims))
+ && gh_number_p (ly_cdr (min_dims)))
{
y.unite (ly_scm2interval (min_dims));
}
SCM extra_dims = e->remove_grob_property ("extra-space");
if (gh_pair_p (extra_dims) &&
- gh_number_p (gh_car (extra_dims))
- && gh_number_p (gh_cdr (extra_dims)))
+ gh_number_p (ly_car (extra_dims))
+ && gh_number_p (ly_cdr (extra_dims)))
{
- y[LEFT] += gh_scm2double (gh_car (extra_dims));
- y[RIGHT] += gh_scm2double (gh_cdr (extra_dims));
+ y[LEFT] += gh_scm2double (ly_car (extra_dims));
+ y[RIGHT] += gh_scm2double (ly_cdr (extra_dims));
}
elems.push (e);
Axis
Align_interface::axis (Grob*me)
{
- return Axis (gh_scm2int (gh_car (me->get_grob_property ("axes"))));
+ return Axis (gh_scm2int (ly_car (me->get_grob_property ("axes"))));
}
int c =0;
while (gh_pair_p (e))
{
- if (gh_car (e) == s->self_scm ())
+ if (ly_car (e) == s->self_scm ())
break;
c++;
- e = gh_cdr (e);
+ e = ly_cdr (e);
}
return c;
}
Grob *me = unsmob_grob (smob);
Grob * common = me;
- for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * stem = unsmob_grob (gh_car (s));
+ Grob * stem = unsmob_grob (ly_car (s));
common = common->common_refpoint (Staff_symbol_referencer::staff_symbol_l (stem),
Y_AXIS);
}
Interval heads;
Real my_y = me->relative_coordinate (common, Y_AXIS);
- for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * stem = unsmob_grob (gh_car (s));
+ Grob * stem = unsmob_grob (ly_car (s));
Grob * ss = Staff_symbol_referencer::staff_symbol_l (stem);
Interval iv =Stem::head_positions (stem);
iv *= Staff_symbol::staff_space (ss)/2.0;
bool
Auto_beam_engraver::test_moment (Direction dir, Moment test_mom)
{
- SCM wild = gh_list (ly_symbol2scm ("*"), ly_symbol2scm ("*"), SCM_UNDEFINED);
+ SCM wild = scm_listify (ly_symbol2scm ("*"), ly_symbol2scm ("*"), SCM_UNDEFINED);
SCM function;
if (dir == START)
- function = gh_list (ly_symbol2scm ("begin"), SCM_UNDEFINED);
+ function = scm_listify (ly_symbol2scm ("begin"), SCM_UNDEFINED);
else
- function = gh_list (ly_symbol2scm ("end"), SCM_UNDEFINED);
+ function = scm_listify (ly_symbol2scm ("end"), SCM_UNDEFINED);
Moment one_beat = *unsmob_moment (get_property ("beatLength"));
int num = int ((*unsmob_moment (get_property ("measureLength")) / one_beat).main_part_);
int den = one_beat.den ();
- SCM time = gh_list (gh_int2scm (num), gh_int2scm (den), SCM_UNDEFINED);
+ SCM time = scm_listify (gh_int2scm (num), gh_int2scm (den), SCM_UNDEFINED);
- SCM type = gh_list (gh_int2scm (test_mom.num ()),
+ SCM type = scm_listify (gh_int2scm (test_mom.num ()),
gh_int2scm (test_mom.den ()), SCM_UNDEFINED);
SCM settings = get_property ("autoBeamSettings");
/* second guess: property generic time exception */
SCM m = gh_assoc (gh_append3 (function, wild, time), settings);
- if (m != SCM_BOOL_F && unsmob_moment (gh_cdr (m)))
- moment = * unsmob_moment (gh_cdr (m));
+ if (m != SCM_BOOL_F && unsmob_moment (ly_cdr (m)))
+ moment = * unsmob_moment (ly_cdr (m));
/* third guess: property time exception, specific for duration type */
m = gh_assoc (gh_append3 (function, type, time), settings);
- if (m != SCM_BOOL_F && unsmob_moment (gh_cdr (m)))
- moment = * unsmob_moment (gh_cdr (m));
+ if (m != SCM_BOOL_F && unsmob_moment (ly_cdr (m)))
+ moment = * unsmob_moment (ly_cdr (m));
/* fourth guess [user override]: property plain generic */
m = gh_assoc (gh_append3 (function, wild, wild), settings);
- if (m != SCM_BOOL_F && unsmob_moment (gh_cdr (m)))
- moment = * unsmob_moment (gh_cdr (m));
+ if (m != SCM_BOOL_F && unsmob_moment (ly_cdr (m)))
+ moment = * unsmob_moment (ly_cdr (m));
/* fifth guess [user override]: property plain, specific for duration type */
m = gh_assoc (gh_append3 (function, type, wild), settings);
- if (m != SCM_BOOL_F && unsmob_moment (gh_cdr (m)))
- moment = * unsmob_moment (gh_cdr (m));
+ if (m != SCM_BOOL_F && unsmob_moment (ly_cdr (m)))
+ moment = * unsmob_moment (ly_cdr (m));
Rational r;
if (moment.to_bool ())
while (1)
{
SCM muses = iter->get_music (m);
- for (SCM s = muses; gh_pair_p (s); s=gh_cdr (s))
- if (Note_req* nr = dynamic_cast<Note_req*> (unsmob_music (gh_car (s))))
+ for (SCM s = muses; gh_pair_p (s); s=ly_cdr (s))
+ if (Note_req* nr = dynamic_cast<Note_req*> (unsmob_music (ly_car (s))))
{
ps.push (*unsmob_pitch (nr->get_mus_property ("pitch")));
}
String type = daddy_grav_l ()->type_str_ ;
SCM dims = get_property ("VerticalExtent");
- if (gh_pair_p (dims) && gh_number_p (gh_car (dims))
- && gh_number_p (gh_cdr (dims)))
+ if (gh_pair_p (dims) && gh_number_p (ly_car (dims))
+ && gh_number_p (ly_cdr (dims)))
{
staffline_p_->set_extent_callback (Grob::preset_extent_proc, Y_AXIS);
staffline_p_->set_grob_property ("extent-Y", dims);
}
dims = get_property ("MinimumVerticalExtent");
- if (gh_pair_p (dims) && gh_number_p (gh_car (dims))
- && gh_number_p (gh_cdr (dims)))
+ if (gh_pair_p (dims) && gh_number_p (ly_car (dims))
+ && gh_number_p (ly_cdr (dims)))
staffline_p_->set_grob_property ("minimum-extent-Y", dims);
dims = get_property ("ExtraVerticalExtent");
- if (gh_pair_p (dims) && gh_number_p (gh_car (dims))
- && gh_number_p (gh_cdr (dims)))
+ if (gh_pair_p (dims) && gh_number_p (ly_car (dims))
+ && gh_number_p (ly_cdr (dims)))
staffline_p_->set_grob_property ("extra-extent-Y", dims);
Grob * it = unsmob_grob (get_property ("currentCommandColumn"));
void
Axis_group_interface::add_element (Grob*me,Grob *e)
{
- for (SCM ax = me->get_grob_property ("axes"); ax != SCM_EOL ; ax = gh_cdr (ax))
+ for (SCM ax = me->get_grob_property ("axes"); ax != SCM_EOL ; ax = ly_cdr (ax))
{
- Axis a = (Axis) gh_scm2int (gh_car (ax));
+ Axis a = (Axis) gh_scm2int (ly_car (ax));
if (!e->parent_l (a))
e->set_parent (me, a);
Axis_group_interface::relative_group_extent (Axis a, Grob *common, SCM elts)
{
Interval r;
- for (SCM s = elts; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = elts; gh_pair_p (s); s = ly_cdr (s))
{
- Grob * se = unsmob_grob (gh_car (s));
+ Grob * se = unsmob_grob (ly_car (s));
Interval dims = se->extent (common, a);
if (!dims.empty_b ())
r.unite (dims);
Grob * common = (Grob*) me;
- for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * se = unsmob_grob (gh_car (s));
+ Grob * se = unsmob_grob (ly_car (s));
common = se->common_refpoint (common, a);
}
if (!has_interface (me))
return childs;
- for (SCM ep = me->get_grob_property ("elements"); gh_pair_p (ep); ep = gh_cdr (ep))
+ for (SCM ep = me->get_grob_property ("elements"); gh_pair_p (ep); ep = ly_cdr (ep))
{
- Grob* e = unsmob_grob (gh_car (ep));
+ Grob* e = unsmob_grob (ly_car (ep));
if (e)
childs.concat (Axis_group_interface::get_children (e));
}
Beam::get_multiplicity (Grob*me)
{
int m = 0;
- for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * sc = unsmob_grob (gh_car (s));
+ Grob * sc = unsmob_grob (ly_car (s));
if (Stem::has_interface (sc))
m = m >? Stem::beam_count (sc,LEFT) >? Stem::beam_count (sc,RIGHT);
somewhere (?), I guess, not by looping here. */
SCM list = me->get_grob_property ("y-dy-callbacks");
- for (SCM i = list; gh_pair_p (i); i = gh_cdr (i))
- gh_call1 (gh_car (i), smob);
+ for (SCM i = list; gh_pair_p (i); i = ly_cdr (i))
+ gh_call1 (ly_car (i), smob);
// UGH. Y is not in staff position unit?
// Ik dacht datwe daar juist van weg wilden?
gh_double2scm (me->paper_l ()->get_var ("stafflinethickness")
/ 1.0));
- for (SCM s = quants; gh_pair_p (s); s = gh_cdr (s))
- a.push (gh_scm2double (gh_car (s)));
+ for (SCM s = quants; gh_pair_p (s); s = ly_cdr (s))
+ a.push (gh_scm2double (ly_car (s)));
if (a.size () > 1)
{
SCM proc = me->get_grob_property ("vertical-position-quant-function");
SCM quants = scm_apply (proc,
me->self_scm (),
- gh_list (gh_int2scm (multiplicity),
+ scm_listify (gh_int2scm (multiplicity),
gh_double2scm (dy/staff_space),
gh_double2scm (thick/staff_space),
SCM_EOL, SCM_UNDEFINED));
Array<Real> a;
- for (; gh_pair_p (quants); quants = gh_cdr (quants))
- a.push (gh_scm2double (gh_car (quants)));
+ for (; gh_pair_p (quants); quants = ly_cdr (quants))
+ a.push (gh_scm2double (ly_car (quants)));
if (a.size () <= 1)
return y;
Break_align_engraver::stop_translation_timestep ()
{
SCM order = get_property ("breakAlignOrder");
- for (; gh_pair_p (order); order = gh_cdr (order))
+ for (; gh_pair_p (order); order = ly_cdr (order))
{
- SCM p = scm_assoc (gh_car (order), column_alist_);
+ SCM p = scm_assoc (ly_car (order), column_alist_);
if (gh_pair_p (p))
{
- add_column (gh_cdr (p));
- column_alist_ = scm_assoc_remove_x (column_alist_, gh_car (order));
+ add_column (ly_cdr (p));
+ column_alist_ = scm_assoc_remove_x (column_alist_, ly_car (order));
}
}
- for (SCM p = column_alist_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = column_alist_; gh_pair_p (p); p = ly_cdr (p))
{
- SCM pair = gh_car (p);
- add_column (gh_cdr (pair));
+ SCM pair = ly_car (p);
+ add_column (ly_cdr (pair));
}
if (s != SCM_BOOL_F)
{
- Grob *e = unsmob_grob (gh_cdr (s));
+ Grob *e = unsmob_grob (ly_cdr (s));
group = dynamic_cast<Item*> (e);
}
else
SCM extra_space;
if (e != SCM_BOOL_F)
{
- extra_space = gh_cdr (e);
+ extra_space = ly_cdr (e);
}
else
{
extra_space = scm_list_n (ly_symbol2scm ("minimum-space"), gh_double2scm (0.0), SCM_UNDEFINED);
}
- SCM symbol = gh_car (extra_space);
+ SCM symbol = ly_car (extra_space);
Real spc = gh_scm2double (gh_cadr (extra_space));
dists.push (spc);
// skip the first sym.
- symbol_list = gh_cdr (scm_reverse (symbol_list));
+ symbol_list = ly_cdr (scm_reverse (symbol_list));
for (int i=0; i <elems.size ()-1; i++)
{
- elems[i]->set_grob_property (gh_car (symbol_list),
+ elems[i]->set_grob_property (ly_car (symbol_list),
scm_cons (gh_double2scm (0),
gh_double2scm (dists[i+1])));
- symbol_list = gh_cdr (symbol_list);
+ symbol_list = ly_cdr (symbol_list);
}
Real stretch_distance =0.;
- if (gh_car (symbol_list) == ly_symbol2scm ("extra-space"))
+ if (ly_car (symbol_list) == ly_symbol2scm ("extra-space"))
{
spring_len += dists.top ();
stretch_distance = dists.top ();
}
- else if (gh_car (symbol_list) == ly_symbol2scm ("minimum-space"))
+ else if (ly_car (symbol_list) == ly_symbol2scm ("minimum-space"))
{
spring_len = spring_len >? dists.top ();
stretch_distance = spring_len;
void
Chord_name_engraver::add_note (Note_req* n)
{
- SCM pitches = gh_car (chord_);
- SCM modifiers = gh_cdr (chord_);
- SCM inversion = modifiers == SCM_EOL ? SCM_EOL : gh_car (modifiers);
- SCM bass = modifiers == SCM_EOL ? SCM_EOL : gh_cdr (modifiers);
+ SCM pitches = ly_car (chord_);
+ SCM modifiers = ly_cdr (chord_);
+ SCM inversion = modifiers == SCM_EOL ? SCM_EOL : ly_car (modifiers);
+ SCM bass = modifiers == SCM_EOL ? SCM_EOL : ly_cdr (modifiers);
if (n->get_mus_property ("inversion") == SCM_BOOL_T)
inversion = n->get_mus_property ("pitch");
void
Chord_name_engraver::create_grobs ()
{
- if (!chord_name_p_ && gh_car (chord_) != SCM_EOL)
+ if (!chord_name_p_ && ly_car (chord_) != SCM_EOL)
{
chord_name_p_ = new Item (get_property ("ChordName"));
chord_name_p_->set_grob_property ("chord", chord_);
announce_grob (chord_name_p_, 0);
SCM s = get_property ("chordChanges");
- if (to_boolean (s) && gh_car (last_chord_) != SCM_EOL
+ if (to_boolean (s) && ly_car (last_chord_) != SCM_EOL
&& gh_equal_p (chord_, last_chord_))
chord_name_p_->set_grob_property ("begin-of-line-visible", SCM_BOOL_T);
}
}
chord_name_p_ = 0;
- if (gh_car (chord_) != SCM_EOL)
+ if (ly_car (chord_) != SCM_EOL)
last_chord_ = chord_;
chord_ = gh_cons (SCM_EOL, gh_cons (SCM_EOL, SCM_EOL));
}
ly_unique (SCM list)
{
SCM unique = SCM_EOL;
- for (SCM i = list; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = list; gh_pair_p (i); i = ly_cdr (i))
{
- if (!gh_pair_p (gh_cdr (i))
- || !gh_equal_p (gh_car (i), gh_cadr (i)))
- unique = gh_cons (gh_car (i), unique);
+ if (!gh_pair_p (ly_cdr (i))
+ || !gh_equal_p (ly_car (i), gh_cadr (i)))
+ unique = gh_cons (ly_car (i), unique);
}
return gh_reverse (unique);
}
ly_remove_member (SCM s, SCM list)
{
SCM removed = SCM_EOL;
- for (SCM i = list; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = list; gh_pair_p (i); i = ly_cdr (i))
{
- if (!gh_equal_p (gh_car (i), s))
- removed = gh_cons (gh_car (i), removed);
+ if (!gh_equal_p (ly_car (i), s))
+ removed = gh_cons (ly_car (i), removed);
}
return gh_reverse (removed);
}
SCM
ly_snoc (SCM s, SCM list)
{
- return gh_append2 (list, gh_list (s, SCM_UNDEFINED));
+ return gh_append2 (list, scm_listify (s, SCM_UNDEFINED));
}
SCM after = list;
for (; gh_pair_p (after);)
{
- SCM i = gh_car (after);
- after = gh_cdr (after);
+ SCM i = ly_car (after);
+ after = ly_cdr (after);
if (gh_equal_p (i, s))
break;
before = gh_cons (i, before);
SCM minor = Pitch (0, 2, -1).smobbed_copy ();
base = gh_cons (tonic, base);
- base = gh_cons (Pitch::transpose (gh_car (base), major), base);
- base = gh_cons (Pitch::transpose (gh_car (base), minor), base);
+ base = gh_cons (Pitch::transpose (ly_car (base), major), base);
+ base = gh_cons (Pitch::transpose (ly_car (base), minor), base);
return gh_reverse (base);
}
hoe doe je lambda in C?
*/
SCM transposed = SCM_EOL;
- for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = pitches; gh_pair_p (i); i = ly_cdr (i))
{
- transposed = gh_cons (Pitch::transpose (tonic, gh_car (i)),
+ transposed = gh_cons (Pitch::transpose (tonic, ly_car (i)),
transposed);
}
return gh_reverse (transposed);
Chord::lower_step (SCM tonic, SCM pitches, SCM step)
{
SCM lowered = SCM_EOL;
- for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = pitches; gh_pair_p (i); i = ly_cdr (i))
{
- SCM p = gh_car (i);
- if (gh_equal_p (step_scm (tonic, gh_car (i)), step)
+ SCM p = ly_car (i);
+ if (gh_equal_p (step_scm (tonic, ly_car (i)), step)
|| gh_scm2int (step) == 0)
{
p = Pitch::transpose (p, Pitch (0, 0, -1).smobbed_copy ());
SCM member = gh_member (p, pitches);
if (member == SCM_BOOL_F)
{
- for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = pitches; gh_pair_p (i); i = ly_cdr (i))
{
/*
Urg, eindelijk gevonden: () != #f, kan maar niet aan wennen.
Anders kon iets korter...
*/
if (unsmob_pitch (p)->notename_i_
- == unsmob_pitch (gh_car (i))->notename_i_)
+ == unsmob_pitch (ly_car (i))->notename_i_)
{
- member = gh_car (i);
+ member = ly_car (i);
break;
}
}
}
else
- member = gh_car (member);
+ member = ly_car (member);
return member;
}
SCM member = gh_member (p, pitches);
if (member == SCM_BOOL_F)
{
- for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = pitches; gh_pair_p (i); i = ly_cdr (i))
{
if (unsmob_pitch (p)->notename_i_
- == unsmob_pitch (gh_car (i))->notename_i_
+ == unsmob_pitch (ly_car (i))->notename_i_
&& unsmob_pitch (p)->alteration_i_
- == unsmob_pitch (gh_car (i))->alteration_i_)
+ == unsmob_pitch (ly_car (i))->alteration_i_)
{
- member = gh_car (i);
+ member = ly_car (i);
break;
}
}
}
else
- member = gh_car (member);
+ member = ly_car (member);
return member;
}
thirds);
thirds = scm_vector (gh_reverse (thirds));
- SCM tonic = gh_car (pitches);
+ SCM tonic = ly_car (pitches);
SCM last = tonic;
SCM missing = SCM_EOL;
for (SCM i = pitches; gh_pair_p (i);)
{
- SCM p = gh_car (i);
+ SCM p = ly_car (i);
int step = gh_scm2int (step_scm (tonic, p));
if (unsmob_pitch (last)->notename_i_ == unsmob_pitch (p)->notename_i_)
}
else
{
- i = gh_cdr (i);
+ i = ly_cdr (i);
}
}
{
/* Should we maybe first make sure that PITCH is below tonic? */
if (pitches != SCM_EOL)
- while (Pitch::less_p (pitch, gh_car (pitches)) == SCM_BOOL_T)
+ while (Pitch::less_p (pitch, ly_car (pitches)) == SCM_BOOL_T)
pitch = Pitch::transpose (pitch, Pitch (1, 0, 0).smobbed_copy ());
pitches = gh_cons (pitch, pitches);
Chord::add_below_tonic (SCM pitch, SCM pitches)
{
if (pitches != SCM_EOL)
- while (Pitch::less_p (gh_car (pitches), pitch) == SCM_BOOL_T)
+ while (Pitch::less_p (ly_car (pitches), pitch) == SCM_BOOL_T)
pitch = Pitch::transpose (pitch, Pitch (-1, 0, 0).smobbed_copy ());
return gh_cons (pitch, pitches);
}
{
/* urg: catch dim modifier: 3rd, 5th, 7th, .. should be lowered */
bool dim_b = false;
- for (SCM i = add; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = add; gh_pair_p (i); i = ly_cdr (i))
{
- Pitch* p = unsmob_pitch (gh_car (i));
+ Pitch* p = unsmob_pitch (ly_car (i));
/* Ugr
This chord modifier stuff should really be fixed
Cmaj7 yields C 7/7-
SCM pitches = SCM_EOL;
/* Add all that aren't subtracted */
- for (SCM i = add; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = add; gh_pair_p (i); i = ly_cdr (i))
{
- SCM p = gh_car (i);
+ SCM p = ly_car (i);
SCM s = member_notename (p, sub);
if (s != SCM_BOOL_F)
sub = scm_delete (s, sub);
}
pitches = scm_sort_list (pitches, Pitch::less_p_proc);
- for (SCM i = sub; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = sub; gh_pair_p (i); i = ly_cdr (i))
warning (_f ("invalid subtraction: not part of chord: %s",
- unsmob_pitch (gh_car (i))->str ()));
+ unsmob_pitch (ly_car (i))->str ()));
return pitches;
}
/* Then, delete and add as base note, ie: the inversion */
pitches = scm_delete (s, pitches);
Note_req* n = new Note_req;
- n->set_mus_property ("pitch", gh_car (add_below_tonic (s, pitches)));
+ n->set_mus_property ("pitch", ly_car (add_below_tonic (s, pitches)));
n->set_mus_property ("duration", dur);
n->set_mus_property ("inversion", SCM_BOOL_T);
list = gh_cons (n->self_scm (), list);
if (bass != SCM_EOL)
{
Note_req* n = new Note_req;
- n->set_mus_property ("pitch", gh_car (add_below_tonic (bass, pitches)));
+ n->set_mus_property ("pitch", ly_car (add_below_tonic (bass, pitches)));
n->set_mus_property ("duration", dur);
n->set_mus_property ("bass", SCM_BOOL_T);
list = gh_cons (n->self_scm (), list);
scm_gc_unprotect_object (n->self_scm ());
}
- for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = pitches; gh_pair_p (i); i = ly_cdr (i))
{
Note_req* n = new Note_req;
- n->set_mus_property ("pitch", gh_car (i));
+ n->set_mus_property ("pitch", ly_car (i));
n->set_mus_property ("duration", dur);
list = gh_cons (n->self_scm (), list);
scm_gc_unprotect_object (n->self_scm ());
Real wid
= gh_scm2double (me->get_grob_property ("note-width"));
- for (; gh_pair_p (hand); hand =gh_cdr (hand))
+ for (; gh_pair_p (hand); hand =ly_cdr (hand))
{
Grob * s = unsmob_grob (gh_caar (hand));
Real amount = gh_scm2double (gh_cdar (hand));
s->translate_axis (amount *wid, X_AXIS);
done.push (s);
}
- for (; gh_pair_p (autos); autos =gh_cdr (autos))
+ for (; gh_pair_p (autos); autos =ly_cdr (autos))
{
Grob * s = unsmob_grob (gh_caar (autos));
Real amount = gh_scm2double (gh_cdar (autos));
SCM tups = SCM_EOL;
SCM s = me->get_grob_property ("elements");
- for (; gh_pair_p (s); s = gh_cdr (s))
+ for (; gh_pair_p (s); s = ly_cdr (s))
{
- SCM car = gh_car (s);
+ SCM car = ly_car (s);
Grob * se = unsmob_grob (car);
if (Note_column::has_interface (se))
SCM tups = SCM_EOL;
SCM s = me->get_grob_property ("elements");
- for (; gh_pair_p (s); s = gh_cdr (s))
+ for (; gh_pair_p (s); s = ly_cdr (s))
{
- Grob * se = unsmob_grob (gh_car (s));
+ Grob * se = unsmob_grob (ly_car (s));
SCM force = se->remove_grob_property ("force-hshift");
if (gh_number_p (force))
{
SCM newlist = SCM_EOL;
SCM pa = get_mus_property ("pitch-alist");
- for (SCM s = pa; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = pa; gh_pair_p (s); s = ly_cdr (s))
{
SCM key = gh_caar (s);
SCM alter = gh_cdar (s);
if (gh_pair_p (key))
{
- Pitch orig (gh_scm2int (gh_car (key)),
- gh_scm2int (gh_cdr (key)),
+ Pitch orig (gh_scm2int (ly_car (key)),
+ gh_scm2int (ly_cdr (key)),
gh_scm2int (alter));
orig.transpose (p);
alist_equal_p (SCM a, SCM b)
{
for (SCM s = a;
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
SCM key = gh_caar (s);
SCM val = gh_cdar (s);
SCM l = scm_assoc (key, b);
if (l == SCM_BOOL_F
- || !gh_equal_p ( gh_cdr (l), val))
+ || !gh_equal_p ( ly_cdr (l), val))
return false;
}
Link_array<Grob> dots;
while (gh_pair_p (l))
{
- dots.push (unsmob_grob (gh_car (l)));
- l = gh_cdr (l);
+ dots.push (unsmob_grob (ly_car (l)));
+ l = ly_cdr (l);
}
dots.sort (compare_position);
int
Duration::print_smob (SCM s, SCM port, scm_print_state *)
{
- Duration *r = (Duration *) gh_cdr (s);
+ Duration *r = (Duration *) ly_cdr (s);
scm_puts ("#<Duration ", port);
scm_display (ly_str02scm (r->str ().ch_C ()), port);
SCM
Duration::equal_p (SCM a , SCM b)
{
- Duration *p = (Duration *) gh_cdr (a);
- Duration *q = (Duration *) gh_cdr (b);
+ Duration *p = (Duration *) ly_cdr (a);
+ Duration *q = (Duration *) ly_cdr (b);
bool eq = p->dots_i_ == q->dots_i_
&& p->durlog_i_ == q->durlog_i_
if (gh_pair_p (s))
{
Interval iv;
- iv[MIN] = gh_scm2double (gh_car (s));
- iv[MAX] = gh_scm2double (gh_cdr (s));
+ iv[MIN] = gh_scm2double (ly_car (s));
+ iv[MAX] = gh_scm2double (ly_cdr (s));
volume = iv[MIN] + iv.length () * volume;
}
}
Engraver_group_engraver::create_grobs ()
{
- for (SCM p = simple_trans_list_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = simple_trans_list_; gh_pair_p (p); p = ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Engraver * eng = dynamic_cast<Engraver*> (t);
if (eng)
eng->create_grobs ();
for (int j =0; j < announce_info_arr_.size (); j++)
{
Grob_info info = announce_info_arr_[j];
- for (SCM p = simple_trans_list_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = simple_trans_list_; gh_pair_p (p); p = ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Engraver * eng = dynamic_cast<Engraver*> (t);
if (eng && eng!= info.origin_trans_l_)
eng->acknowledge_grob (info);
void
Engraver_group_engraver::do_announces ()
{
- for (SCM p = trans_group_list_; gh_pair_p (p); p =gh_cdr (p))
+ for (SCM p = trans_group_list_; gh_pair_p (p); p =ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
dynamic_cast<Engraver_group_engraver*> (t)->do_announces ();
}
void
Engraver_group_engraver::process_music ()
{
- for (SCM p = simple_trans_list_; gh_pair_p (p); p =gh_cdr (p))
+ for (SCM p = simple_trans_list_; gh_pair_p (p); p =ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Engraver * eng = dynamic_cast<Engraver*> (t);
if (eng)
eng->process_music ();
}
- for (SCM p = trans_group_list_; gh_pair_p (p); p =gh_cdr (p))
+ for (SCM p = trans_group_list_; gh_pair_p (p); p =ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Engraver*eng = dynamic_cast<Engraver*> (t);
if (eng)
eng->process_music ();
figure_->get_grob_property ("accidental-alist"));
if (gh_pair_p (alter))
{
- one_fig = gh_list (ly_symbol2scm ("columns"),
+ one_fig = scm_listify (ly_symbol2scm ("columns"),
one_fig,
- gh_cdr(alter),
+ ly_cdr(alter),
SCM_UNDEFINED);
}
}
SCM
Font_interface::font_alist_chain (Grob *me)
{
- SCM defaults = gh_cdr (scm_assoc (ly_symbol2scm ("font-defaults"),
+ SCM defaults = ly_cdr (scm_assoc (ly_symbol2scm ("font-defaults"),
me->paper_l ()->style_sheet_));
- SCM ch = gh_list (me->mutable_property_alist_,
+ SCM ch = scm_listify (me->mutable_property_alist_,
me->immutable_property_alist_,
defaults,
SCM_UNDEFINED);
SCM ss = me->paper_l ()->style_sheet_;
- SCM proc = gh_cdr (scm_assoc (ly_symbol2scm ("properties-to-font"),
+ SCM proc = ly_cdr (scm_assoc (ly_symbol2scm ("properties-to-font"),
ss));
- SCM fonts = gh_cdr (scm_assoc (ly_symbol2scm ("fonts"), ss));
+ SCM fonts = ly_cdr (scm_assoc (ly_symbol2scm ("fonts"), ss));
assert (gh_procedure_p (proc));
SCM font_name = gh_call2 (proc, fonts, chain);
SCM sheet = me->paper_l ()->style_sheet_;
- SCM style_alist = gh_cdr (scm_assoc (ly_symbol2scm ("style-alist"), sheet));
+ SCM style_alist = ly_cdr (scm_assoc (ly_symbol2scm ("style-alist"), sheet));
SCM entry = scm_assoc (style, style_alist);
if (gh_pair_p (entry))
{
- chain = gh_cons (gh_cdr (entry), chain);
+ chain = gh_cons (ly_cdr (entry), chain);
}
return chain;
}
series = ly_assoc_chain (series_sym, alist_chain);
if (gh_pair_p (shape))
- shape = gh_cdr (shape);
+ shape = ly_cdr (shape);
if (gh_pair_p (family))
- family = gh_cdr (family);
+ family = ly_cdr (family);
if (gh_pair_p (series))
- series = gh_cdr (series);
+ series = ly_cdr (series);
}
else
- name = gh_cdr (name);
+ name = ly_cdr (name);
if (gh_pair_p (point_sz))
- point_sz = gh_cdr (point_sz);
+ point_sz = ly_cdr (point_sz);
else
{
rel_sz = ly_assoc_chain (rel_sz_sym, alist_chain);
if (gh_pair_p (rel_sz))
- rel_sz = gh_cdr (rel_sz);
+ rel_sz = ly_cdr (rel_sz);
}
- for (SCM s = fonts ; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = fonts ; gh_pair_p (s); s = ly_cdr (s))
{
SCM qlist = gh_caar (s);
}
else
{
- if (!wild_compare (gh_car (qlist), rel_sz))
+ if (!wild_compare (ly_car (qlist), rel_sz))
continue;
}
}
warning (_ ("couldn't find any font satisfying "));
- scm_write (gh_list (name, point_sz, shape, series , family, rel_sz, SCM_UNDEFINED), scm_current_error_port ());
+ scm_write (scm_listify (name, point_sz, shape, series , family, rel_sz, SCM_UNDEFINED), scm_current_error_port ());
scm_flush (scm_current_error_port ());
return ly_str02scm ("cmr10");
optimal_paths[0] = first_node;
int break_idx=1;
+ Real worst_force = 0.0;
+
for (; break_idx< breaks.size (); break_idx++)
{
/*
sp->solve (&cp);
delete sp;
+ if (cp.force_f_ > worst_force)
+ worst_force = cp.force_f_;
+
+ /*
+ We remember this solution as a "should always work
+ solution", in case everything fucks up. */
if (start_idx == break_idx - 1)
- backup_sol = cp; // in case everything fucks up
+ backup_sol = cp;
if (!cp.satisfies_constraints_b_)
- break;
-
+ {
+ /*
+ If it doesn't satisfy constraints, we make this one
+ really unattractive.
+ */
+ cp.force_f_ += worst_force;
+ cp.force_f_ *= 10;
+ }
Real this_demerits;
+
if (optimal_paths[start_idx].demerits_f_ >= infinity_f)
this_demerits = infinity_f;
else
minimal_sol = cp;
minimal_demerits = this_demerits;
}
+
+ /*
+ we couldn't satisfy the constraints, this won't get better
+ if we add more columns, so we get on with the next one
+ */
+ if (!cp.satisfies_constraints_b_)
+ break ;
}
int prev =break_idx - 1;
if (optimal_paths.top ().demerits_f_ >= infinity_f)
warning (_ ("No feasible line breaking found"));
- for (int i= final_breaks.size (); i--;)
- lines.push (optimal_paths[final_breaks[i]].line_config_);
-
+ for (int i= final_breaks.size (); i--;)
+ {
+ Column_x_positions cp (optimal_paths[final_breaks[i]].line_config_);
+
+ lines.push (cp);
+ if(!cp.satisfies_constraints_b_)
+ warning ("Could not find line breaking that satisfies constraints.");
+ }
return lines;
}
SCM meta = get_grob_property ("meta");
SCM ifs = scm_assoc (ly_symbol2scm ("interfaces"), meta);
- set_grob_property ("interfaces",gh_cdr (ifs));
+ set_grob_property ("interfaces",ly_cdr (ifs));
}
{
SCM s = scm_sloppy_assq (sym, mutable_property_alist_);
if (s != SCM_BOOL_F)
- return gh_cdr (s);
+ return ly_cdr (s);
s = scm_sloppy_assq (sym, immutable_property_alist_);
- return (s == SCM_BOOL_F) ? SCM_EOL : gh_cdr (s);
+ return (s == SCM_BOOL_F) ? SCM_EOL : ly_cdr (s);
}
/*
if (gh_pair_p (ext))
{
- Real l = gh_scm2double (gh_car (ext));
- Real r = gh_scm2double (gh_cdr (ext));
+ Real l = gh_scm2double (ly_car (ext));
+ Real r = gh_scm2double (ly_cdr (ext));
return ly_interval2scm (Interval (l, r));
}
status_c_= busy;
- for (SCM d= get_grob_property ("dependencies"); gh_pair_p (d); d = gh_cdr (d))
+ for (SCM d= get_grob_property ("dependencies"); gh_pair_p (d); d = ly_cdr (d))
{
- unsmob_grob (gh_car (d))
+ unsmob_grob (ly_car (d))
->calculate_dependencies (final, busy, funcname);
}
SCM mol = SCM_EOL;
if (gh_procedure_p (proc))
- mol = gh_apply (proc, gh_list (this->self_scm (), SCM_UNDEFINED));
+ mol = gh_apply (proc, scm_listify (this->self_scm (), SCM_UNDEFINED));
Molecule *m = unsmob_molecule (mol);
// ugr.
mol = Molecule (m->extent_box (),
- gh_list (origin, m->get_expr (), SCM_UNDEFINED)
+ scm_listify (origin, m->get_expr (), SCM_UNDEFINED)
). smobbed_copy ();
m = unsmob_molecule (mol);
}
else if (gh_pair_p (src))
{
- SCM oldcar =gh_car (src);
+ SCM oldcar =ly_car (src);
/*
UGH! breaks on circular lists.
*/
SCM newcar = handle_broken_grobs (oldcar, criterion);
- SCM oldcdr = gh_cdr (src);
+ SCM oldcdr = ly_cdr (src);
if (newcar == SCM_UNDEFINED
&& (gh_pair_p (oldcdr) || oldcdr == SCM_EOL))
*/
if (gh_pair_p (extra))
{
- ext[BIGGER] += gh_scm2double (gh_cdr (extra));
- ext[SMALLER] += gh_scm2double (gh_car (extra));
+ ext[BIGGER] += gh_scm2double (ly_cdr (extra));
+ ext[SMALLER] += gh_scm2double (ly_car (extra));
}
extra = get_grob_property (a == X_AXIS
: "minimum-extent-Y");
if (gh_pair_p (extra))
{
- ext.unite (Interval (gh_scm2double (gh_car (extra)),
- gh_scm2double (gh_cdr (extra))));
+ ext.unite (Interval (gh_scm2double (ly_car (extra)),
+ gh_scm2double (ly_cdr (extra))));
}
ext.translate (x);
Grob::common_refpoint (SCM elist, Axis a) const
{
Grob * common = (Grob*) this;
- for (; gh_pair_p (elist); elist = gh_cdr (elist))
+ for (; gh_pair_p (elist); elist = ly_cdr (elist))
{
- Grob * s = unsmob_grob (gh_car (elist));
+ Grob * s = unsmob_grob (ly_car (elist));
if (s)
common = common->common_refpoint (s, a);
}
{
SCM meta = get_grob_property ("meta");
SCM nm = scm_assoc (ly_symbol2scm ("name"), meta);
- nm = (gh_pair_p (nm)) ? gh_cdr (nm) : SCM_EOL;
+ nm = (gh_pair_p (nm)) ? ly_cdr (nm) : SCM_EOL;
return gh_string_p (nm) ?ly_scm2string (nm) : classname (this);
}
int
Grob::print_smob (SCM s, SCM port, scm_print_state *)
{
- Grob *sc = (Grob *) gh_cdr (s);
+ Grob *sc = (Grob *) ly_cdr (s);
scm_puts ("#<Grob ", port);
scm_puts ((char *)sc->name ().ch_C (), port);
Lookup::line (XY1, XY2).
*/
- SCM hairpin = gh_list (ly_symbol2scm ("hairpin"),
+ SCM hairpin = scm_listify (ly_symbol2scm ("hairpin"),
gh_double2scm (thick),
gh_double2scm (width),
gh_double2scm (starth),
#ifndef LILY_GUILE_HH
#define LILY_GUILE_HH
-#include <guile/gh.h>
#include <libguile.h>
+
+/*
+ TODO: the GH interface is deprecated as of GUILE 1.6
+
+ Remove all gh_XXX functions.
+ */
+#include <guile/gh.h>
+
#include "config.h"
/* Guile 1.3.4 compatibility */
bool type_check_assignment (SCM val, SCM sym, SCM type_symbol) ;
SCM ly_number2string (SCM s);
+
+#define ly_cdr(x) SCM_CDR(x)
+#define ly_car(x) SCM_CAR(x)
+#define ly_caar(x) SCM_CAAR(x)
+#define ly_cdar(x) SCM_CDAR(x)
+#define ly_cadr(x) SCM_CADR(x)
+#define ly_cddr(x) SCM_CDDR(x)
+
+#define ly_pair_p(x) SCM_PAIRP(x)
+#define ly_symbol_p(x) SCM_SYMBOLP(x)
+#define ly_number_p(x) SCM_NUMBERP(x)
+#define ly_procedure_p(x) SCM_NFALSEP(scm_procedure_p(x))
+
/*
display and print newline.
*/
#ifndef PROTECTED_SCM_HH
#define PROTECTED_SCM_HH
-#include <guile/gh.h>
+#include <libguile.h>
/*
Mix GUILE GC with C++ ctors and dtors.
{
SCM args = scm_list_n (gh_int2scm (break_status_dir ()), SCM_UNDEFINED);
SCM result = gh_apply (vis, args);
- bool trans = gh_scm2bool (gh_car (result));
- bool empty = gh_scm2bool (gh_cdr (result));
+ bool trans = gh_scm2bool (ly_car (result));
+ bool empty = gh_scm2bool (ly_cdr (result));
if (empty && trans)
suicide ();
SCM n = scm_list_copy (p);
SCM accs = SCM_EOL;
for (SCM s = get_property ("keyAccidentalOrder");
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- if (gh_pair_p (scm_member (gh_car (s), n)))
+ if (gh_pair_p (scm_member (ly_car (s), n)))
{
- accs = gh_cons (gh_car (s), accs);
- n = scm_delete_x (gh_car (s), n);
+ accs = gh_cons (ly_car (s), accs);
+ n = scm_delete_x (ly_car (s), n);
}
}
- for (SCM s = n ; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = n ; gh_pair_p (s); s = ly_cdr (s))
if (gh_scm2int (gh_cdar (s)))
- accs = gh_cons (gh_car (s), accs);
+ accs = gh_cons (ly_car (s), accs);
old_accs_ = get_property ("keySignature");
daddy_trans_l_->set_property ("keySignature", accs);
alteration_pos (SCM what, int alter, int c0p)
{
if (gh_pair_p (what))
- return gh_scm2int (gh_car (what)) * 7 + gh_scm2int (gh_cdr (what)) + c0p;
+ return gh_scm2int (ly_car (what)) * 7 + gh_scm2int (ly_cdr (what)) + c0p;
int p = gh_scm2int (what);
*/
int c0p = gh_scm2int (me->get_grob_property ("c0-position"));
- for (SCM s = newas; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = newas; gh_pair_p (s); s = ly_cdr (s))
{
SCM what = gh_caar (s);
int alter = gh_scm2int (gh_cdar (s));
natural=Font_interface::get_default_font (me)->
find_by_name (String ("accidentals-") + style + String ("0"));
- for (; gh_pair_p (old); old = gh_cdr (old))
+ for (; gh_pair_p (old); old = ly_cdr (old))
{
SCM found = scm_assoc (gh_caar (old), newas);
if (found == SCM_BOOL_F
- || gh_cdr (found) != gh_cdar (old))
+ || ly_cdr (found) != gh_cdar (old))
{
SCM what = gh_caar (old);
int alter = 0;
if (gh_pair_p (pitch))
{
- yylval.scm = gh_cdr (pitch);
+ yylval.scm = ly_cdr (pitch);
return NOTENAME_PITCH;
}
}
if ((YYSTATE == notes) || (YYSTATE == chords)) {
SCM pitch = scm_hashq_get_handle (pitchname_tab_, sym);
if (gh_pair_p (pitch)) {
- yylval.scm = gh_cdr (pitch);
+ yylval.scm = ly_cdr (pitch);
return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
} else if ((pitch = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
{
- yylval.scm = gh_cdr (pitch);
+ yylval.scm = ly_cdr (pitch);
return CHORDMODIFIER_PITCH;
}
}
SCM
ly_last (SCM list)
{
- return gh_car (scm_last_pair (list));
+ return ly_car (scm_last_pair (list));
}
SCM
SCM
ly_quote_scm (SCM s)
{
- return gh_list (ly_symbol2scm ("quote"), s, SCM_UNDEFINED);
+ return scm_listify (ly_symbol2scm ("quote"), s, SCM_UNDEFINED);
}
void
read_lily_scm_file (String fn)
{
- gh_eval_str ((char *) gulp_file_to_string (fn).ch_C ());
+ scm_c_eval_string ((char *) gulp_file_to_string (fn).ch_C ());
}
extern "C" {
index_cell (SCM s, Direction d)
{
assert (d);
- return (d == LEFT) ? gh_car (s) : gh_cdr (s);
+ return (d == LEFT) ? ly_car (s) : ly_cdr (s);
}
SCM
bool
ly_number_pair_p (SCM p)
{
- return gh_pair_p (p) && gh_number_p (gh_car (p)) && gh_number_p (gh_cdr (p));
+ return gh_pair_p (p) && gh_number_p (ly_car (p)) && gh_number_p (ly_cdr (p));
}
bool
Interval
ly_scm2interval (SCM p)
{
- return Interval (gh_scm2double (gh_car (p)),
- gh_scm2double (gh_cdr (p)));
+ return Interval (gh_scm2double (ly_car (p)),
+ gh_scm2double (ly_cdr (p)));
}
SCM
{
SCM newcons = gh_cons (elt, SCM_EOL);
- gh_set_cdr_x (gh_car (l), newcons);
+ gh_set_cdr_x (ly_car (l), newcons);
gh_set_car_x (l, newcons);
}
Offset
ly_scm2offset (SCM s)
{
- return Offset (gh_scm2double (gh_car (s)),
- gh_scm2double (gh_cdr (s)));
+ return Offset (gh_scm2double (ly_car (s)),
+ gh_scm2double (ly_cdr (s)));
}
SCM
ly_version ()
{
char const* vs = "\' (" MAJOR_VERSION " " MINOR_VERSION " " PATCH_LEVEL " " MY_PATCH_LEVEL ")" ;
-
- return gh_eval_str ((char*)vs);
+ return scm_c_eval_string ((char*)vs);
}
static void
{
if (gh_pair_p (l))
{
- return gh_cons (ly_deep_copy (gh_car (l)), ly_deep_copy (gh_cdr (l)));
+ return gh_cons (ly_deep_copy (ly_car (l)), ly_deep_copy (ly_cdr (l)));
}
else
return l;
{
if (gh_pair_p (achain))
{
- SCM handle = scm_assoc (key, gh_car (achain));
+ SCM handle = scm_assoc (key, ly_car (achain));
if (gh_pair_p (handle))
return handle;
else
- return ly_assoc_chain (key, gh_cdr (achain));
+ return ly_assoc_chain (key, ly_cdr (achain));
}
else
return SCM_BOOL_F;
void
fixup_refpoints (SCM s)
{
- for (; gh_pair_p (s); s = gh_cdr (s))
+ for (; gh_pair_p (s); s = ly_cdr (s))
{
- Grob::fixup_refpoint (gh_car (s));
+ Grob::fixup_refpoint (ly_car (s));
}
}
Line_of_score::output_lines ()
{
for (SCM s = get_grob_property ("all-elements");
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- unsmob_grob (gh_car (s))->do_break_processing ();
+ unsmob_grob (ly_car (s))->do_break_processing ();
}
/*
fixups must be done in broken line_of_scores, because new elements
{
Grob *se = broken_into_l_arr_[i];
SCM all = se->get_grob_property ("all-elements");
- for (SCM s = all; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = all; gh_pair_p (s); s = ly_cdr (s))
{
- fixup_refpoint (gh_car (s));
+ fixup_refpoint (ly_car (s));
}
count += scm_ilength (all);
}
for (SCM s = get_grob_property ("all-elements");
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- unsmob_grob (gh_car (s))->handle_broken_dependencies ();
+ unsmob_grob (ly_car (s))->handle_broken_dependencies ();
}
handle_broken_dependencies ();
if (i < broken_into_l_arr_.size () - 1)
{
- SCM lastcol = gh_car (line_l->get_grob_property ("columns"));
+ SCM lastcol = ly_car (line_l->get_grob_property ("columns"));
Grob* e = unsmob_grob (lastcol);
SCM inter = e->get_grob_property ("between-system-string");
if (gh_string_p (inter))
if (!left)
{
- left = dynamic_cast<Item*> (unsmob_grob (gh_car (between)));
+ left = dynamic_cast<Item*> (unsmob_grob (ly_car (between)));
left = left->column_l ();
}
divide_over ++;
- loose = dynamic_cast<Item*> (unsmob_grob (gh_cdr (between)));
+ loose = dynamic_cast<Item*> (unsmob_grob (ly_cdr (between)));
loose = loose->column_l ();
}
thiscol->translate_axis (lx + j*(rx - lx)/divide_over, X_AXIS);
j ++;
- loose = dynamic_cast<Item*> (unsmob_grob (gh_cdr (between)));
+ loose = dynamic_cast<Item*> (unsmob_grob (ly_cdr (between)));
}
}
if (!gh_pair_p (expr))
return;
- SCM head =gh_car (expr);
+ SCM head =ly_car (expr);
if (unsmob_input (head))
{
Input * ip = unsmob_input (head);
- pscore_l_->outputter_l_->output_scheme (gh_list (define_origin_sym,
+ pscore_l_->outputter_l_->output_scheme (scm_listify (define_origin_sym,
ly_str02scm (ip->file_str ().ch_C ()),
gh_int2scm (ip->line_number ()),
gh_int2scm (ip->column_number ()),
}
else if (head == no_origin_sym)
{
- pscore_l_->outputter_l_->output_scheme (gh_list (no_origin_sym, SCM_UNDEFINED));
+ pscore_l_->outputter_l_->output_scheme (scm_listify (no_origin_sym, SCM_UNDEFINED));
expr = gh_cadr (expr);
}
else if (head == offset_sym)
else
{
pscore_l_->outputter_l_->
- output_scheme (gh_list (placebox_sym,
+ output_scheme (scm_listify (placebox_sym,
gh_double2scm (o[X_AXIS]),
gh_double2scm (o[Y_AXIS]),
expr,
{
Grob *me = this;
SCM cs = me->get_grob_property ("columns");
- Grob * prev = gh_pair_p (cs) ? unsmob_grob (gh_car (cs)) : 0;
+ Grob * prev = gh_pair_p (cs) ? unsmob_grob (ly_car (cs)) : 0;
p->rank_i_ = prev ? Paper_column::rank_i (prev) + 1 : 0;
void
Line_of_score::pre_processing ()
{
- for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
- unsmob_grob (gh_car (s))->discretionary_processing ();
+ for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = ly_cdr (s))
+ unsmob_grob (ly_car (s))->discretionary_processing ();
if (verbose_global_b)
progress_indication (_f ("Element count %d ", element_count ()));
- for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
- unsmob_grob (gh_car (s))->handle_prebroken_dependencies ();
+ for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = ly_cdr (s))
+ unsmob_grob (ly_car (s))->handle_prebroken_dependencies ();
fixup_refpoints (get_grob_property ("all-elements"));
- for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob* sc = unsmob_grob (gh_car (s));
+ Grob* sc = unsmob_grob (ly_car (s));
sc->calculate_dependencies (PRECALCED, PRECALCING, ly_symbol2scm ("before-line-breaking-callback"));
}
progress_indication ("\n" + _ ("Calculating column positions...") + " ");
- for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * e = unsmob_grob (gh_car (s));
+ Grob * e = unsmob_grob (ly_car (s));
SCM proc = e->get_grob_property ("spacing-procedure");
if (gh_procedure_p (proc))
gh_call1 (proc, e->self_scm ());
Line_of_score::post_processing (bool last_line)
{
for (SCM s = get_grob_property ("all-elements");
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- Grob* sc = unsmob_grob (gh_car (s));
+ Grob* sc = unsmob_grob (ly_car (s));
sc->calculate_dependencies (POSTCALCED, POSTCALCING,
ly_symbol2scm ("after-line-breaking-callback"));
}
generate all molecules to trigger all font loads.
(ugh. This is not very memory efficient.) */
- for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s); s = ly_cdr (s))
{
- unsmob_grob (gh_car (s))->get_molecule ();
+ unsmob_grob (ly_car (s))->get_molecule ();
}
/*
font defs;
*/
SCM font_names = ly_quote_scm (paper_l ()->font_descriptions ());
- output_scheme (gh_list (ly_symbol2scm ("define-fonts"),
+ output_scheme (scm_listify (ly_symbol2scm ("define-fonts"),
font_names,
SCM_UNDEFINED));
/*
line preamble.
*/
- output_scheme (gh_list (ly_symbol2scm ("start-line"),
+ output_scheme (scm_listify (ly_symbol2scm ("start-line"),
gh_double2scm (height),
SCM_UNDEFINED));
The default layer is 1. */
for (int i = 0; i < 3; i++)
for (SCM s = get_grob_property ("all-elements"); gh_pair_p (s);
- s = gh_cdr (s))
+ s = ly_cdr (s))
{
- Grob *sc = unsmob_grob (gh_car (s));
+ Grob *sc = unsmob_grob (ly_car (s));
Molecule *m = sc->get_molecule ();
if (!m)
continue;
SCM e = sc->get_grob_property ("extra-offset");
if (gh_pair_p (e))
{
- o[X_AXIS] += gh_scm2double (gh_car (e));
- o[Y_AXIS] += gh_scm2double (gh_cdr (e));
+ o[X_AXIS] += gh_scm2double (ly_car (e));
+ o[Y_AXIS] += gh_scm2double (ly_cdr (e));
}
output_molecule (m->get_expr (), o);
if (last_line)
{
- output_scheme (gh_list (ly_symbol2scm ("stop-last-line"), SCM_UNDEFINED));
+ output_scheme (scm_listify (ly_symbol2scm ("stop-last-line"), SCM_UNDEFINED));
}
else
{
- output_scheme (gh_list (ly_symbol2scm ("stop-line"), SCM_UNDEFINED));
+ output_scheme (scm_listify (ly_symbol2scm ("stop-line"), SCM_UNDEFINED));
}
}
r = r->column_l ();
SCM s = get_grob_property ("columns");
- while (gh_pair_p (s) && gh_car (s) != r->self_scm ())
- s = gh_cdr (s);
+ while (gh_pair_p (s) && ly_car (s) != r->self_scm ())
+ s = ly_cdr (s);
if (gh_pair_p (s))
- s = gh_cdr (s);
+ s = ly_cdr (s);
- while (gh_pair_p (s) && gh_car (s) != l->self_scm ())
+ while (gh_pair_p (s) && ly_car (s) != l->self_scm ())
{
- Paper_column*c = dynamic_cast<Paper_column*> (unsmob_grob (gh_car (s)));
+ Paper_column*c = dynamic_cast<Paper_column*> (unsmob_grob (ly_car (s)));
if (Item::breakable_b (c) && !c->line_l_)
ret.push (c);
- s = gh_cdr (s);
+ s = ly_cdr (s);
}
ret.reverse ();
Real on = length - thick;
Real off = period - on;
- SCM list = gh_list (ly_symbol2scm ("dashed-line"),
+ SCM list = scm_listify (ly_symbol2scm ("dashed-line"),
gh_double2scm (thick),
gh_double2scm (on),
gh_double2scm (off),
&& type == ly_symbol2scm ("trill"))
{
SCM alist_chain = Font_interface::font_alist_chain (me);
- SCM style_chain = gh_list (gh_cons (ly_symbol2scm ("font-family"),
+ SCM style_chain = scm_listify (gh_cons (ly_symbol2scm ("font-family"),
ly_symbol2scm ("music")),
SCM_UNDEFINED);
Font_metric *fm = Font_interface::get_font (me,
- gh_list (style_chain,
+ scm_listify (style_chain,
alist_chain,
SCM_UNDEFINED));
Molecule m = fm->find_by_name ("scripts-trill-element");
SCM prev = scm_assoc (gh_cons (gh_int2scm (o), gh_int2scm (n)), localsig);
if (prev == SCM_BOOL_F)
prev = scm_assoc (gh_int2scm (n), localsig);
- SCM prev_acc = (prev == SCM_BOOL_F) ? gh_int2scm (0) : gh_cdr (prev);
+ SCM prev_acc = (prev == SCM_BOOL_F) ? gh_int2scm (0) : ly_cdr (prev);
bool different = !gh_equal_p (prev_acc , gh_int2scm (a));
int p = gh_number_p (prev_acc) ? gh_scm2int (prev_acc) : 0;
static SCM
pitch_less (SCM p1, SCM p2)
{
- return Pitch::less_p (gh_car (p1), gh_car (p2));
+ return Pitch::less_p (ly_car (p1), ly_car (p2));
}
static SCM pitch_less_proc;
SCM accs = me->get_grob_property ("accidentals");
for (SCM s = accs;
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
SCM opts = gh_cdar (s);
if (!sp->original_l_)
{
/* there should be a better way to delete part of me */
- scm_set_car_x (s, gh_list (gh_caar (s),
+ scm_set_car_x (s, scm_listify (gh_caar (s),
ly_symbol2scm ("deleted"),
SCM_UNDEFINED));
me->set_grob_property ("molecule", SCM_EOL);
SCM accs = me->get_grob_property ("accidentals");
for (SCM s = accs;
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
Pitch p (*unsmob_pitch (gh_caar (s)));
SCM opts = gh_cdar (s);
Interval (min_y, max_y));
- SCM at = gh_list (ly_symbol2scm ("beam"),
+ SCM at = scm_listify (ly_symbol2scm ("beam"),
gh_double2scm (width),
gh_double2scm (slope),
gh_double2scm (thick),
l = gh_cons (ly_offset2scm (b.control_[i]), l);
}
- SCM at = (gh_list (ly_symbol2scm ("dashed-slur"),
+ SCM at = (scm_listify (ly_symbol2scm ("dashed-slur"),
gh_double2scm (thick),
gh_double2scm (dash),
ly_quote_scm (l),
Molecule
Lookup::filledbox (Box b)
{
- SCM at = (gh_list (ly_symbol2scm ("filledbox"),
+ SCM at = (scm_listify (ly_symbol2scm ("filledbox"),
gh_double2scm (-b[X_AXIS][LEFT]),
gh_double2scm (b[X_AXIS][RIGHT]),
gh_double2scm (-b[Y_AXIS][DOWN]),
}
- SCM at = (gh_list (ly_symbol2scm ("bezier-sandwich"),
+ SCM at = (scm_listify (ly_symbol2scm ("bezier-sandwich"),
ly_quote_scm (list),
gh_double2scm (linethick),
SCM_UNDEFINED));
Lookup::accordion (SCM s, Real staff_space, Font_metric *fm)
{
Molecule m;
- String sym = ly_scm2string (gh_car (s));
- String reg = ly_scm2string (gh_car (gh_cdr (s)));
+ String sym = ly_scm2string (ly_car (s));
+ String reg = ly_scm2string (ly_car (ly_cdr (s)));
if (sym == "Discant")
{
SCM wid = gh_double2scm (w);
SCM sl = gh_double2scm (s);
SCM thick = gh_double2scm (t);
- SCM slashnodot = gh_list (ly_symbol2scm ("repeat-slash"),
+ SCM slashnodot = scm_listify (ly_symbol2scm ("repeat-slash"),
wid, sl, thick, SCM_UNDEFINED);
Box b (Interval (0, w + sqrt (sqr(t/s) + sqr (t))),
// (key . ((alist_entry . old_entry) . previous_entry))
if (to_boolean (gh_cdadr (s))) { // it's an old entry ... make it a new one
SCM val = gh_cons (gh_cons (gh_caadr (s), SCM_BOOL_F), gh_cddr (s));
- voice_alist_ = scm_assoc_set_x (voice_alist_, gh_car (s), val);
+ voice_alist_ = scm_assoc_set_x (voice_alist_, ly_car (s), val);
return unsmob_voice_entry (gh_caar (val));
}
else { // the entry is current ... return it.
SCM sp = get_property ("phrasingPunctuation");
punc = gh_string_p (sp) ? ly_scm2string (sp) : ".,;:?!\"";
- for (SCM v=voice_alist_; gh_pair_p (v); v = gh_cdr (v)) {
+ for (SCM v=voice_alist_; gh_pair_p (v); v = ly_cdr (v)) {
SCM v_entry = gh_cdar (v);
// ((current . oldflag) . previous)
if (!to_boolean (gh_cdar (v_entry))) { // not an old entry left over from a prior note ...
if (entry->get_melisma ()) {
if (entry->lyric_count ())
warning (_ ("Huh? Melismatic note found to have associated lyrics."));
- SCM previous_scm = gh_cdr (v_entry);
+ SCM previous_scm = ly_cdr (v_entry);
if (previous_scm != SCM_EOL) {
Syllable_group *previous = unsmob_voice_entry (previous_scm);
if (previous->lyric_count ())
void
Lyric_phrasing_engraver::stop_translation_timestep ()
{
- for (SCM v=voice_alist_; gh_pair_p (v); v = gh_cdr (v)) {
+ for (SCM v=voice_alist_; gh_pair_p (v); v = ly_cdr (v)) {
SCM entry_scm = gh_cdar (v);
// ((alist_entry . entry_is_old) . previous_entry)
Syllable_group * entry = unsmob_voice_entry (gh_caar (entry_scm));
// set previous_entry, set entry_is_old, and resave it to alist_
// but only change if this current was not old.
if (! to_boolean (gh_cdar (entry_scm))) {
- Syllable_group * previous_entry = unsmob_voice_entry (gh_cdr (entry_scm));
+ Syllable_group * previous_entry = unsmob_voice_entry (ly_cdr (entry_scm));
previous_entry->copy (entry);
- entry_scm = gh_cons (gh_cons (gh_caar (entry_scm), SCM_BOOL_T), gh_cdr (entry_scm));
+ entry_scm = gh_cons (gh_cons (gh_caar (entry_scm), SCM_BOOL_T), ly_cdr (entry_scm));
voice_alist_ = scm_assoc_set_x (voice_alist_, gh_caar (v), entry_scm);
}
entry->next_lyric ();
}
void
-main_prog (int, char**)
+main_prog (void * closure, int, char**)
{
/*
need to do this first. Engravers use lily.scm contents.
all_fonts_global_p = new All_font_metrics (global_path.str ());
init_scheme_code_string += ")";
- gh_eval_str ((char *)init_scheme_code_string.ch_C());
+ scm_c_eval_string ((char *)init_scheme_code_string.ch_C());
int p=0;
const char *arg = oparser_p_static->get_next_arg ();
identify (&cerr);
#ifdef WINNT
- gh_enter (argc, argv, main_prog);
+ scm_boot_guile (argc, argv, main_prog, 0);
#else
- gh_enter (argc, argv, (void (*) (int, char**))main_prog);
+ scm_boot_guile (argc, argv, (void (*) (void*, int, char**))main_prog, 0);
#endif
return 0; // unreachable
incr (a);
}
- expr_ = gh_list (ly_symbol2scm ("translate-molecule"),
+ expr_ = scm_listify (ly_symbol2scm ("translate-molecule"),
ly_offset2scm (o),
expr_, SCM_UNDEFINED);
if (!empty_b ())
void
Molecule::add_molecule (Molecule const &m)
{
- expr_ = gh_list (ly_symbol2scm ("combine-molecule"),
+ expr_ = scm_listify (ly_symbol2scm ("combine-molecule"),
m.expr_,
expr_, SCM_UNDEFINED);
dim_.unite (m.dim_);
if (f == SCM_EOL)
return f;
else
- return gh_list (ly_symbol2scm ("fontify"),
+ return scm_listify (ly_symbol2scm ("fontify"),
ly_quote_scm (met->description_), f, SCM_UNDEFINED);
}
int
Molecule::print_smob (SCM s, SCM port, scm_print_state *)
{
- Molecule *r = (Molecule *) gh_cdr (s);
+ Molecule *r = (Molecule *) ly_cdr (s);
scm_puts ("#<Molecule ", port);
/* String str (r->str ());
SCM
Molecule::mark_smob (SCM s)
{
- Molecule *r = (Molecule *) gh_cdr (s);
+ Molecule *r = (Molecule *) ly_cdr (s);
return r->expr_;
}
int
Moment::print_smob (SCM s, SCM port, scm_print_state *)
{
- Moment *r = (Moment *) gh_cdr (s);
+ Moment *r = (Moment *) ly_cdr (s);
scm_puts ("#<Mom ", port);
String str (r->str ());
{
SCM s = l;
k--;
- for (; gh_pair_p (s) && k--; s = gh_cdr (s))
+ for (; gh_pair_p (s) && k--; s = ly_cdr (s))
;
if (gh_pair_p (s))
void
Music_sequence::transpose (Pitch rq)
{
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
- unsmob_music (gh_car (s))->transpose (rq);
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
+ unsmob_music (ly_car (s))->transpose (rq);
}
Moment cumulative;
Moment last_len ;
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- Moment l = unsmob_music (gh_car (s))->length_mom ();
+ Moment l = unsmob_music (ly_car (s))->length_mom ();
if (last_len.grace_part_ && l.main_part_)
{
last_len.grace_part_ = Rational (0);
Music_sequence::maximum_length () const
{
Moment dur = 0;
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- Music * m = unsmob_music (gh_car (s));
+ Music * m = unsmob_music (ly_car (s));
Moment l = m->length_mom ();
dur = dur >? l;
}
int count=0;
Pitch last = p;
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- last = unsmob_music (gh_car (s))->to_relative_octave (last);
+ last = unsmob_music (ly_car (s))->to_relative_octave (last);
if (!count ++)
retval = last;
}
void
Music_sequence::compress (Moment m)
{
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
- unsmob_music (gh_car (s))->compress (m);
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
+ unsmob_music (ly_car (s))->compress (m);
}
ADD_MUSIC (Music_sequence);
{
Moment m;
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- m = m <? unsmob_music (gh_car (s))->start_mom ();
+ m = m <? unsmob_music (ly_car (s))->start_mom ();
}
return m;
}
{
Moment m;
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- Music * mus = unsmob_music (gh_car (s));
+ Music * mus = unsmob_music (ly_car (s));
Moment l = mus->length_mom ();
Moment s = mus->start_mom ();
if (l.to_bool () || s.to_bool ())
}
else if (gh_pair_p (m))
{
- return gh_cons (ly_deep_mus_copy (gh_car (m)), ly_deep_mus_copy (gh_cdr (m)));
+ return gh_cons (ly_deep_mus_copy (ly_car (m)), ly_deep_mus_copy (ly_cdr (m)));
}
else
return m;
void
print_alist (SCM a, SCM port)
{
- for (SCM s = a; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = a; gh_pair_p (s); s = ly_cdr (s))
{
scm_display (gh_caar (s), port);
scm_puts (" = ", port);
{
SCM s = scm_sloppy_assq (sym, mutable_property_alist_);
if (s != SCM_BOOL_F)
- return gh_cdr (s);
+ return ly_cdr (s);
s = scm_sloppy_assq (sym, immutable_property_alist_);
- return (s == SCM_BOOL_F) ? SCM_EOL : gh_cdr (s);
+ return (s == SCM_BOOL_F) ? SCM_EOL : ly_cdr (s);
}
/*
SCM al = p->translator_p_dict_p_->to_alist ();
SCM l = SCM_EOL;
- for (SCM s = al ; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = al ; gh_pair_p (s); s = ly_cdr (s))
{
Translator_def * td = unsmob_translator_def (gh_cdar (s));
l = gh_cons (gh_cons (gh_caar (s), td->to_alist ()), l);
access to the note head.
*/
- for (SCM s = seq; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = seq; gh_pair_p (s); s = ly_cdr (s))
{
Grob *lm = unsmob_grob (gh_caar (s));
Grob *rm = unsmob_grob (gh_cdar (s));
Real break_dist = 0.0;
SCM espace = l->get_grob_property ("extra-space");
if (gh_pair_p (espace))
- break_dist += gh_scm2double (gh_cdr (espace));
+ break_dist += gh_scm2double (ly_cdr (espace));
if (!break_dist)
break_dist = 1.0;
// todo: naming of "distance"
espace = l->get_grob_property ("stretch-distance");
if (gh_pair_p (espace))
- break_stretch += gh_scm2double (gh_cdr (espace));
+ break_stretch += gh_scm2double (ly_cdr (espace));
if (!break_stretch)
break_stretch = 1.0;
if (scm_ilength (dl) != 1 || scm_ilength (dr) != 1)
return 0.;
- dl = gh_car (dl);
- dr = gh_car (dr);
+ dl = ly_car (dl);
+ dr = ly_car (dr);
assert (gh_number_p (dl) && gh_number_p (dr));
int d1 = gh_scm2int (dl);
iv.set_empty ();
SCM h = me->get_grob_property ("note-heads");
- for (; gh_pair_p (h); h = gh_cdr (h))
+ for (; gh_pair_p (h); h = ly_cdr (h))
{
- Grob *se = unsmob_grob (gh_car (h));
+ Grob *se = unsmob_grob (ly_car (h));
int j = int (Staff_symbol_referencer::position_f (se));
iv.unite (Slice (j,j));
UGH: use grob-property.
*/
Molecule out = Font_interface::get_default_font (me)->find_by_name (String ("noteheads-") +
- ly_scm2string (scm_primitive_eval (gh_list (ly_symbol2scm ("find-notehead-symbol"),
+ ly_scm2string (scm_primitive_eval (scm_listify (ly_symbol2scm ("find-notehead-symbol"),
me->get_grob_property ("duration-log"),
ly_quote_scm (style),
SCM_UNDEFINED))));
int l = gh_scm2int (me->get_grob_property ("duration-log"));
int b = (l >= 2);
- SCM at = gh_list (ly_symbol2scm ("ez-ball"),
+ SCM at = scm_listify (ly_symbol2scm ("ez-ball"),
me->get_grob_property ("note-character"),
gh_int2scm (b),
gh_int2scm (1-b),
return 0.0;
SCM st = me->get_grob_property ("style");
- SCM result = gh_apply (v, gh_list (st, SCM_UNDEFINED));
+ SCM result = gh_apply (v, scm_listify (st, SCM_UNDEFINED));
if (!gh_pair_p (result))
return 0.0;
- result = (a == X_AXIS) ? gh_car (result) : gh_cdr (result);
+ result = (a == X_AXIS) ? ly_car (result) : ly_cdr (result);
return gh_number_p (result) ? gh_scm2double (result) : 0.0;
}
Note_heads_engraver::start_translation_timestep ()
{
- /* TODO:make this settable?
+ /*
+ TODO: make this settable?
+
+ TODO: what if someone wants a line break in a grace note section??
*/
- if (note_end_mom_ > now_mom ())
+ // if (note_end_mom_ > now_mom ())
+ if (note_end_mom_.main_part_ > now_mom ().main_part_)
{
Score_engraver * e = 0;
Translator * t = daddy_grav_l ();
should typecheck pred.
*/
SCM result=gh_apply (pred,
- gh_list (inf.elem_l_->self_scm (), SCM_UNDEFINED));
+ scm_listify (inf.elem_l_->self_scm (), SCM_UNDEFINED));
if (to_boolean (result))
{
SCM sym = o->get_mus_property ("grob-property");
SCM met = scm_assoc (key, scaled_fonts_);
if (gh_pair_p (met))
- return unsmob_metrics (gh_cdr (met));
+ return unsmob_metrics (ly_cdr (met));
SCM ssc;
if (scope_p_->try_retrieve (ly_symbol2scm ("outputscale"), &ssc))
SCM l = SCM_EOL;
- for (SCM s = scaled_fonts_; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = scaled_fonts_; gh_pair_p (s); s = ly_cdr (s))
{
SCM desc = gh_caar (s);
SCM mdesc = unsmob_metrics (gh_cdar (s))->description_;
gh_define ("security-paranoia", SCM_BOOL_T);
}
- SCM exp = gh_list (ly_symbol2scm ((output_format_global + "-scm").ch_C ()),
+ SCM exp = scm_listify (ly_symbol2scm ((output_format_global + "-scm").ch_C ()),
ly_quote_scm (ly_symbol2scm ("all-definitions")),
SCM_UNDEFINED);
exp = scm_primitive_eval (exp);
generate = generate + to_str (' ' * (120 - generate.length_i ())>? 0) ;
SCM args_scm =
- gh_list (ly_str02scm (creator.ch_l ()),
+ scm_listify (ly_str02scm (creator.ch_l ()),
ly_str02scm (generate.ch_l ()), SCM_UNDEFINED);
void
Paper_outputter::output_comment (String str)
{
- output_scheme (gh_list (ly_symbol2scm ("comment"),
+ output_scheme (scm_listify (ly_symbol2scm ("comment"),
ly_str02scm ((char*)str.ch_C ()),
SCM_UNDEFINED)
);
Paper_outputter::output_scope (Scope *scope, String prefix)
{
SCM al = scope->to_alist ();
- for (SCM s = al ; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = al ; gh_pair_p (s); s = ly_cdr (s))
{
SCM k = gh_caar (s);
SCM v = gh_cdar (s);
Paper_outputter::output_Real_def (String k, Real v)
{
- SCM scm = gh_list (ly_symbol2scm ("lily-def"),
+ SCM scm = scm_listify (ly_symbol2scm ("lily-def"),
ly_str02scm (k.ch_l ()),
ly_str02scm (to_str (v).ch_l ()),
SCM_UNDEFINED);
Paper_outputter::output_String_def (String k, String v)
{
- SCM scm = gh_list (ly_symbol2scm ("lily-def"),
+ SCM scm = scm_listify (ly_symbol2scm ("lily-def"),
ly_str02scm (k.ch_l ()),
ly_str02scm (v.ch_l ()),
SCM_UNDEFINED);
void
Paper_outputter::output_int_def (String k, int v)
{
- SCM scm = gh_list (ly_symbol2scm ("lily-def"),
+ SCM scm = scm_listify (ly_symbol2scm ("lily-def"),
ly_str02scm (k.ch_l ()),
ly_str02scm (to_str (v).ch_l ()),
SCM_UNDEFINED);
/* Only write header field to file if it exists */
if (gh_pair_p (val))
{
- s = ly_scm2string (gh_cdr (val));
+ s = ly_scm2string (ly_cdr (val));
/* Always write header field file, even if string is empty ... */
write_header_field_to_file (basename_, key, s);
}
if (paper_l_->scope_p_)
outputter_l_->output_scope (paper_l_->scope_p_, "lilypondpaper");
- SCM scm = gh_list (ly_symbol2scm ("header-end"), SCM_UNDEFINED);
+ SCM scm = scm_listify (ly_symbol2scm ("header-end"), SCM_UNDEFINED);
outputter_l_->output_scheme (scm);
line_l_->output_lines ();
- scm = gh_list (ly_symbol2scm ("end-output"), SCM_UNDEFINED);
+ scm = scm_listify (ly_symbol2scm ("end-output"), SCM_UNDEFINED);
outputter_l_->output_scheme (scm);
progress_indication ("\n");
void
set_music_properties (Music *p, SCM a)
{
- for (SCM k = a; gh_pair_p (k); k = gh_cdr (k))
+ for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
{
p->set_mus_property (gh_caar (k), gh_cdar (k));
}
int i = scm_ilength ($1);
SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
- for (SCM s = $1; gh_pair_p (s); s = gh_cdr (s)) {
+ for (SCM s = $1; gh_pair_p (s); s = ly_cdr (s)) {
SCM pt = gh_cdar (s);
if (!unsmob_pitch (pt))
THIS->parser_error ("Need pitch object.");
td->type_aliases_ = gh_cons ($3, td->type_aliases_);
}
| translator_spec_body ELEMENTDESCRIPTIONS embedded_scm {
- for (SCM p = $3; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p))
unsmob_translator_def ($$)
->add_property_assign (scm_symbol_to_string (gh_caar (p)), gh_cdar (p));
SCM s = $$;
SCM c = gh_cons ($2->self_scm (), SCM_EOL);
scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
- if (gh_pair_p (gh_cdr (s)))
- gh_set_cdr_x (gh_cdr (s), c); /* append */
+ if (gh_pair_p (ly_cdr (s)))
+ gh_set_cdr_x (ly_cdr (s), c); /* append */
else
gh_set_car_x (s, c); /* set first cons */
gh_set_cdr_x (s, c) ; /* remember last cell */
Music_sequence: '{' Music_list '}' {
$$ = new Music_sequence (SCM_EOL);
- $$->set_mus_property ("elements", gh_car ($2));
+ $$->set_mus_property ("elements", ly_car ($2));
}
;
Sequential_music:
SEQUENTIAL '{' Music_list '}' {
$$ = new Sequential_music (SCM_EOL);
- $$->set_mus_property ("elements", gh_car ($3));
+ $$->set_mus_property ("elements", ly_car ($3));
}
| '{' Music_list '}' {
$$ = new Sequential_music (SCM_EOL);
- $$->set_mus_property ("elements", gh_car ($2));
+ $$->set_mus_property ("elements", ly_car ($2));
}
;
Simultaneous_music:
SIMULTANEOUS '{' Music_list '}'{
$$ = new Simultaneous_music (SCM_EOL);
- $$->set_mus_property ("elements", gh_car ($3));
+ $$->set_mus_property ("elements", ly_car ($3));
}
| '<' Music_list '>' {
$$ = new Simultaneous_music (SCM_EOL);
- $$->set_mus_property ("elements", gh_car ($2));
+ $$->set_mus_property ("elements", ly_car ($2));
}
;
fraction Music
{
- int n = gh_scm2int (gh_car ($3)); int d = gh_scm2int (gh_cdr ($3));
+ int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
Music *mp = $4;
$$ = new Time_scaled_music (SCM_EOL);
$$->set_spot (THIS->pop_spot ());
SCM result = gh_call1 (func, $2);
SCM l = SCM_EOL;
- for (SCM s = result ; gh_pair_p (s); s = gh_cdr (s)) {
+ for (SCM s = result ; gh_pair_p (s); s = ly_cdr (s)) {
Music * p = new Music (SCM_EOL);
- set_music_properties (p, gh_car (s));
+ set_music_properties (p, ly_car (s));
l = gh_cons (p->self_scm (), l);
scm_gc_unprotect_object (p->self_scm ());
}
| TIME_T fraction {
Music * p1 = set_property_music (ly_symbol2scm ( "timeSignatureFraction"), $2);
- int l = gh_scm2int (gh_car ($2));
- int o = gh_scm2int (gh_cdr ($2));
+ int l = gh_scm2int (ly_car ($2));
+ int o = gh_scm2int (ly_cdr ($2));
Moment one_beat = Moment (1)/Moment (o);
Moment len = Moment (l) * one_beat;
Music *p2 = set_property_music (ly_symbol2scm ("measureLength"), len.smobbed_copy ());
Music *p3 = set_property_music (ly_symbol2scm ("beatLength"), one_beat.smobbed_copy ());
- SCM list = gh_list (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
+ SCM list = scm_listify (p1->self_scm (), p2->self_scm (), p3->self_scm(), SCM_UNDEFINED);
Sequential_music *seq = new Sequential_music (SCM_EOL);
seq->set_mus_property ("elements", list);
$$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
}
| multiplied_duration '*' FRACTION {
- Rational m (gh_scm2int (gh_car ($3)), gh_scm2int (gh_cdr ($3)));
+ Rational m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
$$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
}
n->set_mus_property ("force-accidental", SCM_BOOL_T);
Simultaneous_music*v = new Request_chord (SCM_EOL);
- v->set_mus_property ("elements", gh_list (n->self_scm (), SCM_UNDEFINED));
+ v->set_mus_property ("elements", scm_listify (n->self_scm (), SCM_UNDEFINED));
v->set_spot (i);
n->set_spot (i);
Music * m = unsmob_music ($1);
Input i = THIS->pop_spot ();
m->set_spot (i);
- for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = m->get_mus_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
{
- unsmob_music (gh_car (s))->set_mus_property ("duration", $2);
+ unsmob_music (ly_car (s))->set_mus_property ("duration", $2);
}
$$ = m;
}
e = rest_req_p->self_scm ();
}
Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
- velt_p-> set_mus_property ("elements", gh_list (e,SCM_UNDEFINED));
+ velt_p-> set_mus_property ("elements", scm_listify (e,SCM_UNDEFINED));
velt_p->set_spot (i);
$$ = velt_p;
sp2->set_mus_property ("span-type", r);
Request_chord * rqc1 = new Request_chord (SCM_EOL);
- rqc1->set_mus_property ("elements", gh_list (sp1->self_scm (), SCM_UNDEFINED));
+ rqc1->set_mus_property ("elements", scm_listify (sp1->self_scm (), SCM_UNDEFINED));
Request_chord * rqc2 = new Request_chord (SCM_EOL);
- rqc2->set_mus_property ("elements", gh_list (sk->self_scm (), SCM_UNDEFINED));;
+ rqc2->set_mus_property ("elements", scm_listify (sk->self_scm (), SCM_UNDEFINED));;
Request_chord * rqc3 = new Request_chord (SCM_EOL);
- rqc3->set_mus_property ("elements", gh_list (sp2->self_scm (), SCM_UNDEFINED));;
+ rqc3->set_mus_property ("elements", scm_listify (sp2->self_scm (), SCM_UNDEFINED));;
- SCM ms = gh_list (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
+ SCM ms = scm_listify (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
$$ = new Sequential_music (SCM_EOL);
$$->set_mus_property ("elements", ms);
lreq_p->set_mus_property ("duration",$2);
lreq_p->set_spot (i);
Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
- velt_p->set_mus_property ("elements", gh_list (lreq_p->self_scm (), SCM_UNDEFINED));
+ velt_p->set_mus_property ("elements", scm_listify (lreq_p->self_scm (), SCM_UNDEFINED));
$$= velt_p;
}
$$ = gh_cons (unsmob_pitch ($1)->smobbed_copy (), SCM_EOL);
}
| CHORDMODIFIER_PITCH chord_note { /* Ugh. */
- $$ = gh_list (unsmob_pitch ($1)->smobbed_copy (),
+ $$ = scm_listify (unsmob_pitch ($1)->smobbed_copy (),
$2, SCM_UNDEFINED);
}
;
{
if (iter->ok ())
{
- for (SCM i = iter->get_music (m); gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = iter->get_music (m); gh_pair_p (i); i = ly_cdr (i))
{
- Music *m = unsmob_music (gh_car (i));
+ Music *m = unsmob_music (ly_car (i));
if (Melodic_req *r = dynamic_cast<Melodic_req *> (m))
*pitches = gh_cons (r->get_mus_property ("pitch"), *pitches);
if (Rhythmic_req *r = dynamic_cast<Rhythmic_req *> (m))
if (!gh_pair_p (s))
return state;
- Moment change_mom = *unsmob_moment (gh_car (s));
- Moment diff_mom = *unsmob_moment (gh_cdr (s));
+ Moment change_mom = *unsmob_moment (ly_car (s));
+ Moment diff_mom = *unsmob_moment (ly_cdr (s));
Moment now = pending_moment ();
scm_sort_list_x (second_pitches,
scm_primitive_eval (ly_str02scm ("Pitch::less_p")));
- interval = gh_int2scm (unsmob_pitch (gh_car (first_pitches))->steps ()
- - unsmob_pitch (gh_car (scm_last_pair (second_pitches)))->steps ());
+ interval = gh_int2scm (unsmob_pitch (ly_car (first_pitches))->steps ()
+ - unsmob_pitch (ly_car (scm_last_pair (second_pitches)))->steps ());
}
if (first_durations != SCM_EOL)
{
scm_sort_list_x (first_durations,
scm_primitive_eval (ly_str02scm ("Duration::less_p")));
- first_mom += unsmob_duration (gh_car (first_durations))->length_mom ();
+ first_mom += unsmob_duration (ly_car (first_durations))->length_mom ();
}
if (second_durations != SCM_EOL)
{
scm_sort_list_x (second_durations,
scm_primitive_eval (ly_str02scm ("Duration::less_p")));
- second_mom += unsmob_duration (gh_car (second_durations))->length_mom ();
+ second_mom += unsmob_duration (ly_car (second_durations))->length_mom ();
}
if (first_pitches != SCM_EOL && second_pitches == SCM_EOL
SCM s = first_translator->get_property (ly_symbol2scm ("splitInterval"));
int i = gh_scm2int (interval);
if (gh_pair_p (s)
- && gh_number_p (gh_car (s))
- && gh_number_p (gh_cdr (s))
- && i >= gh_scm2int (gh_car (s))
- && i <= gh_scm2int (gh_cdr (s)))
+ && gh_number_p (ly_car (s))
+ && gh_number_p (ly_cdr (s))
+ && i >= gh_scm2int (ly_car (s))
+ && i <= gh_scm2int (ly_cdr (s)))
{
if (! (state & ~ (SPLIT_INTERVAL | UNIRHYTHM | UNISON)))
state |= SPLIT_INTERVAL;
void
Performer_group_performer::create_audio_elements ()
{
- for (SCM p = simple_trans_list_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = simple_trans_list_; gh_pair_p (p); p = ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Performer * eng = dynamic_cast<Performer*> (t);
if (eng)
eng->create_audio_elements ();
{
Audio_element_info info = announce_info_arr_[j];
- for (SCM p = simple_trans_list_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = simple_trans_list_; gh_pair_p (p); p = ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
Performer * eng = dynamic_cast<Performer*> (t);
if (eng && eng!= info.origin_trans_l_)
eng->acknowledge_audio_element (info);
void
Performer_group_performer::do_announces ()
{
- for (SCM p = trans_group_list_; gh_pair_p (p); p =gh_cdr (p))
+ for (SCM p = trans_group_list_; gh_pair_p (p); p =ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
dynamic_cast<Performer_group_performer*> (t)->do_announces ();
}
else if (p->req_l_drul_[START])
{
p->start_req_l_ = p->req_l_drul_[START];
- s = gh_car (strings);
+ s = ly_car (strings);
}
if (gh_string_p (s))
int
Pitch::print_smob (SCM s, SCM port, scm_print_state *)
{
- Pitch *r = (Pitch *) gh_cdr (s);
+ Pitch *r = (Pitch *) ly_cdr (s);
scm_puts ("#<Pitch ", port);
scm_display (ly_str02scm (r->str ().ch_C ()), port);
SCM
Pitch::equal_p (SCM a , SCM b)
{
- Pitch *p = (Pitch *) gh_cdr (a);
- Pitch *q = (Pitch *) gh_cdr (b);
+ Pitch *p = (Pitch *) ly_cdr (a);
+ Pitch *q = (Pitch *) ly_cdr (b);
bool eq = p->notename_i_ == q->notename_i_
&& p->octave_i_ == q->octave_i_
SCM width_scm = gh_double2scm (width);
SCM slope_scm = gh_double2scm (slope);
SCM thickness_scm = gh_double2scm (thickness);
- SCM horizontal_slope = gh_list (ly_symbol2scm ("beam"),
+ SCM horizontal_slope = scm_listify (ly_symbol2scm ("beam"),
width_scm, slope_scm,
thickness_scm, SCM_UNDEFINED);
Box b (Interval (0, width),
prop_dict_ = new Scheme_hash_table;
SCM plist = get_property (ly_symbol2scm ("Generic_property_list"));
- for (; gh_pair_p (plist); plist = gh_cdr (plist))
+ for (; gh_pair_p (plist); plist = ly_cdr (plist))
{
- SCM elt_props = gh_car (plist);
- prop_dict_->set (gh_car (elt_props), gh_cdr (elt_props));
+ SCM elt_props = ly_car (plist);
+ prop_dict_->set (ly_car (elt_props), ly_cdr (elt_props));
}
}
{
SCM ifs = i.elem_l_->get_grob_property ("interfaces");
SCM props;
- for (; gh_pair_p (ifs); ifs = gh_cdr (ifs))
+ for (; gh_pair_p (ifs); ifs = ly_cdr (ifs))
{
- if (prop_dict_->try_retrieve (gh_car (ifs), &props))
+ if (prop_dict_->try_retrieve (ly_car (ifs), &props))
{
apply_properties (props,i.elem_l_, i.origin_trans_l_->daddy_trans_l_);
}
void
Property_engraver::apply_properties (SCM p, Grob *e, Translator_group*origin)
{
- for (; gh_pair_p (p); p = gh_cdr (p))
+ for (; gh_pair_p (p); p = ly_cdr (p))
{
/*
Try each property in order; earlier descriptions take
they're already set.
*/
- SCM entry = gh_car (p);
- SCM prop_sym = gh_car (entry);
+ SCM entry = ly_car (p);
+ SCM prop_sym = ly_car (entry);
SCM type_p = gh_cadr (entry);
SCM elt_prop_sym = gh_caddr (entry);
warning (_f ("`%s' is deprecated. Use\n \\property %s.%s \\override #'%s = #%s",
ly_symbol2string (prop_sym).ch_C (),
origin->type_str_.ch_C (),
- ly_scm2string (gh_cdr (name)).ch_C (),
+ ly_scm2string (ly_cdr (name)).ch_C (),
ly_symbol2string (elt_prop_sym).ch_C (),
ly_scm2string (ly_write2scm (val)).ch_C ()));
}
bool volta_found = false;
while (gh_pair_p (cs))
{
- SCM command = gh_car (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 (gh_pair_p (command) && gh_car (command) == ly_symbol2scm ("volta"))
+ else if (gh_pair_p (command) && ly_car (command) == ly_symbol2scm ("volta"))
volta_found = true;
- cs = gh_cdr (cs);
+ cs = ly_cdr (cs);
}
if (start && end)
Pitch last = p ;
if (alternatives ())
- for (SCM s = alternatives ()->music_list (); gh_pair_p (s); s = gh_cdr (s))
- unsmob_music (gh_car (s))->to_relative_octave (p);
+ for (SCM s = alternatives ()->music_list (); gh_pair_p (s); s = ly_cdr (s))
+ unsmob_music (ly_car (s))->to_relative_octave (p);
return last;
SCM p = alternatives ()->music_list ();
while (gh_pair_p (p) && done < repeat_count ())
{
- m = m + unsmob_music (gh_car (p))->length_mom ();
+ m = m + unsmob_music (ly_car (p))->length_mom ();
done ++;
if (repeat_count () - done < alternatives ()->length_i ())
- p = gh_cdr (p);
+ p = ly_cdr (p);
}
return m;
}
SCM p = alternatives ()->music_list ();
while (gh_pair_p (p))
{
- m = m + unsmob_music (gh_car (p))->length_mom ();
- p = gh_cdr (p);
+ m = m + unsmob_music (ly_car (p))->length_mom ();
+ p = ly_cdr (p);
}
return m;
}
{
Music_sequence * ms = dynamic_cast<Music_sequence*> (music_l ());
- for (SCM m = ms->music_list (); gh_pair_p (m); m = gh_cdr (m))
+ for (SCM m = ms->music_list (); gh_pair_p (m); m = ly_cdr (m))
{
- s = gh_cons (gh_car (m) , s);
+ s = gh_cons (ly_car (m) , s);
}
}
return s;
if (last_processed_mom_ < Moment (0))
{
for (SCM s = dynamic_cast<Music_sequence *> (music_l ())->music_list ();
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- Music *mus = unsmob_music (gh_car (s));
+ Music *mus = unsmob_music (ly_car (s));
bool gotcha = try_music (mus);
if (!gotcha)
Pitch
Request_chord::to_relative_octave (Pitch last)
{
- for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = music_list (); gh_pair_p (s); s = ly_cdr (s))
{
- Music * mus = unsmob_music (gh_car (s));
+ Music * mus = unsmob_music (ly_car (s));
if (Melodic_req *m= dynamic_cast <Melodic_req *> (mus))
{
Pitch pit = *unsmob_pitch (m->get_mus_property ("pitch"));
Link_array<Grob> rests;
Link_array<Grob> notes;
Grob * commony = 0;
- for (SCM s = elts; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = elts; gh_pair_p (s); s = ly_cdr (s))
{
- Grob * e = unsmob_grob (gh_car (s));
+ Grob * e = unsmob_grob (ly_car (s));
if (!e)
continue;
magnification_f_ = magn;
SCM desc = m->description_;
- Real total_mag = magn * gh_scm2double (gh_cdr (desc));
- description_ = gh_cons (gh_car (desc), gh_double2scm (total_mag));
+ Real total_mag = magn * gh_scm2double (ly_cdr (desc));
+ description_ = gh_cons (ly_car (desc), gh_double2scm (total_mag));
orig_l_ = m;
}
/*
TODO: this is not very elegant....
*/
- store_locations_global_b = (gh_eval_str ("point-and-click") != SCM_BOOL_F);
+ store_locations_global_b = (scm_c_eval_string ("point-and-click") != SCM_BOOL_F);
Music * m =unsmob_music (s.music_);
music_ = m?m->clone ()->self_scm () : SCM_EOL;
}
// todo -> use result of articulation-to-scriptdef directly as basic prop list.
Grob *p =new Item (get_property ("Script"));
- art = gh_cdr (art);
- p->set_grob_property ("molecule", gh_car (art));
+ art = ly_cdr (art);
+ p->set_grob_property ("molecule", ly_car (art));
- art = gh_cdr (art);
- bool follow_staff = gh_scm2bool (gh_car (art));
- art = gh_cdr (art);
- SCM relative_stem_dir = gh_car (art);
- art = gh_cdr (art);
+ art = ly_cdr (art);
+ bool follow_staff = gh_scm2bool (ly_car (art));
+ art = ly_cdr (art);
+ SCM relative_stem_dir = ly_car (art);
+ art = ly_cdr (art);
SCM force_dir = l->get_mus_property ("direction");
if (isdir_b (force_dir) && !to_dir (force_dir))
- force_dir = gh_car (art);
+ force_dir = ly_car (art);
- art = gh_cdr (art);
- SCM priority = gh_car (art);
+ art = ly_cdr (art);
+ SCM priority = ly_car (art);
if (isdir_b (force_dir) && to_dir (force_dir))
p->set_grob_property ("direction", force_dir);
SCM s = me->get_grob_property ("molecule");
assert (gh_pair_p (s));
- SCM key = gh_car (s);
+ SCM key = ly_car (s);
if (key == ly_symbol2scm ("feta"))
{
return Font_interface::get_default_font (me)->find_by_name ("scripts-" +
- ly_scm2string (index_cell (gh_cdr (s), d)));
+ ly_scm2string (index_cell (ly_cdr (s), d)));
}
else if (key == ly_symbol2scm ("accordion"))
{
- return Lookup::accordion (gh_cdr (s), 1.0, Font_interface::get_default_font (me));
+ return Lookup::accordion (ly_cdr (s), 1.0, Font_interface::get_default_font (me));
}
else
assert (false);
This is an inner loop, however, in most cases, the interesting L
will just be the first entry of NEXT, making it linear in most of
the cases. */
- for(; gh_pair_p (next); next = gh_cdr (next))
+ for(; gh_pair_p (next); next = ly_cdr (next))
{
- Item *l = dynamic_cast<Item*> (unsmob_grob (gh_car( next)));
+ Item *l = dynamic_cast<Item*> (unsmob_grob (ly_car( next)));
Item *lb = l->find_prebroken_piece (RIGHT);
if (lb)
{
Grob*me = unsmob_grob (smob);
- for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s) && gh_pair_p (gh_cdr (s)); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s) && gh_pair_p (ly_cdr (s)); s = ly_cdr (s))
{
/*
Order of elements is reversed!
*/
- SCM elt = gh_car (s);
+ SCM elt = ly_car (s);
Item *r = dynamic_cast<Item*> (unsmob_grob (elt));
if (!r)
Item *rb
= dynamic_cast<Item*> (r->find_prebroken_piece (LEFT));
- find_rods (r, gh_cdr (s));
+ find_rods (r, ly_cdr (s));
if (rb)
- find_rods (rb, gh_cdr (s));
+ find_rods (rb, ly_cdr (s));
}
find_musical_sequences (me);
/*
We've done our job, so we get lost.
*/
- for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
{
- Item * it =dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
+ Item * it =dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
if (it && it->broken_b ())
{
it->find_prebroken_piece (LEFT) ->suicide ();
Item *last = 0;
Item *llast = 0;
for (SCM s = me->get_grob_property ("elements");
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
- Item *it = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
+ Item *it = dynamic_cast<Item*> (unsmob_grob (ly_car (s)));
if (last)
{
Item *lcol = last->column_l ();
}
Item * left
- = dynamic_cast<Item*> (unsmob_grob (gh_car (between)));
+ = dynamic_cast<Item*> (unsmob_grob (ly_car (between)));
if(Paper_column::rank_i (left->column_l ()) < rank)
gh_set_car_x (between, col->self_scm());
Item * right
- = dynamic_cast<Item*> (unsmob_grob (gh_cdr (between)));
+ = dynamic_cast<Item*> (unsmob_grob (ly_cdr (between)));
if (Paper_column::rank_i (right->column_l ()) > llrank )
gh_set_cdr_x (between, llcol->self_scm ());
}
Paper_column * pc = item->column_l ();
Interval w;
- for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
{
- SCM elt = gh_car (s);
+ SCM elt = ly_car (s);
if (!unsmob_grob (elt))
continue;
if (gh_pair_p (cursor_))
- iter_p_->music_l_ == unsmob_music (gh_car (cursor_))
+ iter_p_->music_l_ == unsmob_music (ly_car (cursor_))
else
iter_p_ == 0;
Grace_fixup *head = 0;
Grace_fixup **tail = &head;
- for (; gh_pair_p (cursor); cursor = gh_cdr (cursor))
+ for (; gh_pair_p (cursor); cursor = ly_cdr (cursor))
{
- Music * mus = unsmob_music (gh_car (cursor));
+ Music * mus = unsmob_music (ly_car (cursor));
Moment s = mus->start_mom ();
Moment l =mus->length_mom () - s;
{
cursor_ = dynamic_cast<Music_sequence const*> (music_l ())->music_list ();
- iter_p_ = gh_pair_p (cursor_) ? get_iterator_p (unsmob_music (gh_car (cursor_))) : 0;
+ iter_p_ = gh_pair_p (cursor_) ? get_iterator_p (unsmob_music (ly_car (cursor_))) : 0;
while (iter_p_ && !iter_p_->ok ())
{
next_element ();
}
delete iter_p_;
- cursor_ = gh_cdr (cursor_);
+ cursor_ = ly_cdr (cursor_);
if (gh_pair_p (cursor_))
- iter_p_ = get_iterator_p (unsmob_music (gh_car (cursor_)));
+ iter_p_ = get_iterator_p (unsmob_music (ly_car (cursor_)));
else
iter_p_ = 0;
}
s = gh_append2 (nm, s);
Moment m = 0;
- for (SCM i = nm; gh_pair_p (i); i = gh_cdr (i))
+ for (SCM i = nm; gh_pair_p (i); i = ly_cdr (i))
{
- Music *mus=unsmob_music (gh_car (i));
+ Music *mus=unsmob_music (ly_car (i));
m = m >? (mus->length_mom () - mus->start_mom ());
}
if (m > Moment (0))
*/
SCM support = me->get_grob_property ("side-support-elements");
// me->remove_grob_property ("side-support-elements");
- for (SCM s = support; s != SCM_EOL; s = gh_cdr (s))
+ for (SCM s = support; s != SCM_EOL; s = ly_cdr (s))
{
- Grob * e = unsmob_grob (gh_car (s));
+ Grob * e = unsmob_grob (ly_car (s));
if (e)
common = common->common_refpoint (e, a);
}
Interval dim;
- for (SCM s = support; s != SCM_EOL; s = gh_cdr (s))
+ for (SCM s = support; s != SCM_EOL; s = ly_cdr (s))
{
- Grob * e = unsmob_grob (gh_car (s));
+ Grob * e = unsmob_grob (ly_car (s));
if (e)
if (use_extents)
dim.unite (e->extent (common, a));
SCM spring_params = SCM_EOL;
for (SCM s = cols[i]->get_grob_property ("ideal-distances");
!gh_pair_p (spring_params) && gh_pair_p (s);
- s = gh_cdr (s))
+ s = ly_cdr (s))
{
Grob *other = unsmob_grob (gh_caar (s));
if (other != cols[i+1])
Spring_description desc;
if (gh_pair_p (spring_params))
{
- desc.ideal_f_ = gh_scm2double (gh_car (spring_params));
- desc.hooke_f_ = gh_scm2double (gh_cdr (spring_params));
+ desc.ideal_f_ = gh_scm2double (ly_car (spring_params));
+ desc.hooke_f_ = gh_scm2double (ly_cdr (spring_params));
}
else
{
for (int i=0; i < cols.size () - 1; i++)
{
for (SCM s = Spaceable_grob::get_minimum_distances (cols[i]);
- gh_pair_p (s); s = gh_cdr (s))
+ gh_pair_p (s); s = ly_cdr (s))
{
Grob * other = unsmob_grob (gh_caar (s));
int oi = cols.find_i (other);
Music_sequence const *sim = dynamic_cast<Music_sequence const*> (music_l ());
SCM i = sim->music_list ();
- for (; gh_pair_p (i); i = gh_cdr (i), j++)
+ for (; gh_pair_p (i); i = ly_cdr (i), j++)
{
- Music *mus = unsmob_music (gh_car (i));
+ Music *mus = unsmob_music (ly_car (i));
Music_iterator * mi = static_get_iterator_p (mus);
/* if separate_contexts_b_ is set, create a new context with the
if (fit_factor () > 1.0)
blow_fit ();
- Real pct_c0 = gh_scm2double (gh_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-c0"), bezier_props)));
- Real pct_c3 = gh_scm2double (gh_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-c3"), bezier_props)));
- Real pct_in_max = gh_scm2double (gh_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-in-max"), bezier_props)));
- Real pct_out_max = gh_scm2double (gh_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-out-max"), bezier_props)));
- Real steps = gh_scm2double (gh_cdr (scm_assoc (ly_symbol2scm ("bezier-area-steps"),bezier_props)));
+ Real pct_c0 = gh_scm2double (ly_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-c0"), bezier_props)));
+ Real pct_c3 = gh_scm2double (ly_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-c3"), bezier_props)));
+ Real pct_in_max = gh_scm2double (ly_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-in-max"), bezier_props)));
+ Real pct_out_max = gh_scm2double (ly_cdr (scm_assoc (ly_symbol2scm ("bezier-pct-out-max"), bezier_props)));
+ Real steps = gh_scm2double (ly_cdr (scm_assoc (ly_symbol2scm ("bezier-area-steps"),bezier_props)));
for (int i=0; i < steps; i++)
{
Real f = default_height / length;
SCM up = me->get_grob_property ("de-uglify-parameters");
- Real c1 = gh_scm2double (gh_car (up));
+ Real c1 = gh_scm2double (ly_car (up));
Real c2 = gh_scm2double (gh_cadr (up));
Real c3 = gh_scm2double (gh_caddr (up));
if (!gh_symbol_p (index_cell (me->get_grob_property ("attachment"), dir)))
{
for (SCM s = me->get_grob_property ("extremity-rules");
- s != SCM_EOL; s = gh_cdr (s))
+ s != SCM_EOL; s = ly_cdr (s))
{
SCM r = gh_call2 (gh_caar (s), me->self_scm (),
gh_int2scm ((int)dir));
Slur::get_first_notecolumn_y (Grob *me, Direction dir)
{
Grob *col = dir == LEFT
- ? unsmob_grob (gh_car (scm_reverse (me->get_grob_property
+ ? unsmob_grob (ly_car (scm_reverse (me->get_grob_property
("note-columns"))))
: unsmob_grob
- (gh_car (me->get_grob_property ("note-columns")));
+ (ly_car (me->get_grob_property ("note-columns")));
Grob *common[] =
{
set_extremities (me);
s = me->get_grob_property ("attachment");
}
- SCM a = dir == LEFT ? gh_car (s) : gh_cdr (s);
+ SCM a = dir == LEFT ? ly_car (s) : ly_cdr (s);
Spanner*sp = dynamic_cast<Spanner*> (me);
String str = ly_symbol2string (a);
Real staff_space = Staff_symbol_referencer::staff_space ((Grob*)me);
Hmm, maybe after-line-breaking should set this to loose-end? */
else // if (str == "loose-end")
{
- SCM other_a = dir == LEFT ? gh_cdr (s) : gh_car (s);
+ SCM other_a = dir == LEFT ? ly_cdr (s) : ly_car (s);
if (ly_symbol2string (other_a) != "loose-end")
o = broken_trend_offset (me, dir);
}
if (l != SCM_BOOL_F)
{
- Offset off = ly_scm2offset (gh_cdr (l)) * staff_space;
+ Offset off = ly_scm2offset (ly_cdr (l)) * staff_space;
off[X_AXIS] *= dir;
off[Y_AXIS] *= Directional_element_interface::get (me);
o += off;
Link_array<Grob> encompass_arr;
while (gh_pair_p (eltlist))
{
- encompass_arr.push (unsmob_grob (gh_car (eltlist)));
- eltlist =gh_cdr (eltlist);
+ encompass_arr.push (unsmob_grob (ly_car (eltlist)));
+ eltlist =ly_cdr (eltlist);
}
encompass_arr.reverse ();
SCM h_inf_scm = scm_assq (ly_symbol2scm ("height-limit"), details);
SCM r_0_scm = scm_assq (ly_symbol2scm ("ratio"), details);
- Real r_0 = gh_scm2double (gh_cdr (r_0_scm));
- Real h_inf = staff_space * gh_scm2double (gh_cdr (h_inf_scm));
+ Real r_0 = gh_scm2double (ly_cdr (r_0_scm));
+ Real h_inf = staff_space * gh_scm2double (ly_cdr (h_inf_scm));
Slur_bezier_bow bb (get_encompass_offset_arr (me),
Directional_element_interface::get (me),
bb.minimise_enclosed_area (sb, details);
SCM sbf = scm_assq (ly_symbol2scm ("force-blowfit"), details);
Real bff = 1.0;
- if (gh_pair_p (sbf) && gh_number_p (gh_cdr (sbf)))
- bff = gh_scm2double (gh_cdr (sbf));
+ if (gh_pair_p (sbf) && gh_number_p (ly_cdr (sbf)))
+ bff = gh_scm2double (ly_cdr (sbf));
bb.curve_.control_[1][Y_AXIS] *= bff;
bb.curve_.control_[2][Y_AXIS] *= bff;
if (!scm_ilength (me->get_grob_property ("note-columns")))
return b;
- for (SCM s= me->get_grob_property ("control-points"); s != SCM_EOL; s = gh_cdr (s))
+ for (SCM s= me->get_grob_property ("control-points"); s != SCM_EOL; s = ly_cdr (s))
{
- b.control_[i] = ly_scm2offset (gh_car (s));
+ b.control_[i] = ly_scm2offset (ly_car (s));
i++;
}
{
SCM mins = get_minimum_distances (me);
SCM newdist = gh_double2scm (d);
- for (SCM s = mins; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = mins; gh_pair_p (s); s = ly_cdr (s))
{
- SCM dist = gh_car (s);
- if (gh_car (dist) == p->self_scm ())
+ SCM dist = ly_car (s);
+ if (ly_car (dist) == p->self_scm ())
{
- gh_set_cdr_x (dist, scm_max (gh_cdr (dist),
+ gh_set_cdr_x (dist, scm_max (ly_cdr (dist),
newdist));
return ;
}
SCM newdist= gh_double2scm (d);
- for (SCM s = mins; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = mins; gh_pair_p (s); s = ly_cdr (s))
{
- SCM dist = gh_car (s);
- if (gh_car (dist) == p->self_scm ())
+ SCM dist = ly_car (s);
+ if (ly_car (dist) == p->self_scm ())
{
programming_error ("already have that spring");
return ;
Real left_distance = 0;
if (gh_pair_p (hint))
{
- left_distance = gh_scm2double (gh_cdr (hint));
+ left_distance = gh_scm2double (ly_cdr (hint));
}
// 2nd condition should be (i+1 < col_count ()), ie. not the last column in score. FIXME
else if (!Paper_column::musical_b (lc) && i+1 < cols.size ())
Real right_dist = 0.0;
if (gh_pair_p (next_hint))
{
- right_dist += - gh_scm2double (gh_car (next_hint));
+ right_dist += - gh_scm2double (ly_car (next_hint));
}
else
{
if (gh_pair_p (next_stretch_hint))
// see regtest spacing-tight
- stretch_dist += - gh_scm2double (gh_car (next_stretch_hint));
+ stretch_dist += - gh_scm2double (ly_car (next_stretch_hint));
else
stretch_dist += right_dist;
if (scm_ilength (dl) != 1 || scm_ilength (dr) != 1)
return 0.;
- dl = gh_car (dl);
- dr = gh_car (dr);
+ dl = ly_car (dl);
+ dr = ly_car (dr);
assert (gh_number_p (dl) && gh_number_p (dr));
int d1 = gh_scm2int (dl);
for (int i=0; i < arpeggios_.size (); i ++)
{
for (SCM s = arpeggios_[i]->get_grob_property ("stems");
- gh_pair_p (s); s = gh_cdr (s))
- Group_interface::add_thing (span_arpeggio_, "stems", gh_car (s));
+ gh_pair_p (s); s = ly_cdr (s))
+ Group_interface::add_thing (span_arpeggio_, "stems", ly_car (s));
for (SCM s = arpeggios_[i]->get_grob_property ("side-support-elements");
- gh_pair_p (s); s = gh_cdr (s))
- Group_interface::add_thing (span_arpeggio_, "side-support-elements", gh_car (s));
+ gh_pair_p (s); s = ly_cdr (s))
+ Group_interface::add_thing (span_arpeggio_, "side-support-elements", ly_car (s));
/*
we can't kill the children, since we don't want to the
// compute common refpoint of elements
Grob *refp = me;
- for (SCM elts = first_elt; gh_pair_p (elts); elts = gh_cdr (elts))
+ for (SCM elts = first_elt; gh_pair_p (elts); elts = ly_cdr (elts))
{
- SCM smobbed_staff_bar = gh_car (elts);
+ SCM smobbed_staff_bar = ly_car (elts);
Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
refp = staff_bar->common_refpoint (refp, Y_AXIS);
}
Molecule span_bar_mol;
Interval prev_extent;
- for (SCM elts = first_elt; gh_pair_p (elts); elts = gh_cdr (elts))
+ for (SCM elts = first_elt; gh_pair_p (elts); elts = ly_cdr (elts))
{
- SCM smobbed_staff_bar = gh_car (elts);
+ SCM smobbed_staff_bar = ly_car (elts);
Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
Interval ext = staff_bar->extent (refp, Y_AXIS);
if (ext.empty_b ())
Span_bar::evaluate_glyph (Grob*me)
{
SCM elts = me->get_grob_property ("elements");
- Grob * b = unsmob_grob (gh_car (elts));
+ Grob * b = unsmob_grob (ly_car (elts));
SCM glsym =ly_symbol2scm ("glyph");
SCM gl =b ->get_grob_property (glsym);
if (!gh_string_p (gl))
if (!it)
return;
Item * col = it->column_l ();
- Item * i1 = dynamic_cast<Item*> (unsmob_grob (gh_car (extremal_pair)));
- Item * i2 = dynamic_cast<Item*> (unsmob_grob (gh_cdr (extremal_pair)));
+ Item * i1 = dynamic_cast<Item*> (unsmob_grob (ly_car (extremal_pair)));
+ Item * i2 = dynamic_cast<Item*> (unsmob_grob (ly_cdr (extremal_pair)));
int r = Paper_column::rank_i (col);
if (!i1 || r < Paper_column::rank_i (i1->column_l ()))
{
{
if (gh_pair_p (value))
{
- extend_spanner_over_elements (gh_car (value), extremal_pair);
- extend_spanner_over_elements (gh_cdr (value), extremal_pair);
+ extend_spanner_over_elements (ly_car (value), extremal_pair);
+ extend_spanner_over_elements (ly_cdr (value), extremal_pair);
}
else if (unsmob_grob (value))
{
SCM pair = gh_cons (s1,s2);
extend_spanner_over_elements (sp->mutable_property_alist_, pair);
- Grob *p1 = unsmob_grob (gh_car (pair));
- Grob* p2 = unsmob_grob (gh_cdr (pair));
+ Grob *p1 = unsmob_grob (ly_car (pair));
+ Grob* p2 = unsmob_grob (ly_cdr (pair));
sp->set_bound (LEFT,p1);
sp->set_bound (RIGHT, p2);
}
UGH.
*/
- return unsmob_grob (gh_car (me->get_grob_property ("heads")));
+ return unsmob_grob (ly_car (me->get_grob_property ("heads")));
}
else
return first_head (me);
Drul_array<Grob *> exthead;
exthead[LEFT] = exthead[RIGHT] =0;
- for (SCM s = me->get_grob_property ("heads"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("heads"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * n = unsmob_grob (gh_car (s));
+ Grob * n = unsmob_grob (ly_car (s));
int p = int (Staff_symbol_referencer::position_f (n));
Stem::note_head_positions (Grob *me)
{
Array<int> ps ;
- for (SCM s = me->get_grob_property ("heads"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("heads"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * n = unsmob_grob (gh_car (s));
+ Grob * n = unsmob_grob (ly_car (s));
int p = int (Staff_symbol_referencer::position_f (n));
ps.push (p);
else
{
s = me->get_grob_property ("lengths");
- for (SCM q = s; q != SCM_EOL; q = gh_cdr (q))
- a.push (gh_scm2double (gh_car (q)));
+ for (SCM q = s; q != SCM_EOL; q = ly_cdr (q))
+ a.push (gh_scm2double (ly_car (q)));
// stem uses half-spaces
length_f = a[ ((flag_i (me) - 2) >? 0) <? (a.size () - 1)] * 2;
a.clear ();
s = me->get_grob_property ("stem-shorten");
- for (SCM q = s; gh_pair_p (q); q = gh_cdr (q))
- a.push (gh_scm2double (gh_car (q)));
+ for (SCM q = s; gh_pair_p (q); q = ly_cdr (q))
+ a.push (gh_scm2double (ly_car (q)));
// stem uses half-spaces
- // fixme: use gh_list_ref () iso. array[]
+ // fixme: use scm_listify_ref () iso. array[]
Real shorten_f = a[ ((flag_i (me) - 2) >? 0) <? (a.size () - 1)] * 2;
/* URGURGURG
s = me->get_grob_property ("beamed-minimum-lengths");
a.clear ();
- for (SCM q = s; q != SCM_EOL; q = gh_cdr (q))
- a.push (gh_scm2double (gh_car (q)));
+ for (SCM q = s; q != SCM_EOL; q = ly_cdr (q))
+ a.push (gh_scm2double (ly_car (q)));
Real minimum_length = a[multiplicity <? (a.size () - 1)] * staff_space;
s = me->get_grob_property ("beamed-lengths");
a.clear ();
- for (SCM q = s; q != SCM_EOL; q = gh_cdr (q))
- a.push (gh_scm2double (gh_car (q)));
+ for (SCM q = s; q != SCM_EOL; q = ly_cdr (q))
+ a.push (gh_scm2double (ly_car (q)));
Real stem_length = a[multiplicity <? (a.size () - 1)] * staff_space;
{
Real arc_height = gh_scm2double (me->get_grob_property ("arch-height")) ;
- SCM at = gh_list (ly_symbol2scm ("bracket"),
+ SCM at = scm_listify (ly_symbol2scm ("bracket"),
me->get_grob_property ("arch-angle"),
me->get_grob_property ("arch-width"),
gh_double2scm (arc_height),
name. This is better than using find_font directly,
esp. because that triggers mktextfm for non-existent
fonts. */
- SCM alist = gh_list (gh_cons (ly_symbol2scm ("font-family"),
+ SCM alist = scm_listify (gh_cons (ly_symbol2scm ("font-family"),
ly_symbol2scm ("braces")),
gh_cons (ly_symbol2scm ("font-relative-size"),
gh_int2scm (i)),
SCM_UNDEFINED);
- fm = Font_interface::get_font (me, gh_list (alist, SCM_UNDEFINED));
+ fm = Font_interface::get_font (me, scm_listify (alist, SCM_UNDEFINED));
/* Hmm, if lookup fails, we get cmr10 anyway */
- if (ly_scm2string (gh_car (fm->description_)) == "cmr10")
+ if (ly_scm2string (ly_car (fm->description_)) == "cmr10")
break;
}
else
}
while (hi - lo > 1);
- SCM at = gh_list (ly_symbol2scm ("char"), gh_int2scm (lo), SCM_UNDEFINED);
+ SCM at = scm_listify (ly_symbol2scm ("char"), gh_int2scm (lo), SCM_UNDEFINED);
at = fontify_atom (fm, at);
b = fm->get_char (lo);
else if (gh_pair_p (text))
{
/* urg, why not just do this in markup_text2molecule ? */
- if (gh_string_p (gh_car (text)))
+ if (gh_string_p (ly_car (text)))
return markup_text2molecule (me,
- gh_append2 (gh_list (SCM_EOL,
+ gh_append2 (scm_listify (SCM_EOL,
SCM_UNDEFINED),
text),
alist_chain);
#'(("foo"))
*/
else if (scm_ilength (text) <= 1)
- return text2molecule (me, gh_car (text), alist_chain);
+ return text2molecule (me, ly_car (text), alist_chain);
else
return markup_text2molecule (me, text, alist_chain);
}
{
SCM style = ly_assoc_chain (ly_symbol2scm ("font-style"),
alist_chain);
- if (gh_pair_p (style) && gh_symbol_p (gh_cdr (style)))
- alist_chain = Font_interface::add_style (me, gh_cdr (style), alist_chain);
+ if (gh_pair_p (style) && gh_symbol_p (ly_cdr (style)))
+ alist_chain = Font_interface::add_style (me, ly_cdr (style), alist_chain);
Font_metric *fm = Font_interface::get_font (me, alist_chain);
SCM lookup = ly_assoc_chain (ly_symbol2scm ("lookup"), alist_chain);
Molecule mol;
- if (gh_pair_p (lookup) && gh_cdr (lookup) ==ly_symbol2scm ("name"))
+ if (gh_pair_p (lookup) && ly_cdr (lookup) ==ly_symbol2scm ("name"))
mol = lookup_character (me, fm, text);
else
mol = lookup_text (me, fm, text);
#endif
- SCM list = gh_list (ly_symbol2scm ("text"), text, SCM_UNDEFINED);
+ SCM list = scm_listify (ly_symbol2scm ("text"), text, SCM_UNDEFINED);
list = fontify_atom (fm, list);
return Molecule (fm->text_dimension (ly_scm2string (text)), list);
SCM alist_chain)
{
SCM sheet = me->paper_l ()->style_sheet_;
- SCM f = gh_cdr (scm_assoc (ly_symbol2scm ("markup-to-properties"), sheet));
+ SCM f = ly_cdr (scm_assoc (ly_symbol2scm ("markup-to-properties"), sheet));
- SCM markup = gh_car (markup_text);
- SCM text = gh_cdr (markup_text);
+ SCM markup = ly_car (markup_text);
+ SCM text = ly_cdr (markup_text);
SCM p = gh_cons (gh_call2 (f, sheet, markup), alist_chain);
Axis axis = X_AXIS;
SCM a = ly_assoc_chain (ly_symbol2scm ("axis"), p);
- if (gh_pair_p (a) && isaxis_b (gh_cdr (a)))
- axis = (Axis)gh_scm2int (gh_cdr (a));
+ if (gh_pair_p (a) && isaxis_b (ly_cdr (a)))
+ axis = (Axis)gh_scm2int (ly_cdr (a));
Real baseline_skip = 0;
SCM b = ly_assoc_chain (ly_symbol2scm ("baseline-skip"), p);
- if (gh_pair_p (b) && gh_number_p (gh_cdr (b)))
- baseline_skip = gh_scm2double (gh_cdr (b)) * staff_space;
+ if (gh_pair_p (b) && gh_number_p (ly_cdr (b)))
+ baseline_skip = gh_scm2double (ly_cdr (b)) * staff_space;
Real kern[2] = {0,0};
SCM k = ly_assoc_chain (ly_symbol2scm ("kern"), p);
- if (gh_pair_p (k) && gh_number_p (gh_cdr (k)))
- kern[axis] = gh_scm2double (gh_cdr (k)) * staff_space;
+ if (gh_pair_p (k) && gh_number_p (ly_cdr (k)))
+ kern[axis] = gh_scm2double (ly_cdr (k)) * staff_space;
Real raise = 0;
SCM r = ly_assoc_chain (ly_symbol2scm ("raise"), p);
- if (gh_pair_p (r) && gh_number_p (gh_cdr (r)))
- raise = gh_scm2double (gh_cdr (r)) * staff_space;
+ if (gh_pair_p (r) && gh_number_p (ly_cdr (r)))
+ raise = gh_scm2double (ly_cdr (r)) * staff_space;
Interval extent;
bool extent_b = false;
SCM e = ly_assoc_chain (ly_symbol2scm ("extent"), p);
- if (gh_pair_p (e) && ly_number_pair_p (gh_cdr (e)))
+ if (gh_pair_p (e) && ly_number_pair_p (ly_cdr (e)))
{
extent = Interval (gh_scm2double (gh_cadr (e)) * staff_space,
gh_scm2double (gh_cddr (e)) * staff_space);
while (gh_pair_p (text))
{
- Molecule m = text2molecule (me, gh_car (text), p);
+ Molecule m = text2molecule (me, ly_car (text), p);
/*
TODO: look at padding?
*/
SCM next_p = SCM_EOL;
- if (gh_pair_p (gh_car (text)))
- next_p = gh_list (gh_call2 (f, sheet, gh_caar (text)), SCM_UNDEFINED);
+ if (gh_pair_p (ly_car (text)))
+ next_p = scm_listify (gh_call2 (f, sheet, gh_caar (text)), SCM_UNDEFINED);
SCM next_k = ly_assoc_chain (ly_symbol2scm ("kern"), next_p);
Real next_kern = kern[axis];
- if (gh_pair_p (next_k) && gh_number_p (gh_cdr (next_k)))
- next_kern = gh_scm2double (gh_cdr (next_k)) * staff_space;
+ if (gh_pair_p (next_k) && gh_number_p (ly_cdr (next_k)))
+ next_kern = gh_scm2double (ly_cdr (next_k)) * staff_space;
SCM next_r = ly_assoc_chain (ly_symbol2scm ("raise"), next_p);
Real next_raise = 0;
- if (gh_pair_p (next_r) && gh_number_p (gh_cdr (next_r)))
- next_raise = gh_scm2double (gh_cdr (next_r)) * staff_space;
+ if (gh_pair_p (next_r) && gh_number_p (ly_cdr (next_r)))
+ next_raise = gh_scm2double (ly_cdr (next_r)) * staff_space;
o[Y_AXIS] = next_raise;
mol.add_at_edge (axis, axis == X_AXIS ? RIGHT : DOWN, m, next_kern);
}
}
- text = gh_cdr (text);
+ text = ly_cdr (text);
}
if (extent_b)
/* Hmm, we're not allowed to change a Molecule's extent? */
mol.dim_[axis] = extent;
Molecule::ly_set_molecule_extent_x (mol.self_scm (), gh_int2scm (axis),
- gh_cdr (e));
+ ly_cdr (e));
#else
// burp: unpredictable names, these...
Box b = mol.extent_box ();
SCM s = me->get_grob_property ("shorten");
if (gh_pair_p (s))
{
- shorten[LEFT] = gh_scm2double (gh_car (s));
- shorten[RIGHT] = gh_scm2double (gh_cdr (s));
+ shorten[LEFT] = gh_scm2double (ly_car (s));
+ shorten[RIGHT] = gh_scm2double (ly_cdr (s));
}
width -= shorten[LEFT] + shorten[RIGHT];
if (!i)
return;
- SCM pair = gh_list_ref (head_list, gh_int2scm (i/2));
+ SCM pair = scm_listify_ref (head_list, gh_int2scm (i/2));
Spanner * p = new Spanner (basic);
Tie::set_interface (p);
- Tie::set_head (p,LEFT, dynamic_cast<Item*> (unsmob_grob (gh_car (pair))));
- Tie::set_head (p,RIGHT, dynamic_cast<Item*> (unsmob_grob (gh_cdr (pair))));
+ Tie::set_head (p,LEFT, dynamic_cast<Item*> (unsmob_grob (ly_car (pair))));
+ Tie::set_head (p,RIGHT, dynamic_cast<Item*> (unsmob_grob (ly_cdr (pair))));
tie_p_arr_.push (p);
announce_grob (p, req_l_);
}
- else for (SCM s = head_list; gh_pair_p (s); s = gh_cdr (s))
+ else for (SCM s = head_list; gh_pair_p (s); s = ly_cdr (s))
{
Grob * p = new Spanner (basic);
Tie::set_interface (p);
SCM lim // groetjes aan de chirurgendochter.
= scm_assq (ly_symbol2scm ("height-limit"),details);
- Real h_inf = gh_scm2double (gh_cdr (lim)) * staff_space;
- Real r_0 = gh_scm2double (gh_cdr (scm_assq (ly_symbol2scm ("ratio"),details)));
+ Real h_inf = gh_scm2double (ly_cdr (lim)) * staff_space;
+ Real r_0 = gh_scm2double (ly_cdr (scm_assq (ly_symbol2scm ("ratio"),details)));
Bezier b = slur_shape (width, h_inf, r_0);
Bezier b;
int i = 0;
- for (SCM s= cp; s != SCM_EOL; s = gh_cdr (s))
+ for (SCM s= cp; s != SCM_EOL; s = ly_cdr (s))
{
- b.control_[i] = ly_scm2offset (gh_car (s));
+ b.control_[i] = ly_scm2offset (ly_car (s));
i++;
}
if (gh_pair_p (fr) && !gh_equal_p (fr, prev_fraction_))
{
prev_fraction_ = fr;
- int b = gh_scm2int (gh_car (fr));
- int o = gh_scm2int (gh_cdr (fr));
+ int b = gh_scm2int (ly_car (fr));
+ int o = gh_scm2int (ly_cdr (fr));
audio_p_ = new Audio_time_signature (b,o);
Audio_element_info info (audio_p_, 0);
int d = 4;
if (gh_pair_p (frac))
{
- n = gh_scm2int (gh_car (frac));
- d = gh_scm2int (gh_cdr (frac));
+ n = gh_scm2int (ly_car (frac));
+ d = gh_scm2int (ly_cdr (frac));
}
void
Translator_def::add_push_property (SCM props, SCM syms, SCM vals)
{
- this->property_ops_ = gh_cons (gh_list (push_sym, props, syms, vals, SCM_UNDEFINED),
+ this->property_ops_ = gh_cons (scm_listify (push_sym, props, syms, vals, SCM_UNDEFINED),
this->property_ops_);
}
void
Translator_def::add_pop_property (SCM props, SCM syms)
{
- this->property_ops_ = gh_cons (gh_list (push_sym, props, syms, SCM_UNDEFINED),
+ this->property_ops_ = gh_cons (scm_listify (push_sym, props, syms, SCM_UNDEFINED),
this->property_ops_);
}
{
if (gh_symbol_p (syms))
dynamic_cast<Translator_group*> (me)->execute_single_pushpop_property (syms, eprop, val);
- else for (SCM s = syms; gh_pair_p (s); s = gh_cdr (s))
- dynamic_cast<Translator_group*> (me)->execute_single_pushpop_property (gh_car (s), eprop, val);
+ else for (SCM s = syms; gh_pair_p (s); s = ly_cdr (s))
+ dynamic_cast<Translator_group*> (me)->execute_single_pushpop_property (ly_car (s), eprop, val);
}
assert (gh_string_p (type_str));
Link_array<Translator_def> accepted_arr;
- for (SCM s = accepts_name_list_; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = accepts_name_list_; gh_pair_p (s); s = ly_cdr (s))
{
- Translator_def *t = unsmob_translator_def (odef->find_translator_l (gh_car (s)));
+ Translator_def *t = unsmob_translator_def (odef->find_translator_l (ly_car (s)));
if (!t)
continue;
accepted_arr.push (t);
trans_list (SCM namelist, Translator_group*tg)
{
SCM l = SCM_EOL;
- for (SCM s = namelist; gh_pair_p (s) ; s = gh_cdr (s))
+ for (SCM s = namelist; gh_pair_p (s) ; s = ly_cdr (s))
{
- Translator * t = get_translator_l (ly_scm2string (gh_car (s)));
+ Translator * t = get_translator_l (ly_scm2string (ly_car (s)));
if (!t)
warning (_f ("can't find: `%s'", s));
else
Translator_def::apply_property_operations (Translator_group*tg)
{
SCM correct_order = scm_reverse (property_ops_); // pity of the mem.
- for (SCM s = correct_order; gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = correct_order; gh_pair_p (s); s = ly_cdr (s))
{
- SCM entry = gh_car (s);
- SCM type = gh_car (entry);
- entry = gh_cdr (entry);
+ SCM entry = ly_car (s);
+ SCM type = ly_car (entry);
+ entry = ly_cdr (entry);
if (type == push_sym)
{
SCM val = gh_cddr (entry);
- val = gh_pair_p (val) ? gh_car (val) : SCM_UNDEFINED;
+ val = gh_pair_p (val) ? ly_car (val) : SCM_UNDEFINED;
- apply_pushpop_property (tg, gh_car (entry), gh_cadr (entry), val);
+ apply_pushpop_property (tg, ly_car (entry), gh_cadr (entry), val);
}
else if (type == assign_sym)
{
- tg->set_property (gh_car (entry), gh_cadr (entry));
+ tg->set_property (ly_car (entry), gh_cadr (entry));
}
}
}
void
Translator_def::add_property_assign (SCM nm, SCM val)
{
- this->property_ops_ = gh_cons (gh_list (assign_sym, scm_string_to_symbol (nm), val, SCM_UNDEFINED),
+ this->property_ops_ = gh_cons (scm_listify (assign_sym, scm_string_to_symbol (nm), val, SCM_UNDEFINED),
this->property_ops_);
}
Translator_def::default_child_context_name ()
{
SCM d = accepts_name_list_;
- return gh_pair_p (d) ? gh_car (scm_last_pair (d)) : SCM_EOL;
+ return gh_pair_p (d) ? ly_car (scm_last_pair (d)) : SCM_EOL;
}
SCM
SCM next = SCM_EOL;
for (SCM p = trans_group_list_; gh_pair_p (p); p = next)
{
- next = gh_cdr (p);
+ next = ly_cdr (p);
- Translator_group *trg = dynamic_cast<Translator_group*> (unsmob_translator (gh_car (p)));
+ Translator_group *trg = dynamic_cast<Translator_group*> (unsmob_translator (ly_car (p)));
trg->check_removal ();
if (trg->removable_b ())
return this;
Translator_group* r = 0;
- for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = ly_cdr (p))
{
- Translator * t = unsmob_translator (gh_car (p));
+ Translator * t = unsmob_translator (ly_car (p));
r = dynamic_cast<Translator_group*> (t)->find_existing_translator_l (n, id);
}
{
bool hebbes_b =false;
- for (SCM p = simple_trans_list_; !hebbes_b && gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = simple_trans_list_; !hebbes_b && gh_pair_p (p); p = ly_cdr (p))
{
- hebbes_b = unsmob_translator (gh_car (p))->try_music (m);
+ hebbes_b = unsmob_translator (ly_car (p))->try_music (m);
}
return hebbes_b;
}
static void
static_each (SCM list, Method_pointer method)
{
- for (SCM p = list; gh_pair_p (p); p = gh_cdr (p))
- (unsmob_translator (gh_car (p))->*method) ();
+ for (SCM p = list; gh_pair_p (p); p = ly_cdr (p))
+ (unsmob_translator (ly_car (p))->*method) ();
}
SCM newprops= SCM_EOL ;
while (gh_pair_p (prev) && gh_caar (prev) != eltprop)
{
- newprops = gh_cons (gh_car (prev), newprops);
- prev = gh_cdr (prev);
+ newprops = gh_cons (ly_car (prev), newprops);
+ prev = ly_cdr (prev);
}
if (gh_pair_p (prev))
{
- newprops = scm_reverse_x (newprops, gh_cdr (prev));
+ newprops = scm_reverse_x (newprops, ly_cdr (prev));
set_property (prop, newprops);
}
}
bool b = s == type_str_;
for (SCM a = unsmob_translator_def (definition_)->type_aliases_;
- !b && gh_pair_p (a); a = gh_cdr (a))
- b = b || s == ly_scm2string (gh_car (a));
+ !b && gh_pair_p (a); a = ly_cdr (a))
+ b = b || s == ly_scm2string (ly_car (a));
return b;
}
int
Translator::print_smob (SCM s, SCM port, scm_print_state *)
{
- Translator *sc = (Translator *) gh_cdr (s);
+ Translator *sc = (Translator *) ly_cdr (s);
scm_puts ("#<Translator ", port);
scm_puts ((char *)sc->name (), port);
SCM thick = me->get_grob_property ("thick");
SCM gap = me->get_grob_property ("number-gap");
- SCM at =gh_list (ly_symbol2scm ("tuplet"),
+ SCM at =scm_listify (ly_symbol2scm ("tuplet"),
gh_double2scm (1.0),
gap,
gh_double2scm (w),
}
d = UP ;
- for (SCM s = me->get_grob_property ("columns"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_grob_property ("columns"); gh_pair_p (s); s = ly_cdr (s))
{
- Grob * nc = unsmob_grob (gh_car (s));
+ Grob * nc = unsmob_grob (ly_car (s));
if (Note_column::dir (nc) < 0)
{
d = DOWN;
SCM proc = get_property ("tupletNumberFormatFunction");
if (gh_procedure_p (proc))
{
- SCM t = gh_apply (proc, gh_list (time_scaled_music_arr_[i]->self_scm (), SCM_UNDEFINED));
+ SCM t = gh_apply (proc, scm_listify (time_scaled_music_arr_[i]->self_scm (), SCM_UNDEFINED));
glep->set_grob_property ("text", t);
}
if (gh_pair_p (alternative_cons_))
{
- current_iter_p_ = get_iterator_p (unsmob_music (gh_car (alternative_cons_)));
+ current_iter_p_ = get_iterator_p (unsmob_music (ly_car (alternative_cons_)));
do_main_b_ = false;
if (volta_b_)
}
if (do_repcommands)
- add_repeat_command (gh_list (ly_symbol2scm ("volta"),
+ add_repeat_command (scm_listify (ly_symbol2scm ("volta"),
ly_str02scm (repstr.ch_C ()), SCM_UNDEFINED));
}
}
*/
if (alternative_cons_)
{
- here_mom_ += unsmob_music (gh_car (alternative_cons_))->length_mom ();
+ here_mom_ += unsmob_music (ly_car (alternative_cons_))->length_mom ();
if (volta_b_ ||
repmus->repeat_count () - done_count_ < alternative_count_i_)
- alternative_cons_ = gh_cdr (alternative_cons_);
+ alternative_cons_ = ly_cdr (alternative_cons_);
if (do_repcommands)
- add_repeat_command (gh_list (ly_symbol2scm ("volta"), SCM_BOOL_F, SCM_UNDEFINED));
+ add_repeat_command (scm_listify (ly_symbol2scm ("volta"), SCM_BOOL_F, SCM_UNDEFINED));
if (do_repcommands)
{
String repstr = to_str (done_count_ + 1) + ".";
- add_repeat_command (gh_list (ly_symbol2scm ("volta"),
+ add_repeat_command (scm_listify (ly_symbol2scm ("volta"),
ly_str02scm (repstr.ch_C ()), SCM_UNDEFINED));
add_repeat_command (ly_symbol2scm ("end-repeat"));
}
if (volta_b_)
- current_iter_p_ = get_iterator_p (unsmob_music (gh_car (alternative_cons_)));
+ current_iter_p_ = get_iterator_p (unsmob_music (ly_car (alternative_cons_)));
else
{
current_iter_p_ = get_iterator_p (repmus->body ());
? mus->alternatives ()->music_list ()
: SCM_EOL;
- for (SCM p = alternative_cons_; gh_pair_p (p); p = gh_cdr (p))
+ for (SCM p = alternative_cons_; gh_pair_p (p); p = ly_cdr (p))
alternative_count_i_ ++;
if (mus->body ())
}
else if (gh_pair_p (alternative_cons_))
{
- current_iter_p_ = get_iterator_p (unsmob_music (gh_car (alternative_cons_)));
+ current_iter_p_ = get_iterator_p (unsmob_music (ly_car (alternative_cons_)));
do_main_b_ = false;
}
s = gh_append2 (nm, s);
Moment m = 0;
- for (SCM i = nm; gh_pair_p (i); i = gh_cdr (i))
- m = m >? unsmob_music (gh_car (i))->length_mom ();
+ for (SCM i = nm; gh_pair_p (i); i = ly_cdr (i))
+ m = m >? unsmob_music (ly_car (i))->length_mom ();
if (m > Moment (0))
break ;
start_str_ = SCM_EOL;
while (gh_pair_p (cs))
{
- SCM c = gh_car (cs);
+ SCM c = ly_car (cs);
- if (gh_pair_p (c) && gh_car (c) == ly_symbol2scm ("volta")
- && gh_pair_p (gh_cdr (c)))
+ if (gh_pair_p (c) && ly_car (c) == ly_symbol2scm ("volta")
+ && gh_pair_p (ly_cdr (c)))
{
if (gh_cadr (c) == SCM_BOOL_F)
end = true;
start_str_ = gh_cadr (c);
}
- cs = gh_cdr (cs);
+ cs = ly_cdr (cs);
}
if (volta_span_p_)
bool no_vertical_start = orig_span && !first_bracket;
bool no_vertical_end = orig_span && !last_bracket;
SCM bars = me->get_grob_property ("bars");
- Grob * endbar = unsmob_grob (gh_car (bars));
+ Grob * endbar = unsmob_grob (ly_car (bars));
SCM glyph = endbar->get_grob_property("glyph");
String str = ly_scm2string(glyph);
const char* cs = str.ch_C();
/*
ugh: should build from line segments.
*/
- SCM at = (gh_list (ly_symbol2scm ("volta"),
+ SCM at = (scm_listify (ly_symbol2scm ("volta"),
gh_double2scm (h),
gh_double2scm (w),
gh_double2scm (t),
Box b (Interval (0, w), Interval (0, h));
Molecule mol (b, at);
SCM text = me->get_grob_property ("text");
- SCM properties = gh_list (me->mutable_property_alist_, me->immutable_property_alist_,SCM_UNDEFINED);
+ SCM properties = scm_listify (me->mutable_property_alist_, me->immutable_property_alist_,SCM_UNDEFINED);
Molecule num = Text_item::text2molecule (me, text, properties);
mol.add_at_edge (X_AXIS, LEFT, num, - num.extent (X_AXIS).length ()
0,0
};
+void
+add_constants (PyObject *dict)
+{
+ message_t * p[] = {metaEvents, channelModeMessages, channelVoiceMessages ,0};
+ int i,j;
+ for ( j =0; p[j]; j++)
+ for ( i = 0; p[j][i].description; i++)
+ PyDict_SetItemString (dict, p[j][i].description, Py_BuildValue ("i", p[j][i].msg));
+}
+
unsigned long int
-get_number (char * str, char * end_str, int length)
+get_number (unsigned char ** str, unsigned char * end_str, int length)
{
/* # MIDI uses big-endian for everything */
long sum = 0;
int i = 0;
for (; i < length; i++)
- sum = (sum << 8) + (unsigned char) str[i];
+ sum = (sum << 8) + (unsigned char) (*str)[i];
+ *str += length;
debug_print ("%d:\n", sum);
return sum;
}
unsigned long int
-get_variable_length_number (char **str, char * end_str)
+get_variable_length_number (unsigned char **str, unsigned char * end_str)
{
long sum = 0;
int i = 0;
return sum;
}
-static PyObject *
-read_unimplemented_event (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
+PyObject *
+read_one_byte (unsigned char **track, unsigned char *end,
+ unsigned char x)
{
- debug_print ("%x:%s", z, "unimplemented MIDI event\n");
- *track += 2;
- return Py_BuildValue ("(iii)", z, *((*track) -2), *((*track) -1));
+ PyObject *pyev = Py_BuildValue ("(i)", x);
+ debug_print ("%x:%s", x, "event\n");
+
+ return pyev;
}
PyObject *
-read_one_byte (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
+read_two_bytes (unsigned char **track, unsigned char *end,
+ unsigned char x)
{
- debug_print ("%x:%s", z, "event\n");
+ PyObject *pyev = Py_BuildValue ("(ii)", x, (*track)[0]);
*track += 1;
- return Py_BuildValue ("(ii)", z, *((*track) -1));
+ debug_print ("%x:%s", x, "event\n");
+ return pyev;
}
PyObject *
-read_two_bytes (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
+read_three_bytes (unsigned char **track, unsigned char *end,
+ unsigned char x)
{
- debug_print ("%x:%s", z, "event\n");
- *track += 2;
- return Py_BuildValue ("(iii)", z, *((*track) -2), *((*track) -1));
-}
+ PyObject *pyev = Py_BuildValue ("(iii)", x, (*track)[0],
+ (*track)[1]);
-PyObject *
-read_three_bytes (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
-{
- debug_print ("%x:%s", z, "event\n");
- *track += 3;
- return Py_BuildValue ("(iiii)", z, *((*track) -3), *((*track) -2), *((*track) -1));
+ *track += 2;
+ debug_print ("%x:%s", x, "event\n");
+ return pyev;
}
PyObject *
-read_string (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
+read_string (unsigned char **track, unsigned char *end)
{
unsigned long length = get_variable_length_number (track, end);
- if (length < *track - end)
- debug_print ("%s", "zero length string\n");
+ if (length > end - *track)
+ length = end - *track;
+
*track += length;
- debug_print ("%x:%s", length, "string\n");
- return Py_BuildValue ("(is)", z, *((*track) -length));
+ return Py_BuildValue ("s", ((*track) -length));
}
typedef PyObject* (*Read_midi_event)
- (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z);
-
-Read_midi_event read_ff_byte [16] =
-{
- read_three_bytes, // 0
- read_one_byte, // 10
- read_one_byte, // 20
- read_one_byte, // 30
- read_one_byte, // 40
- read_one_byte, // 50
- read_one_byte, // 60
- read_two_bytes, // 70
- read_two_bytes, // 80
- read_two_bytes, // 90
- read_two_bytes, // a0
- read_two_bytes, // b0
- read_one_byte, // c0
- read_two_bytes, // d0
- read_two_bytes, // e0
- read_two_bytes, // e0
-};
+ (unsigned char **track, unsigned char *end,
+ unsigned char x);
static PyObject *
-read_f0_byte (char **track, char *end, unsigned long time,
- unsigned char x, unsigned char z)
+read_f0_byte (unsigned char **track, unsigned char *end,
+ unsigned char x)
{
- debug_print ("%x:%s", z, "event\n");
- if (z == 0xff)
+ debug_print ("%x:%s", x, "event\n");
+ if (x == 0xff)
{
- unsigned char zz = *(*track)++;
- debug_print ("%x:%s", zz, "f0-event\n");
- if (zz == 0x01 && **track <= 0x07)
- return read_string (track, end, time, x, zz);
- else if (zz == 0x2f && **track == 0x00)
+ unsigned char z = (*track)[0 ];
+ *track += 1;
+ debug_print ("%x:%s", z, "f0-event\n");
+
+ if (z == 0x2f && (*track)[0] == 0x00) /* end of track */
{
- (*track)++;
- debug_print ("%s", "done\n");
+ *track += 1;
return 0;
}
else
- return read_unimplemented_event (track, end, time, x, zz);
- exit (0);
+ return Py_BuildValue ("(iiO)", x, z, read_string (track, end));
}
- else
- return read_string (track, end, time, x, z);
+
+ return Py_BuildValue ("(iO)", x, read_string (track, end));
}
Read_midi_event read_midi_event [16] =
read_one_byte, // 30
read_one_byte, // 40
read_one_byte, // 50
- read_one_byte, // 60
- read_two_bytes, // 70
- read_two_bytes, // 80
- read_two_bytes, // 90
- read_two_bytes, // a0
- read_two_bytes, // b0
- read_one_byte, // c0
- read_two_bytes, // d0
- read_two_bytes, // e0
+ read_one_byte, // 60 data entry.
+ read_two_bytes, // 70 all notes off
+ read_three_bytes, // 80 note off
+ read_three_bytes, // 90 note on
+ read_three_bytes, // a0 poly aftertouch
+ read_three_bytes, // b0 control
+ read_two_bytes, // c0 prog change
+ read_two_bytes, // d0 ch aftertouch
+ read_three_bytes, // e0 pitchwheel range
read_f0_byte, // f0
};
-
+
+
static PyObject *
-read_event (char **track, char *end, unsigned long time,
+read_event (unsigned char **track, unsigned char *end, PyObject *time,
unsigned char *running_status)
{
int rsb_skip = ((**track & 0x80)) ? 1 :0;
unsigned char x = (rsb_skip) ? (*track)[0]: *running_status;
- // unsigned char y = x & 0xf0;
- unsigned char z = (*track)[1 + rsb_skip];
-
- debug_print ("%x:%s", z, "event\n");
- *track += 2 + rsb_skip;
- return (*read_midi_event[z >> 4]) (track, end, time, x, z);
+ PyObject * bare_event = 0;
+ debug_print ("%x:%s", x, "event\n");
+ *running_status = x;
+ *track += rsb_skip;
+
+ // printf ("%x %x %d next %x\n", x, (*track)[0], rsb_skip, (*track)[1]);
+ bare_event = (*read_midi_event[x >> 4]) (track, end, x);
+ if (bare_event)
+ return Py_BuildValue ("(OO)", time, bare_event);
+ else
+ return NULL;
}
static PyObject *
-midi_parse_track (char **track, char *track_end)
+midi_parse_track (unsigned char **track, unsigned char *track_end)
{
unsigned int time = 0;
unsigned char running_status;
assert (!strcmp (*track, "MTrk"));
*track += 4;
- track_len = get_number (*track, *track + 4, 4);
- *track += 4;
+ track_len = get_number (track, *track + 4, 4);
+
debug_print ("track_len: %u\n", track_len);
debug_print ("track_size: %u\n", track_size);
track_end = *track + track_len;
- while (*track < track_end)
- {
- long dt = get_variable_length_number(track, track_end);
- time += dt;
- PyList_Append (pytrack, read_event (track, track_end, time,
- &running_status));
- }
-
+ {
+ PyObject *pytime = PyInt_FromLong (0L);
+ while (*track < track_end)
+ {
+ long dt = get_variable_length_number(track, track_end);
+ PyObject *pyev = 0;
+
+ time += dt;
+ if (dt)
+ pytime = PyInt_FromLong (time);
+
+ pyev = read_event (track, track_end, pytime,
+ &running_status);
+ if (pyev)
+ PyList_Append (pytrack, pyev);
+ }
+ }
+
*track = track_end;
return pytrack;
}
static PyObject *
pymidi_parse_track (PyObject *self, PyObject *args)
{
- char *track, *track_end;
+ unsigned char *track, *track_end;
unsigned long track_size, track_len;
PyObject * sobj = PyTuple_GetItem (args, 0);
}
static PyObject *
-midi_parse (char **midi, char *midi_end)
+midi_parse (unsigned char **midi,unsigned char *midi_end)
{
PyObject *pymidi = 0;
unsigned long header_len;
debug_print ("%s", "\n");
/* Header */
- header_len = get_number (*midi, *midi + 4, 4);
- *midi += 4;
+ header_len = get_number (midi, *midi + 4, 4);
+
if (header_len < 6)
return midi_error ("header too short");
- format = get_number (*midi, *midi + 2, 2);
- *midi += 2;
-
- tracks = get_number (*midi, *midi + 2, 2);
- *midi += 2;
+ format = get_number (midi, *midi + 2, 2);
+ tracks = get_number (midi, *midi + 2, 2);
if (tracks > 32)
return midi_error ("too many tracks");
- division = get_number (*midi, *midi + 2, 2) * 4;
- *midi += 2;
+ division = get_number (midi, *midi + 2, 2) * 4;
+
if (division < 0)
/* return midi_error ("can't handle non-metrical time"); */
*midi += header_len - 6;
pymidi = PyList_New (0);
- PyList_Append (pymidi, Py_BuildValue ("(iii)", format, tracks, division));
/* Tracks */
for (i = 0; i < tracks; i++)
PyList_Append (pymidi, midi_parse_track (midi, midi_end));
+ pymidi = Py_BuildValue ("(OO)", Py_BuildValue ("(ii)", format, division),
+ pymidi);
return pymidi;
}
static PyObject *
pymidi_parse (PyObject *self, PyObject *args)
{
- char *midi, *midi_end;
+ unsigned char *midi, *midi_end;
unsigned long midi_size, midi_len;
PyObject *sobj = PyTuple_GetItem (args, 0);
Midi_error = PyString_FromString ("midi.error");
PyDict_SetItemString (d, "error", Midi_error);
+ add_constants (d);
Midi_warning = PyString_FromString ("midi.warning");
PyDict_SetItemString (d, "warning", Midi_warning);
}
--- /dev/null
+#!@PYTHON@
+
+import midi
+import sys
+
+scale_steps =[0,2,4,5,7,9,11]
+
+def split_channels (track):
+ chs = {}
+ for i in range(16):
+ chs[i] = []
+
+ for e in track:
+ data = list (e[1])
+ c = data[0] & 0x0f
+ e = (e[0], tuple ([data[0] & 0xf0] + data[1:]))
+ chs[c].append (e)
+
+ for i in range (16):
+ if chs[i] == []:
+ del chs[i]
+
+
+ for v in chs.values ():
+ ns = notes_on_channel(v)
+ ns = unthread_notes (ns)
+ map (dump_thread, ns)
+
+ return chs
+
+
+class Note:
+ def __init__(self, duration, pitch, velocity):
+ self.velocity = velocity
+ self.pitch = pitch
+ self.duration = duration
+
+ def duration_compare(a,b):
+ if a.duration < b.duration :
+ return -1
+ elif a.duration > b.duration:
+ return 1
+ else:
+ return 0
+
+def notes_on_channel (channel):
+ pitches = {}
+
+ nch= []
+ for e in channel:
+ t = e[0]
+
+ if e[1][0] == midi.NOTE_ON:
+ if not pitches.has_key (e[1][1]):
+ pitches[e[1][1]] = (t, e[1][2])
+ elif e[1][0] == midi.NOTE_OFF:
+ try:
+ (lt, vel) = pitches[e[1][1]]
+ del pitches[e[1][1]]
+
+ nch.append ((t, Note (t-lt, e[1][1], vel)))
+
+ except KeyError:
+ pass
+ else:
+ pass
+
+ return nch
+
+def unthread_notes (channel):
+ threads = []
+ while channel:
+ thread = []
+ end_busy_t = 0
+ start_busy_t = 0
+ todo = []
+ for e in channel:
+ t = e[0]
+ if (t == start_busy_t and e[1].duration + t == end_busy_t) \
+ or t >= end_busy_t:
+ thread.append (e)
+ start_busy_t = t
+ end_busy_t = t + e[1].duration
+ else:
+ todo.append(e)
+ threads.append (thread)
+ channel = todo
+
+ return threads
+
+def gcd (a,b):
+ if b == 0:
+ return a
+ c = a
+ while c:
+ c = a % b
+ a = b
+ b = c
+ return a
+
+def dump_skip (dt):
+ wholes = dt / (4*384)
+ dt = dt % (4*384);
+ quarters = dt / 384
+
+ # etc.
+ if (wholes):
+ print 's1*%d' % wholes
+ if quarters:
+ print 's4*%d' % quarters
+
+
+
+def dump_duration (dur):
+ g = gcd (dur, 384)
+ sys.stdout.write ('4')
+ (p,q) = (dur / g, 384 / g)
+ if (p == 1 and q == 1) :
+ pass
+ else:
+ if p <> 1:
+ sys.stdout.write ('*%d'% p)
+ if q <> 1:
+ sys.stdout.write ('*%d'% q)
+
+
+def dump_note (note):
+ p = note.pitch
+ oct = p / 12
+ step = p % 12
+
+ i = 0
+ while i < len (scale_steps):
+ if scale_steps[i] > step:
+ break
+ i = i+1
+
+ i = i-1
+ str = chr (i + ord ('a'))
+ if scale_steps[i] <> step:
+ str = str + 'is'
+
+ sys.stdout.write (' %s' % str);
+ dump_duration (note.duration)
+
+def dump_chord (ch):
+ if len(ch) == 1:
+ dump_note (ch[0])
+ else:
+ sys.stdout.write ("<")
+ map (dump_note, ch)
+ sys.stdout.write ('>')
+
+def dump_thread (thread):
+ last_e = None
+ chs = []
+ ch = []
+
+ for e in thread:
+ if last_e and last_e[0] == e[0]:
+ ch.append (e[1])
+ else:
+ if ch:
+ chs.append ( (last_e[0], ch))
+
+ ch = [e[1]]
+
+ last_e = e
+
+ if ch: chs.append ((last_e[0] ,ch))
+ t = 0
+ last_t = 0
+
+ for ch in chs:
+ t = ch[0]
+ if t - last_t:
+ dump_skip (t-last_t)
+
+ dump_chord (ch[1])
+ last_t = t + ch[1][0].duration
+
+def dump_notes (channel):
+ on_hold = []
+ for e in channel:
+ if e[0] <> last_t:
+ dump_chord (on_hold)
+ on_hold = []
+ last_t = e[0]
+
+ on_hold.append (e)
+
+
+
+
+def convert_midi (f):
+ str = open (f).read ()
+ midi_dump = midi.parse (str)
+
+ channels = []
+
+ for t in midi_dump[1]:
+ channels.append (split_channels (t))
+
+
+for f in sys.argv[1:]:
+ convert_midi (f)
projects / lilypond.git / commitdiff