buildscripts/fixcc.py: Fixes.
+2005-08-13 Jan Nieuwenhuizen <janneke@gnu.org>
+
+ * Nitpick run.
+
+ * buildscripts/fixcc.py: Fixes.
+
2005-08-12 Graham Percival <gpermus@gmail.com>
* Documentation/user/advanced-notation.itely: add markup
import time
COMMENT = 'COMMENT'
+STRING = 'STRING'
+GLOBAL_CXX = 'GC++'
CXX = 'C++'
verbose_p = 0
indent_p = 0
rules = {
+ GLOBAL_CXX:
+ [
+ # delete gratuitous block
+ ('''\n( |\t)\s*{\n\s*(.*?)(?![{}]|\b(do|for|else|if|switch|while)\b);\n\s*}''',
+ '\n\\2;'),
+ ],
CXX:
[
# space before parenthesis open
('([^\( \]])[ \t]*\(', '\\1 ('),
# space after comma
- (',[ \t]*', ', '),
+ ("\([^'],\)[ \t]*", '\1 '),
+ # delete gratuitous block
+ ('''\n( |\t)\s*{\n\s*(.*?)(?![{}]|\b(do|for|else|if|switch|while)\b);\n\s*}''',
+ '\n\\2;'),
# delete inline tabs
('(\w)\t+', '\\1 '),
# delete inline double spaces
('(return|=) (\*|&|-|!) ([\w\(])', '\\1 \\2\\3'),
# space after `operator'
('(\Woperator) *([^\w\s])', '\\1 \\2'),
- # delete gratuitous block
- ('''\n( |\t)\s*{\n\s*(.*?)(?![{}]|\b(do|for|else|if|switch|while)\b);\n\s*}''',
- '\n\\2;'),
# dangling brace close
('\n[ \t]*(\n[ \t]*})', '\\1'),
# dangling newline
('\n[ \t]*,', ','),
# dangling semicolon
('\n[ \t]*;', ';'),
- # delete gratuitous blocks
- ('''xx\n([ ]|\t)\s*{\n\s*(.*?)(?![{}]|\b(do|for|else|if|switch|while)\b);\n\s*}''',
- '\n\\2;'),
# brace open
('(\w)[ \t]*([^\s]*){([ \t]*\n)', '\\1\\2\n{\n'),
# brace open backslash
('(\w[^\n]*){[ \t]*\\\\\n', '\\1\\\n{\\\n'),
# brace close
- ('}[ \t]*([^\n]*\w[^\n\\\]*)\n', '}\n\\1\n'),
+ ("}[ \t]*([^'\n]*\w[^\n\\\]*)\n", '}\n\\1\n'),
# brace close backslash
- ('}[ \t]*([^\n]*\w[^\n\\\]*)', '\n}\n\\1'),
+ ("}[ \t]*([^'\n]*\w[^\n\\\]*)", '\n}\n\\1'),
# delete space after `operator'
#('(\Woperator) (\W)', '\\1\\2'),
# delete space after case, label
no_match = 'a\ba'
snippet_res = {
CXX: {
- 'include':
- no_match,
-
- 'multiline_comment':
- r'''(?sx)
- (?P<match>
- (?P<code>
- [ \t]*/\*.*?\*/))''',
-
- 'singleline_comment':
- r'''(?mx)
- ^.*
- (?P<match>
- (?P<code>
- [ \t]*//([ \t][^\n]*|)\n))''',
-
- 'string':
- r'''(?x)
- (?P<match>
- (?P<code>
- "([^"]|(([^\\]|(\\\\))\\"))*"))''',
-
- 'char':
- r'''(?x)
- (?P<match>
- (?P<code>
- '([^']+|\')))''',
-
- 'include':
- r'''(?x)
- (?P<match>
- (?P<code>
- "#[ \t]*include[ \t]*<[^>]*>''',
- },
- }
+ 'multiline_comment':
+ r'''(?sx)
+ (?P<match>
+ (?P<code>
+ [ \t]*/\*.*?\*/))''',
+
+ 'singleline_comment':
+ r'''(?mx)
+ ^.*
+ (?P<match>
+ (?P<code>
+ [ \t]*//([ \t][^\n]*|)\n))''',
+
+ 'string':
+ r'''(?x)
+ (?P<match>
+ (?P<code>
+ "([^\"\n](\")*)*"))''',
+
+ 'char':
+ r'''(?x)
+ (?P<match>
+ (?P<code>
+ '([^']+|\')))''',
+
+ 'include':
+ r'''(?x)
+ (?P<match>
+ (?P<code>
+ "#[ \t]*include[ \t]*<[^>]*>''',
+ },
+ }
class Chunk:
def replacement_text (self):
def filter_text (self):
return self.replacement_text ()
- def ly_is_outdated (self):
- return 0
-
- def png_is_outdated (self):
- return 0
-
class Substring (Chunk):
def __init__ (self, source, start, end):
self.source = source
for i in rules[CXX]:
if verbose_p:
sys.stderr.write ('.')
- #sys.stderr.write ('\n*********\n')
+ #sys.stderr.write ('\n\n***********\n')
#sys.stderr.write (i[0])
- #sys.stderr.write ('\n=========\n')
+ #sys.stderr.write ('\n***********\n')
+ #sys.stderr.write ('\n=========>>\n')
#sys.stderr.write (s)
- #sys.stderr.write ('\n*********\n')
+ #sys.stderr.write ('\n<<=========\n')
s = re.sub (i[0], i[1], s)
if verbose_p:
sys.stderr.write ('done\n')
snippet_type_to_class = {
'multiline_comment': Multiline_comment,
-# 'lilypond_block': Lilypond_snippet,
-# 'lilypond': Lilypond_snippet,
+# 'string': Multiline_comment,
# 'include': Include_snippet,
}
def nitpick_file (outdir, file):
s = open (file).read ()
+ for i in rules[GLOBAL_CXX]:
+ s = re.sub (i[0], i[1], s)
+
# FIXME: Containing blocks must be first, see
# find_toplevel_snippets.
+ # We leave simple strings be part of the code
snippet_types = (
'multiline_comment',
'singleline_comment',
'string',
- 'char',
+# 'char',
)
chunks = find_toplevel_snippets (s, snippet_types)
typedef std::map < AFM_Ligature const *, int > Bar;
+ /**
+ (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ */
+
/* ||
* vv
* !OK OK
a = 0 ? *x : *y;
+a = "foo() 2,2,4";
+{
+ if (!span_)
+ {
+ span_ = make_spanner ("StaffSymbol", SCM_EOL);
+ }
+}
{
- if (foo)
+ if (!span_)
{
- a = 1;
+ span_ = make_spanner (StaffSymbol, SCM_EOL);
}
}
'''
{
String s ("center");
if (a == Y_AXIS)
- {
- s = (d == UP ? "up" : "down");
- }
+ s = (d == UP ? "up" : "down");
else if (a == X_AXIS)
- {
- s = (d == LEFT ? "left" : "right");
- }
+ s = (d == LEFT ? "left" : "right");
return s;
}
File_path::parse_path (String p)
{
int len;
- while ((len = p.length ()) )
+ while ((len = p.length ()))
{
int i = p.index (PATHSEP);
- if (i < 0)
+ if (i < 0)
i = len;
append (p.left_string (i));
p = p.right_string (len - i - 1);
assert (*optnm);
char const *endopt = strchr (optnm, '=');
- int searchlen = (endopt) ? endopt - optnm : strlen (optnm);
+ int searchlen = (endopt) ? endopt - optnm : strlen (optnm);
- found_option_=0;
- for (int i=0; i< table_len_; i++)
+ found_option_ = 0;
+ for (int i = 0; i < table_len_; i++)
{
char const *ln = option_a_[i].longname_str0_;
if (ln && !strncmp (ln, optnm, searchlen))
{
- found_option_ = option_a_+i;
+ found_option_ = option_a_ + i;
break;
}
}
array_index_++;
argument_index_ = 0;
-
if (found_option_->take_arg_str0_)
{
if (endopt)
array_index_++;
}
if (!optional_argument_str0_)
- {
- report (E_ARGEXPECT);
- }
+ report (E_ARGEXPECT);
return found_option_;
}
int wid = 0;
for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
- {
- wid = max (wid, l[i].str_for_help ().length ());
- }
+ wid = max (wid, l[i].str_for_help ().length ());
for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
{
binary_search_bounds (table, key, compare, &lo, &hi);
if (! (*compare) (key, table[lo]))
- {
- return lo;
- }
+ return lo;
else
return -1; /* not found */
}
Cons<T> *last_cons (Cons<T> *head)
{
while (head && head->next_)
- {
- head = head->next_;
- }
+ head = head->next_;
return head;
}
{
Cons<T> **p = &head_;
for (; *p && i; p = &((*p)->next_))
- {
- i--;
- }
+ i--;
if (*p)
{
elem_ref (RIGHT) = min (h.elem (RIGHT), elem (RIGHT));
}
-
template<class T>
String
Interval_t<T>::to_string () const
junk_pointers (Link_array<T> &a)
{
for (int i = 0; i < a.size (); i++)
- {
- delete a[i];
- }
+ delete a[i];
a.clear ();
}
int ch, idx;
/* skip over white space */
- while ((ch = fgetc (stream)) == ' ' || ch == lineterm ||
- ch == lineterm_alt ||
- ch == ',' || ch == '\t' || ch == ';');
+ while ((ch = fgetc (stream)) == ' ' || ch == lineterm
+ || ch == lineterm_alt
+ || ch == ',' || ch == '\t' || ch == ';');
idx = 0;
- while (idx < MAX_NAME - 1 &&
- ch != EOF && ch != ' ' && ch != lineterm && ch != lineterm_alt
+ while (idx < MAX_NAME - 1
+ && ch != EOF && ch != ' ' && ch != lineterm && ch != lineterm_alt
&& ch != '\t' && ch != ':' && ch != ';')
{
ident[idx++] = ch;
} /* while */
if (ch == EOF && idx < 1) return ((char *)NULL);
- if (idx >= 1 && ch != ':' ) ungetc (ch, stream);
- if (idx < 1 ) ident[idx++] = ch; /* single-character token */
+ if (idx >= 1 && ch != ':') ungetc (ch, stream);
+ if (idx < 1) ident[idx++] = ch; /* single-character token */
ident[idx] = 0;
return (ident); /* returns pointer to the token */
{
int ch, idx;
- while ((ch = fgetc (stream)) == ' ' || ch == '\t' );
+ while ((ch = fgetc (stream)) == ' ' || ch == '\t');
idx = 0;
- while (idx < MAX_NAME - 1 &&
- ch != EOF && ch != lineterm && ch != lineterm_alt)
+ while (idx < MAX_NAME - 1
+ && ch != EOF && ch != lineterm && ch != lineterm_alt)
{
ident[idx++] = ch;
ch = fgetc (stream);
Polynomial::differentiate ()
{
for (int i = 1; i <= degree (); i++)
- {
- coefs_[i - 1] = coefs_[i] * i;
- }
+ coefs_[i - 1] = coefs_[i] * i;
coefs_.pop ();
}
#endif
str = to_string (fill_char, length_i - str.length ()) + str;
- while ((str.length () > length_i) && (str[ 0 ] == 'f' ) )
+ while ((str.length () > length_i) && (str[ 0 ] == 'f'))
str = str.cut_string (2, INT_MAX);
return str;
}
-String
+String
String_convert::int2hex (int i, int length_i, char fill_char)
{
return unsigned2hex ((unsigned)i, length_i, fill_char);
Byte
String_convert::nibble2hex_byte (Byte byte)
{
- if ((byte & 0x0f) <= 9 )
+ if ((byte & 0x0f) <= 9)
return (byte & 0x0f) + '0';
else
return (byte & 0x0f) - 10 + 'a';
str = "0." + to_string ('0', -dot) + str;
else if (dot >= str.length ())
str += to_string ('0', dot - str.length ());
- else if (( dot > 0) && (dot < str.length ()))
+ else if ((dot > 0) && (dot < str.length ()))
str = str.left_string (dot) + "." + str.cut_string (dot, INT_MAX);
else
assert (0);
String
String_convert::pad_to (String s, int n)
{
- return s + to_string (' ' , max (n - s.length (), 0));
+ return s + to_string (' ', max (n - s.length (), 0));
}
return strh_.to_bytes ();
}
-
Byte *
String::get_bytes ()
{
Array<Accidental_entry> accidentals_;
Link_array<Spanner> ties_;
-
};
/*
if (from_same_octave != SCM_BOOL_F
&& recent_enough (bar_number, from_same_octave, laziness))
- {
- previous_alteration = from_same_octave;
- }
+ previous_alteration = from_same_octave;
else if (ignore_octave
&& from_other_octaves != SCM_BOOL_F
&& recent_enough (bar_number, from_other_octaves, laziness))
- {
- previous_alteration = from_other_octaves;
- }
+ previous_alteration = from_other_octaves;
else if (from_key_signature != SCM_BOOL_F)
- {
- previous_alteration = from_key_signature;
- }
+ previous_alteration = from_key_signature;
int num = 1;
if (is_tied (previous_alteration))
Side_position_interface::add_support (a, note_head);
if (Grob *stem = unsmob_grob (a->get_object ("stem")))
- {
- Side_position_interface::add_support (a, stem);
- }
+ Side_position_interface::add_support (a, stem);
a->set_parent (note_head, X_AXIS);
return a;
SCM key = scm_from_int (n);
SCM entry = scm_assq (key, accs);
if (entry == SCM_BOOL_F)
- {
- entry = SCM_EOL;
- }
+ entry = SCM_EOL;
else
entry = scm_cdr (entry);
Interval extent;
for (int i = 0; i < which->size (); i++)
- {
- extent.unite (which->elem (i)->extent (item_col, X_AXIS));
- }
+ extent.unite (which->elem (i)->extent (item_col, X_AXIS));
if (!extent.is_empty ())
{
}
for (int i = note_cols.size (); i--;)
- {
- heads.concat (extract_grob_array (note_cols[i], "note-heads"));
- }
+ heads.concat (extract_grob_array (note_cols[i], "note-heads"));
heads.default_sort ();
heads.uniq ();
Offset o (a->relative_coordinate (common[X_AXIS], X_AXIS),
a->relative_coordinate (common[Y_AXIS], Y_AXIS));
for (int i = boxes.size (); i--;)
- {
- boxes[i].translate (o);
- }
+ boxes[i].translate (o);
return boxes;
}
if (a == Y_AXIS
&& me_spanner
&& me_spanner->get_bound (LEFT)->break_status_dir () == CENTER)
- {
- me_spanner->warning (_ ("vertical alignment called before line-breaking. Only do cross-staff spanners with PianoStaff."));
- }
+ me_spanner->warning (_ ("vertical alignment called before line-breaking. Only do cross-staff spanners with PianoStaff."));
me->set_property ("positioning-done", SCM_BOOL_T);
* be placed after the rest.
*/
if (!ambitus_)
- {
- create_ambitus ();
- }
+ create_ambitus ();
}
void
Arpeggio_engraver::try_music (Music *m)
{
if (!arpeggio_event_)
- {
- arpeggio_event_ = m;
- }
+ arpeggio_event_ = m;
return true;
}
We can't catch local key items (accidentals) from Voice context,
see Local_key_engraver
*/
- {
- Side_position_interface::add_support (arpeggio_, info.grob ());
- }
+ Side_position_interface::add_support (arpeggio_, info.grob ());
}
void
Arpeggio_engraver::acknowledge_note_column (Grob_info info)
{
if (arpeggio_)
- {
- info.grob ()->set_object ("arpeggio", arpeggio_->self_scm ());
- }
+ info.grob ()->set_object ("arpeggio", arpeggio_->self_scm ());
}
void
Arpeggio_engraver::process_music ()
{
if (arpeggio_event_)
- {
- arpeggio_ = make_item ("Arpeggio", arpeggio_event_->self_scm ());
- }
+ arpeggio_ = make_item ("Arpeggio", arpeggio_event_->self_scm ());
}
void
SCM ad = me->get_property ("arpeggio-direction");
Direction dir = CENTER;
if (is_direction (ad))
- {
- dir = to_dir (ad);
- }
+ dir = to_dir (ad);
Stencil mol;
Font_metric *fm = Font_interface::get_default_font (me);
Auto_beam_engraver::end_beam ()
{
if (stems_->size () < 2)
- {
- junk_beam ();
- }
+ junk_beam ();
else
{
finished_beam_ = create_beam ();
}
-
void
Auto_beam_engraver::acknowledge_beam (Grob_info info)
{
(void)info;
check_bar_property ();
if (stems_)
- {
- end_beam ();
- }
+ end_beam ();
}
void
return r;
}
-
MAKE_SCHEME_CALLBACK (Axis_group_interface, group_extent_callback, 2);
SCM
Axis_group_interface::group_extent_callback (SCM element_smob, SCM scm_axis)
str = "|:";
if (str == "")
- {
- return Lookup::blank (Box (Interval (0, 0), Interval (-h / 2, h / 2)));
- }
+ return Lookup::blank (Box (Interval (0, 0), Interval (-h / 2, h / 2)));
else if (str == "|")
- {
- return thin;
- }
+ return thin;
else if (str == "|." || (h == 0 && str == ":|"))
{
m.add_at_edge (X_AXIS, LEFT, thick, 0, 0);
Beam_engraver::process_music ()
{
if (beam_ && !to_boolean (get_property ("allowBeamBreak")))
- {
- get_score_engraver ()->forbid_breaks ();
- }
+ get_score_engraver ()->forbid_breaks ();
if (start_ev_)
{
SCM entry = scm_assq (sym, alist);
if (scm_is_pair (entry))
- {
- return robust_scm2double (scm_cdr (entry), def);
- }
+ return robust_scm2double (scm_cdr (entry), def);
return def;
}
Direction d = DOWN;
do
- {
- score[d] /= max (count[d], 1);
- }
- while (flip (&d) != DOWN);
+ score[d] /= max (count[d], 1);
+ while (flip (&d) != DOWN)
+ ;
return score[LEFT] + score[RIGHT];
}
*/
if (fabs (dy / dx) > parameters->ROUND_TO_ZERO_SLOPE
&& sign (dy_damp) != sign (dy))
- {
- dem += parameters->DAMPING_DIRECTION_PENALTY;
- }
+ dem += parameters->DAMPING_DIRECTION_PENALTY;
dem += parameters->MUSICAL_DIRECTION_FACTOR *max (0.0, (fabs (dy) - fabs (dy_mus)));
return scm_to_double (s);
}
else
- {
- return 0.81;
- }
+ return 0.81;
}
/* Maximum beam_count. */
Direction d = LEFT;
do
- {
- splits[d].beamify (beat_length, subdivide);
- }
- while (flip (&d) != LEFT);
+ splits[d].beamify (beat_length, subdivide);
+ while (flip (&d) != LEFT)
+ ;
int middle_beams = (split ? 1
: min (splits[RIGHT].beam_extend_count (LEFT),
Real one_min_tj[4];
one_min_tj[0] = 1;
for (int i = 1; i < 4; i++)
- {
- one_min_tj[i] = one_min_tj[i - 1] * (1 - t);
- }
+ one_min_tj[i] = one_min_tj[i - 1] * (1 - t);
Real r = 0.0;
for (int j = 0; j < 4; j++)
Real one_min_tj[4];
one_min_tj[0] = 1;
for (int i = 1; i < 4; i++)
- {
- one_min_tj[i] = one_min_tj[i - 1] * (1 - t);
- }
+ one_min_tj[i] = one_min_tj[i - 1] * (1 - t);
Offset o;
for (int j = 0; j < 4; j++)
String str = pre_string
+ to_string ('\n')
- + to_string (' ', pre_string.length () + 1)
+ + to_string (' ', pre_string.length () + 1)
+ post_string;
return str;
}
int
-Binary_source_file::get_line (char const* pos_str0) const
+Binary_source_file::get_line (char const *pos_str0) const
{
if (!contains (pos_str0))
return 0;
U8
Binary_source_file::get_U8 ()
{
- return * (U8*)forward_str0 (1);
+ return *(U8 *)forward_str0 (1);
}
-
U16
Binary_source_file::get_U16 ()
{
}
/* Concatenate all score outputs into a Paper_book
-
-*/
+ */
Paper_book *
Book::process (Output_def *default_paper,
Output_def *default_layout)
sort out how interfacing this should work;
*/
if (line.is_empty ())
- {
- sp->line_len_ = -1;
- }
+ sp->line_len_ = -1;
else
sp->line_len_ = line.length ();
Item *item = dynamic_cast<Item *> (me);
Direction bsd = item->break_status_dir ();
if (bsd == LEFT)
- {
- me->set_property ("self-alignment-X", scm_from_int (RIGHT));
- }
+ me->set_property ("self-alignment-X", scm_from_int (RIGHT));
/*
Force break alignment itself to be done first, in the case
return;
if (me->break_status_dir () == LEFT)
- {
- alignment_off = -total_extent[RIGHT] - extra_right_space;
- }
+ alignment_off = -total_extent[RIGHT] - extra_right_space;
else if (edge_idx < 0)
alignment_off = -total_extent[LEFT];
new_grobs->set_size (ptr - array);
if (new_arr == grob_arr)
- {
- new_arr->set_array (*new_grobs);
- }
+ new_arr->set_array (*new_grobs);
}
/*
Slice rv;
if (System *st = sp->get_system ())
- {
- rv = Slice (st->get_rank (), st->get_rank ());
- }
+ rv = Slice (st->get_rank (), st->get_rank ());
else
{
if (sp->broken_intos_.size ())
Real thickness = Staff_symbol_referencer::line_thickness (me);
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
if (Staff_symbol_referencer::get_staff_symbol (me))
- {
- staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
- }
+ staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
else
staff_size = 0.0;
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
if (Staff_symbol_referencer::get_staff_symbol (me))
- {
- staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
- }
+ staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
else
staff_size = 0.0;
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
if (Staff_symbol_referencer::get_staff_symbol (me))
- {
- staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
- }
+ staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
else
staff_size = 0.0;
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
if (Staff_symbol_referencer::get_staff_symbol (me))
- {
- staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
- }
+ staff_size = (Staff_symbol_referencer::line_count (me) - 1) * staff_space;
else
staff_size = 0.0;
int elt_count = body_is_sequential_ ? scm_ilength (body->get_property ("elements")) : 1;
if (body_is_sequential_ && elt_count != 2)
- {
- m->origin ()->warning (_f ("expect 2 elements for chord tremolo, found %d", elt_count));
- }
+ m->origin ()->warning (_f ("expect 2 elements for chord tremolo, found %d", elt_count));
if (elt_count <= 0)
elt_count = 1;
Stem::set_beaming (s, flags_, LEFT);
if (Stem::duration_log (s) != 1)
- {
- beam_->set_property ("gap-count", scm_from_int (flags_ - total_duration_flags_));
- }
+ beam_->set_property ("gap-count", scm_from_int (flags_ - total_duration_flags_));
if (info.music_cause ()->is_mus_type ("rhythmic-event"))
Beam::add_stem (beam_, s);
{
Item *item = dynamic_cast<Item *> (info.grob ());
if (item && scm_is_string (get_property ("clefGlyph")))
- {
- create_clef ();
- }
+ create_clef ();
}
void
{
SCM vis = 0;
if (to_boolean (clef_->get_property ("non-default")))
- {
- vis = get_property ("explicitClefVisibility");
- }
+ vis = get_property ("explicitClefVisibility");
if (vis)
{
clef_->set_property ("break-visibility", vis);
if (octavate_)
- {
- octavate_->set_property ("break-visibility", vis);
- }
+ octavate_->set_property ("break-visibility", vis);
}
clef_ = 0;
}
if (beacon_ && !spanner_)
- {
- spanner_ = make_spanner ("ClusterSpanner", cluster_notes_[0]->self_scm ());
- }
+ spanner_ = make_spanner ("ClusterSpanner", cluster_notes_[0]->self_scm ());
if (beacon_ && spanner_)
{
String shape;
if (scm_is_symbol (shape_scm))
- {
- shape = ly_symbol2string (shape_scm);
- }
+ shape = ly_symbol2string (shape_scm);
else
{
programming_error ("#'style should be symbol.");
out.add_stencil (Lookup::round_filled_polygon (points, blotdiameter));
}
else
- {
- me->warning (_f ("unknown cluster style `%s'", shape.to_str0 ()));
- }
+ me->warning (_f ("unknown cluster style `%s'", shape.to_str0 ()));
return out;
}
ly_display_scm (lc->self_scm ());
Real distance;
if (incr_scm != SCM_EOL)
- {
- distance = scm_to_double (incr_scm);
- }
+ distance = scm_to_double (incr_scm);
else
{
me->warning (_ ("distance undefined, assuming 0.1"));
}
}
else
- {
- get_set_column (parent, column);
- }
+ get_set_column (parent, column);
}
/*
if (col_ || note_columns_.size () < 2)
return;
if (!col_)
- {
- col_ = make_item ("NoteCollision", SCM_EOL);
- }
+ col_ = make_item ("NoteCollision", SCM_EOL);
for (int i = 0; i < note_columns_.size (); i++)
Note_collision_interface::add_column (col_, note_columns_[i]);
#include "duration.hh"
#include "pitch.hh"
-
/*
TODO: make matching rest engraver.
*/
return true;
}
else if (m->is_mus_type ("busy-playing-event"))
- {
- return note_events_.size () && is_first_;
- }
+ return note_events_.size () && is_first_;
return false;
}
Duration note_dur;
Duration *orig = 0;
if (left_to_do_)
- {
- note_dur = find_nearest_duration (left_to_do_);
- }
+ note_dur = find_nearest_duration (left_to_do_);
else
{
orig = unsmob_duration (note_events_[0]->get_property ("duration"));
}
if (orig)
- {
- left_to_do_ = orig->get_length ();
- }
+ left_to_do_ = orig->get_length ();
if (orig && note_dur.get_length () != orig->get_length ())
{
*/
if (orig
&& now_mom ().grace_part_)
- {
- left_to_do_ = Rational (0, 0);
- }
+ left_to_do_ = Rational (0, 0);
}
void
dots_.clear ();
for (int i = scratch_note_events_.size (); i--;)
- {
- scratch_note_events_[i]->unprotect ();
- }
+ scratch_note_events_[i]->unprotect ();
scratch_note_events_.clear ();
}
sym = scm_string_to_symbol (sym);
if (ly_symbol2scm ("default-child") == tag)
- {
- default_child_ = sym;
- }
+ default_child_ = sym;
else if (ly_symbol2scm ("consists") == tag
|| ly_symbol2scm ("consists-end") == tag
|| ly_symbol2scm ("remove") == tag)
SCM based_on = scm_cdr (props);
if (based_on == daddy_props)
- {
- return scm_car (props);
- }
+ return scm_car (props);
else
{
SCM copy = daddy_props;
int disambiguation_count = 0;
if (context_counts_.find (now_key) != context_counts_.end ())
- {
- disambiguation_count = context_counts_[now_key];
- }
+ disambiguation_count = context_counts_[now_key];
context_counts_[now_key] = disambiguation_count + 1;
int disambiguation_count = 0;
if (grob_counts_.find (name) != grob_counts_.end ())
- {
- disambiguation_count = grob_counts_[name];
- }
+ disambiguation_count = grob_counts_[name];
grob_counts_[name] = disambiguation_count + 1;
Object_key *k = new Lilypond_grob_key (get_key (),
{
#ifndef NDEBUG
if (profile_property_accesses)
- {
- note_property_access (&context_property_lookup_table, sym);
- }
+ note_property_access (&context_property_lookup_table, sym);
#endif
if (properties_dict ()->try_retrieve (sym, value))
- {
- return (Context *)this;
- }
+ return (Context *)this;
return (daddy_context_) ? daddy_context_->where_defined (sym, value) : 0;
}
{
#ifndef NDEBUG
if (profile_property_accesses)
- {
- note_property_access (&context_property_lookup_table, sym);
- }
+ note_property_access (&context_property_lookup_table, sym);
#endif
SCM val = SCM_EOL;
{
Context const *p = this;
while (p->daddy_context_)
- {
- p = p->daddy_context_;
- }
+ p = p->daddy_context_;
return p->now_mom ();
}
grob_counts_.clear ();
context_counts_.clear ();
for (SCM s = context_list_; scm_is_pair (s); s = scm_cdr (s))
- {
- unsmob_context (scm_car (s))->clear_key_disambiguations ();
- }
+ unsmob_context (scm_car (s))->clear_key_disambiguations ();
}
/*
Custos_engraver::finalize ()
{
for (int i = custodes_.size (); i--;)
- {
- custodes_[i]->suicide ();
- }
+ custodes_[i]->suicide ();
custodes_.clear ();
}
SCM scm_style = me->get_property ("style");
String style;
if (scm_is_symbol (scm_style))
- {
- style = ly_symbol2string (scm_style);
- }
+ style = ly_symbol2string (scm_style);
else
- {
- style = "mensural";
- }
+ style = "mensural";
/*
* Shall we use a common custos font character regardless if on
font_char += "d";
if (adjust)
- {
- font_char += (((pos ^ sz) & 0x1) == 0) ? "1" : "0";
- }
+ font_char += (((pos ^ sz) & 0x1) == 0) ? "1" : "0";
else
- {
- font_char += "2";
- }
+ font_char += "2";
Stencil stencil
= Font_interface::get_default_font (me)->find_by_name (font_char);
if (d)
{
if (!dotcol_)
- {
- dotcol_ = make_item ("DotColumn", SCM_EOL);
- }
+ dotcol_ = make_item ("DotColumn", SCM_EOL);
Dot_column::add_head (dotcol_, info.grob ());
}
for (Dot_configuration::const_iterator i (cfg.begin ());
i != cfg.end (); i++)
- {
- Staff_symbol_referencer::set_position (i->second.dot_, i->first);
- }
+ Staff_symbol_referencer::set_position (i->second.dot_, i->first);
return SCM_UNSPECIFIED;
}
// --> grace notes effectively do not get delayed
Moment now = now_mom ();
for (int i = 0; i < notes_.size (); i++)
- {
- play_element (notes_[i]);
- }
+ play_element (notes_[i]);
notes_.clear ();
note_evs_.clear ();
}
Dynamic_engraver::acknowledge_slur (Grob_info info)
{
if (line_spanner_)
- {
- Side_position_interface::add_support (line_spanner_, info.grob ());
- }
+ Side_position_interface::add_support (line_spanner_, info.grob ());
}
void
}
if (finished_cresc_ && !finished_cresc_->get_bound (RIGHT))
- {
- finished_cresc_->set_bound (RIGHT, info.grob ());
- }
+ finished_cresc_->set_bound (RIGHT, info.grob ());
}
void
charstr = scm_makfrom0str (s);
}
-
SCM letter
- = Text_interface::interpret_string (me->get_layout()->self_scm (),
+ = Text_interface::interpret_string (me->get_layout ()->self_scm (),
Font_interface::text_font_alist_chain (me),
charstr);
-
+
Stencil l (*unsmob_stencil (letter));
l.align_to (X_AXIS, CENTER);
l.align_to (Y_AXIS, CENTER);
-
- l = Stencil (Box (), l.expr ());
+ l = Stencil (Box (), l.expr ());
Real ss = Staff_symbol_referencer::staff_space (me);
Real lt = Staff_symbol_referencer::line_thickness (me);
Real radius = (ss + lt) / 2.0;
- Real stem_thick = 1.3 * lt;
+ Real stem_thick = 1.3 * lt;
if (Grob *stem = unsmob_grob (me->get_object ("stem")))
- {
- stem_thick = Stem::thickness (stem);
- }
+ stem_thick = Stem::thickness (stem);
int black = (log >= 2);
SCM_BOOL_T));
Stencil white_head;
if (black)
- {
- l = l.in_color (1, 1, 1);
- }
+ l = l.in_color (1, 1, 1);
else
{
white_head = Stencil (extent,
/* read */ "",
/* write */ "");
-
void
Engraver_group_engraver::derived_mark () const
{
map_file_name (String s)
{
if (file_name_map_global.find (s) != file_name_map_global.end ())
- {
- s = file_name_map_global[s];
- }
+ s = file_name_map_global[s];
return s;
}
Fingering_engraver::acknowledge_stem (Grob_info inf)
{
for (int i = 0; i < fingerings_.size (); i++)
- {
- Side_position_interface::add_support (fingerings_[i], inf.grob ());
- }
+ Side_position_interface::add_support (fingerings_[i], inf.grob ());
}
void
Folded_repeat_iterator::pending_moment () const
{
if (main_iter_)
- {
- return main_iter_->pending_moment ();
- }
+ return main_iter_->pending_moment ();
else
return main_length_mom_ + alternative_iter_->pending_moment ();
}
}
if (!main_iter_ && !alternative_iter_)
- {
- enter_alternative ();
- }
+ enter_alternative ();
if (alternative_iter_)
{
Folded_repeat_iterator::try_music_in_children (Music *m) const
{
if (main_iter_)
- {
- return main_iter_->try_music (m);
- }
+ return main_iter_->try_music (m);
if (alternative_iter_)
return alternative_iter_->try_music (m);
return 0;
if (!FcInit ())
error (_ ("initializing FontConfig failed"));
-
font_config_global = FcConfigGetCurrent ();
Array<String> dirs;
struct stat statbuf;
#endif
}
else
- {
- fm = unsmob_metrics (scm_force (scm_c_vector_ref (font_vector, i)));
- }
+ fm = unsmob_metrics (scm_force (scm_c_vector_ref (font_vector, i)));
return find_scaled_font (layout, fm, requested / size);
}
#if HAVE_PANGO_FT2
if (scm_is_string (name)
&& is_pango_format_global)
- {
- return select_pango_font (layout, chain);
- }
+ return select_pango_font (layout, chain);
else
#endif
if (scm_is_string (name))
SCM lst = SCM_EOL;
int output_formats_count = output_formats.size ();
- for (int i = 0; i < output_formats_count; i ++)
+ for (int i = 0; i < output_formats_count; i++)
lst = scm_cons (scm_makfrom0str (output_formats[i].to_str0 ()), lst);
return lst;
char *p = buf;
if (wide_char < 0x0080)
- {
- *p++ = (char)wide_char;
- }
+ *p++ = (char)wide_char;
else if (wide_char < 0x0800)
{
*p++ = (char) (((wide_char >> 6)) | 0xC0);
Glissando_engraver::process_music ()
{
if (event_)
- {
- line_ = make_spanner ("Glissando", event_->self_scm ());
- }
+ line_ = make_spanner ("Glissando", event_->self_scm ());
}
void
Glissando_engraver::stop_translation_timestep ()
{
if (last_line_ && last_line_->get_bound (RIGHT))
- {
- last_line_ = 0;
- }
+ last_line_ = 0;
if (line_)
{
if (last_line_)
Context_def *globaldef = unsmob_context_def (definition_);
if (!globaldef)
- {
- programming_error ("no `Global' context found");
- }
+ programming_error ("no `Global' context found");
else
globaldef->apply_default_property_operations (this);
accepts_list_ = scm_list_1 (ly_symbol2scm ("Score"));
if (prefix_set & PES_OR_FLEXA)
if (!i) // ligature may not start with 2nd head of pes or flexa
- {
- primitive->warning (_ ("can't apply `\\~' on first head of ligature"));
- }
+ primitive->warning (_ ("can't apply `\\~' on first head of ligature"));
else if (pitch > prev_pitch) // pes
{
prev_context_info |= PES_LOWER;
context_info |= FLEXA_RIGHT;
}
else // (pitch == prev_pitch)
- {
- primitive->warning (_ ("can't apply `\\~' on heads with identical pitch"));
- }
+ primitive->warning (_ ("can't apply `\\~' on heads with identical pitch"));
if (prev_prefix_set & DEMINUTUM)
context_info |= AFTER_DEMINUTUM;
Moment now = now_mom ();
if (!now.main_part_.mod_rat (mom->main_part_))
- {
- make_item ("GridPoint", SCM_EOL);
- }
+ make_item ("GridPoint", SCM_EOL);
}
}
SCM arr_scm = Grob_array::make_array ();
Grob_array *ga = unsmob_grob_array (arr_scm);
for (SCM s = lst; scm_is_pair (s); s = scm_cdr (s))
- {
- ga->add (unsmob_grob (scm_car (s)));
- }
+ ga->add (unsmob_grob (scm_car (s)));
return arr_scm;
}
SCM start_busy = get_property ("busyGrobs");
SCM busy = start_busy;
while (scm_is_pair (busy) && *unsmob_moment (scm_caar (busy)) == now)
- {
- busy = scm_cdr (busy);
- }
+ busy = scm_cdr (busy);
started_now_.sort (Grob_pq_entry::compare);
SCM lst = SCM_EOL;
= scm_sloppy_assq (sym, mutable_property_alist_);
if (handle != SCM_BOOL_F)
- {
- scm_set_cdr_x (handle, scm_cons (thing, scm_cdr (handle)));
- }
+ scm_set_cdr_x (handle, scm_cons (thing, scm_cdr (handle)));
else
{
/*
}
}
-
extern void check_interfaces_for_property (Grob const *me, SCM sym);
void
//#define PROFILE_PROPERTY_ACCESSES
-
SCM
Grob::internal_get_property (SCM sym) const
{
#ifndef NDEBUG
if (profile_property_accesses)
- {
- note_property_access (&grob_property_lookup_table, sym);
- }
+ note_property_access (&grob_property_lookup_table, sym);
#endif
SCM s = scm_sloppy_assq (sym, mutable_property_alist_);
return (s == SCM_BOOL_F) ? SCM_EOL : scm_cdr (s);
}
-
void
Grob::internal_set_object (SCM s, SCM v)
{
return me->get_key ()->self_scm ();
}
-
LY_DEFINE (ly_grob_default_font, "ly:grob-default-font",
1, 0, 0, (SCM grob),
"Return the default font for grob @var{gr}.")
We always get a new key object for a new grob.
*/
if (key_)
- {
- ((Object_key *)key_)->unprotect ();
- }
+ ((Object_key *)key_)->unprotect ();
SCM meta = get_property ("meta");
if (scm_is_pair (meta))
- {
- interfaces_ = scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta));
- }
+ interfaces_ = scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta));
/* TODO:
smobify_self ();
if (key_)
- {
- ((Object_key *)key_)->unprotect ();
- }
+ ((Object_key *)key_)->unprotect ();
}
Grob::~Grob ()
{
Interval ext = me->extent (refp, a);
if (ext.is_empty ())
- {
- ext.add_point (me->relative_coordinate (refp, a));
- }
+ ext.add_point (me->relative_coordinate (refp, a));
return ext;
}
if (broken[LEFT]
&& ly_is_equal (bounds[RIGHT]->get_column ()->get_property ("when"),
bounds[LEFT]->get_property ("when")))
- {
- me->suicide ();
- }
+ me->suicide ();
return SCM_UNSPECIFIED;
}
if (!to_boolean (me->get_property ("remove-first"))
&& broken_spanner_index (sp) == 0)
- {
- return;
- }
+ return;
Link_array<Grob> childs;
Axis_group_interface::get_children (me, &childs);
Hyphen_engraver::process_music ()
{
if (ev_)
- {
- hyphen_ = make_spanner ("LyricHyphen", ev_->self_scm ());
- }
+ hyphen_ = make_spanner ("LyricHyphen", ev_->self_scm ());
}
void
Hyphen_engraver::stop_translation_timestep ()
{
if (finished_hyphen_ && finished_hyphen_->get_bound (RIGHT))
- {
- finished_hyphen_ = 0;
- }
+ finished_hyphen_ = 0;
if (finished_hyphen_ && hyphen_)
{
*/
SCM interfaces_;
-
/* BARF */
friend class Spanner;
friend SCM ly_grob_properties (SCM);
inline bool ly_is_pair (SCM x) { return SCM_I_CONSP (x); }
-
#endif /* LILY_GUILE_HH */
typedef void (*Translator_void_method_ptr) (Translator *);
-
#endif /* LILY_PROTO_HH */
#define extract_item_set(grob, prop, set) \
Link_array<Item> set (internal_extract_item_array (grob, ly_symbol2scm (prop)))
-
#endif /* POINTER_GROUP_INTERFACE_HH */
SCM ly_get_option (SCM);
SCM ly_set_option (SCM, SCM);
-
#endif /* SCM_OPTION_HH */
void precomputed_recurse_over_translators (Context *c, Translator_precompute_index idx, Direction dir);
Translator_group *get_translator_group (SCM sym);
-#define ADD_TRANSLATOR_GROUP(classname, desc, grobs, accepted, read, write)
+#define foobar
+#define ADD_TRANSLATOR_GROUP(classname, desc, grobs, accepted, read, write) foobar
DECLARE_UNSMOB (Translator_group, translator_group);
ADD_SCM_INIT_FUNC (CLASS ## NAME ## _ack_adder_initclass, CLASS ## NAME ## _ack_adder);
-
#endif /* TRANSLATOR_ICC */
(void)info;
SCM c = get_property ("createKeyOnClefChange");
if (to_boolean (c))
- {
- create_key (false);
- }
+ create_key (false);
}
void
{
(void)info;
if (scm_is_pair (get_property ("keySignature")))
- {
- create_key (true);
- }
+ create_key (true);
}
void
Key_performer::try_music (Music *ev)
{
if (!key_ev_)
- {
- key_ev_ = ev;
- }
+ key_ev_ = ev;
return true;
}
SCM scm_style = me->get_property ("style");
String style;
if (scm_is_symbol (scm_style))
- {
- style = ly_symbol2string (scm_style);
- }
+ style = ly_symbol2string (scm_style);
else
- {
- style = "";
- }
+ style = "";
SCM newas = me->get_property ("alteration-alist");
Stencil mol;
Stencil acc (fm->find_by_name ("accidentals." + font_char));
if (acc.is_empty ())
- {
- me->warning (_f ("accidental `%s' not found", font_char));
- }
+ me->warning (_f ("accidental `%s' not found", font_char));
else
{
SCM what = scm_caar (s);
Keyword_table::Keyword_table (Keyword_ent *tab)
{
while (tab->name_)
- {
- table_.push (*tab++);
- }
+ table_.push (*tab++);
table_.sort (tabcmp);
}
}
if (!last_bound_)
- {
- events_drul_[STOP]->origin ()->warning (_ ("no right bound"));
- }
+ events_drul_[STOP]->origin ()->warning (_ ("no right bound"));
else
ligature_->set_bound (RIGHT, last_bound_);
brew_ligature_primitive_proc
= ligature_->get_property ("ligature-primitive-callback");
if (brew_ligature_primitive_proc == SCM_EOL)
- {
- programming_error ("Ligature_engraver: ligature-primitive-callback undefined");
- }
+ programming_error ("Ligature_engraver: ligature-primitive-callback undefined");
Grob *bound = unsmob_grob (get_property ("currentMusicalColumn"));
if (!bound)
- {
- events_drul_[START]->origin ()->warning (_ ("no left bound"));
- }
+ events_drul_[START]->origin ()->warning (_ ("no left bound"));
else
ligature_->set_bound (LEFT, bound);
if (lenp)
*lenp = len;
-
+
return new_str;
}
return 0;
SCM
index_get_cell (SCM s, Direction d)
{
-
+
assert (d);
return (d == LEFT) ? scm_car (s) : scm_cdr (s);
}
scm_set_cdr_x (s, v);
return s;
}
-
+
bool
is_number_pair (SCM p)
{
return src;
}
-
/* looks the key up in the cdrs of the alist-keys
- ignoring the car and ignoring non-pair keys.
Returns first match found, i.e.
{
SCM x = SCM_EOL;
for (SCM p = alist; scm_is_pair (p); p = scm_cdr (p))
- {
- x = scm_cons (scm_cdar (p), x);
- }
+ x = scm_cons (scm_cdar (p), x);
return x;
}
start_module_ = scm_current_module ();
for (SCM s = scopes_; scm_is_pair (s); s = scm_cdr (s))
- {
- ly_use_module (module, scm_car (s));
- }
+ ly_use_module (module, scm_car (s));
scopes_ = scm_cons (module, scopes_);
set_current_scope ();
Input
Lily_lexer::here_input () const
{
- return Input(*lexloc);
+ return Input (*lexloc);
}
void
Lily_parser::parse_file (String init, String name, String out_name)
{
if (output_backend_global == "tex")
- {
- try_load_text_metrics (out_name);
- }
+ try_load_text_metrics (out_name);
// TODO: use $parser
lexer_->set_identifier (ly_symbol2scm ("parser"),
{
Array<String> version;
version = String_convert::split (str, '.');
-
+
major_ = version[0].to_int ();
minor_ = version[1].to_int ();
patch_ = 0;
Real off = dash_period - on;
for (int i = 4; i--;)
- {
- l = scm_cons (ly_offset2scm (b.control_[i]), l);
- }
+ l = scm_cons (ly_offset2scm (b.control_[i]), l);
SCM at = (scm_list_n (ly_symbol2scm ("dashed-slur"),
scm_from_double (thick),
Lookup::round_filled_box (Box b, Real blotdiameter)
{
if (b.x ().length () < blotdiameter)
- {
- blotdiameter = b.x ().length ();
- }
+ blotdiameter = b.x ().length ();
if (b.y ().length () < blotdiameter)
- {
- blotdiameter = b.y ().length ();
- }
+ blotdiameter = b.y ().length ();
SCM at = (scm_list_n (ly_symbol2scm ("round-filled-box"),
scm_from_double (-b[X_AXIS][LEFT]),
int indices[] = {5, 6, 7, 4, 1, 2, 3, 0};
SCM list = SCM_EOL;
for (int i = 8; i--;)
- {
- list = scm_cons (scontrols[indices[i]], list);
- }
+ list = scm_cons (scontrols[indices[i]], list);
SCM at = (scm_list_n (ly_symbol2scm ("bezier-sandwich"),
ly_quote_scm (list),
Offset p1 (0, 0);
Offset p2 (w, w * s);
-
return Lookup::round_filled_polygon (points, blotdiameter);
#endif
#define FUNC_NAME __FUNCTION__
-
static SCM
accumulate_symbol (void *closure, SCM key, SCM val, SCM result)
{
ly_export (mod, ly_module_symbols (mod));
}
-
#ifdef MODULE_GC_KLUDGE
static SCM
redefine_keyval (void *closure, SCM key, SCM val, SCM result)
#endif
#ifdef __MINGW32__
-# include <winbase.h>
+#include <winbase.h>
#endif
static void
-setup_paths (char const* argv0)
+setup_paths (char const *argv0)
{
prefix_directory = LILYPOND_DATADIR;
struct stat statbuf;
String builddir = prefix_directory + "/mf/out/";
if (stat (builddir.to_str0 (), &statbuf) == 0)
- {
- dirs.push (builddir.to_str0 ());
- }
+ dirs.push (builddir.to_str0 ());
else
{
dirs.push (prefix_directory + "/fonts/otf/");
}
#endif
-
static void
main_with_guile (void *, int, char **)
{
warranty ();
exit (0);
break;
-
+
case 'b':
output_backend_global = option_parser->optional_argument_str0_;
break;
case 'f':
output_format_global = option_parser->optional_argument_str0_;
break;
-
+
case 'H':
dump_header_fieldnames_global
.push (option_parser->optional_argument_str0_);
Measure_grouping_engraver::acknowledge_note_column (Grob_info gi)
{
if (grouping_)
- {
- Side_position_interface::add_support (grouping_, gi.grob ());
- }
+ Side_position_interface::add_support (grouping_, gi.grob ());
}
void
TODO: use line interface
*/
if (which == ly_symbol2scm ("bracket"))
- {
- m = Lookup::bracket (X_AXIS, iv, t, -height, t);
- }
+ m = Lookup::bracket (X_AXIS, iv, t, -height, t);
else if (which == ly_symbol2scm ("triangle"))
- {
- m = Lookup::triangle (iv, t, height);
- }
+ m = Lookup::triangle (iv, t, height);
m.align_to (Y_AXIS, DOWN);
m.translate_axis (- me->relative_coordinate (common, X_AXIS), X_AXIS);
Melisma_translator::try_music (Music *m)
{
if (m->is_mus_type ("melisma-playing-event"))
- {
- return melisma_busy (context ());
- }
+ return melisma_busy (context ());
else if (m->is_mus_type ("melisma-span-event"))
{
event_ = m;
Real width = 0.0;
Real staff_space = Staff_symbol_referencer::staff_space (me);
if (primitive & MLP_ANY)
- {
- thickness = robust_scm2double (me->get_property ("thickness"), .14);
- }
+ thickness = robust_scm2double (me->get_property ("thickness"), .14);
if (primitive & MLP_FLEXA)
{
= robust_scm2double (me->get_property ("flexa-width"), 2.0 * staff_space);
}
if (primitive & MLP_SINGLE_HEAD)
- {
- width = robust_scm2double (me->get_property ("head-width"), staff_space);
- }
+ width = robust_scm2double (me->get_property ("head-width"), staff_space);
switch (primitive & MLP_ANY)
{
out.add_stencil (join);
}
else
- {
- programming_error (_f ("Mensural_ligature: (join_right == 0)"));
- }
+ programming_error (_f ("Mensural_ligature: (join_right == 0)"));
}
#if 0 /* what happend with the ledger lines? */
wholes_per_min /= 4;
}
else
- {
- wholes_per_min /= *w;
- }
+ wholes_per_min /= *w;
int beats_per_min = int ((wholes_per_min / one_beat_mom).main_part_);
return int (beats_per_min);
String format_string = String_convert::int2hex (format_i, 4, '0');
str += String_convert::hex2bin (format_string);
-
+
String tracks_string = String_convert::int2hex (tracks_i, 4, '0');
str += String_convert::hex2bin (tracks_string);
return String_convert::hex2bin (str);
}
-Midi_time_signature::Midi_time_signature (Audio_time_signature* a)
+Midi_time_signature::Midi_time_signature (Audio_time_signature *a)
{
audio_ = a;
clocks_per_1_ = 18;
String str = "ff5804";
str += String_convert::int2hex (num, 2, '0');
- str += String_convert::int2hex (intlog2 (den) , 2, '0');
+ str += String_convert::int2hex (intlog2 (den), 2, '0');
str += String_convert::int2hex (clocks_per_1_, 2, '0');
str += String_convert::int2hex (8, 2, '0');
return String_convert::hex2bin (str);
}
-Midi_note::Midi_note (Audio_note* a)
+Midi_note::Midi_note (Audio_note *a)
{
audio_ = a;
dynamic_byte_ = 0x7f;
return String_convert::hex2bin (str);
}
-Midi_text::Midi_text (Audio_text* a)
+Midi_text::Midi_text (Audio_text *a)
{
audio_ = a;
}
return operator << (str);
}
-Midi_stream&
+Midi_stream &
Midi_stream::operator << (int i)
{
// output binary string ourselves
start with graces
*/
if (delta_t < Moment (0))
- {
- delta_t = Moment (0);
- }
+ delta_t = Moment (0);
track_->add (delta_t, l);
}
/* Accent marks use width of base letter */
if (i +1 < text.length ())
{
- if (text[i + 1]=='\'' || text[i + 1]=='`' || text[i+1]=='"'
- || text[i+1]=='^')
+ if (text[i + 1]=='\'' || text[i + 1]=='`' || text[i + 1]=='"'
+ || text[i + 1]=='^')
{
i++;
break;
}
/* For string width \\ is a \ and \_ is a _. */
- if (text[i + 1]=='\\' || text[i+1]=='_')
+ if (text[i + 1]=='\\' || text[i + 1]=='_')
break;
}
-
- for (i++; (i < text.length ()) && !isspace (text[i])
+
+ for (i++; (i < text.length ()) && !isspace (text[i])
&& text[i]!='{' && text[i]!='}'; i++)
;
-
+
/* Compensate for the auto-increment in the outer loop. */
i--;
break;
- case '{': // Skip '{' and '}'
+ case '{': // Skip '{' and '}'
case '}':
break;
-
- default:
+
+ default:
Box b = get_ascii_char ((unsigned char)text[i]);
-
+
/* Use the width of 'x' for unknown characters */
if (b[X_AXIS].length () == 0)
b = get_ascii_char ((unsigned char)'x');
-
+
w += b[X_AXIS].length ();
ydims.unite (b[Y_AXIS]);
break;
}
}
-
+
if (ydims.is_empty ())
ydims = Interval (0, 0);
-
+
return Box (Interval (0, w), ydims);
}
Stencil
Modified_font_metric::text_stencil (String text) const
{
- Box b;
- if (Pango_font * pf = dynamic_cast<Pango_font*> (orig_))
+ Box b;
+ if (Pango_font *pf = dynamic_cast<Pango_font *> (orig_))
{
Stencil stc = pf->text_stencil (text);
Box b = stc.extent_box ();
b.scale (magnification_);
- Stencil scaled(b, stc.expr());
+ Stencil scaled (b, stc.expr ());
return scaled;
}
Box b = lookup_tex_text_dimension (orig_, stext);
if (!b[Y_AXIS].is_empty ())
{
- b.scale (magnification_);
+ b.scale (magnification_);
return b;
}
{
String s = main_part_.to_string ();
if (grace_part_)
- {
- s += "G" + grace_part_.to_string ();
- }
+ s += "G" + grace_part_.to_string ();
return s;
}
Multi_measure_rest_engraver::start_translation_timestep ()
{
if (now_mom ().main_part_ >= stop_moment_.main_part_)
- {
- rest_ev_ = 0;
- }
+ rest_ev_ = 0;
Moment mp (robust_scm2moment (get_property ("measurePosition"), Moment (0)));
SCM sml = get_property ("measureLength");
Rational ml = (unsmob_moment (sml)) ? unsmob_moment (sml)->main_part_ : Rational (1);
if (ml >= Rational (2))
- {
- last_rest_->set_property ("use-breve-rest", SCM_BOOL_T);
- }
+ last_rest_->set_property ("use-breve-rest", SCM_BOOL_T);
mmrest_ = 0;
numbers_.clear ();
int measures = 0;
SCM m (me->get_property ("measure-count"));
if (scm_is_number (m))
- {
- measures = scm_to_int (m);
- }
+ measures = scm_to_int (m);
mol.translate_axis (x_off, X_AXIS);
return mol.smobbed_copy ();
int measures = 0;
SCM m (me->get_property ("measure-count"));
if (scm_is_number (m))
- {
- measures = scm_to_int (m);
- }
+ measures = scm_to_int (m);
if (measures <= 0)
return Stencil ();
}
}
else
- {
- return church_rest (me, musfont, measures, space);
- }
+ return church_rest (me, musfont, measures, space);
}
/*
is_child_context (Context *me, Context *child)
{
while (child && child != me)
- {
- child = child->get_parent_context ();
- }
+ child = child->get_parent_context ();
return child == me;
}
bool ok = type_check_assignment (sym, val, ly_symbol2scm ("music-type?"));
if (ok)
- {
- sc->internal_set_property (sym, val);
- }
+ sc->internal_set_property (sym, val);
return SCM_UNSPECIFIED;
}
Moment m;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- {
- m = min (m, unsmob_music (scm_car (s))->start_mom ());
- }
+ m = min (m, unsmob_music (scm_car (s))->start_mom ());
return m;
}
{
SCM nm = get_property ("name");
if (scm_is_symbol (nm))
- {
- return ly_symbol2string (nm);
- }
+ return ly_symbol2string (nm);
else
- {
- return classname (this);
- }
+ return classname (this);
}
Music::Music (SCM init)
length_callback_ = get_property ("length-callback");
if (!ly_is_procedure (length_callback_))
- {
- length_callback_ = duration_length_callback_proc;
- }
+ length_callback_ = duration_length_callback_proc;
start_callback_ = get_property ("start-callback");
}
*/
SCM pa = get_property ("pitch-alist");
if (scm_is_pair (pa))
- {
- set_property ("pitch-alist", ly_transpose_key_alist (pa, delta.smobbed_copy ()));
- }
+ set_property ("pitch-alist", ly_transpose_key_alist (pa, delta.smobbed_copy ()));
}
IMPLEMENT_TYPE_P (Music, "ly:music?");
Moment mom;
if (d)
- {
- mom = d->get_length ();
- }
+ mom = d->get_length ();
return mom.smobbed_copy ();
}
if (m->is_mus_type ("fingering-event"))
add_fingering (inf.grob (), m, note_ev);
else if (m->is_mus_type ("text-script-event"))
- {
- m->origin ()->warning (_ ("can't add text scripts to individual note heads"));
- }
+ m->origin ()->warning (_ ("can't add text scripts to individual note heads"));
else if (m->is_mus_type ("script-event"))
add_script (inf.grob (), m, note_ev);
else if (m->is_mus_type ("string-number-event"))
positioning the fingerings, setting both X and Y coordinates.
*/
for (int i = 0; i < scripts->size (); i++)
- {
- (*scripts)[i].position_ = scm_to_int ((*scripts)[i].head_->get_property ("staff-position"));
- }
+ (*scripts)[i].position_ = scm_to_int ((*scripts)[i].head_->get_property ("staff-position"));
for (int i = scripts->size (); i--;)
for (int j = heads_.size (); j--;)
}
for (int i = 0; i < amounts.size (); i++)
- {
- done[i]->translate_axis (amounts[i] - left_most, X_AXIS);
- }
+ done[i]->translate_axis (amounts[i] - left_most, X_AXIS);
}
Drul_array < Link_array<Grob>
{
SCM style = me->get_property ("style");
if (!scm_is_symbol (style))
- {
- style = ly_symbol2scm ("default");
- }
+ style = ly_symbol2scm ("default");
SCM log = scm_from_int (Note_head::get_balltype (me));
String suffix = to_string (min (robust_scm2int (me->get_property ("duration-log"), 2), 2));
out = Stencil (Box (Interval (0, 0), Interval (0, 0)), SCM_EOL);
}
else
- {
- *font_char = idx;
- }
+ *font_char = idx;
return out;
}
#if 0 /* TODO: should have a mechanism to switch off these warnings. */
if (!pit)
- {
- ev->origin ()->warning (_ ("NoteEvent without pitch"));
- }
+ ev->origin ()->warning (_ ("NoteEvent without pitch"));
#endif
int pos = pit ? pit->steps () : 0;
&& scm_is_symbol (scm_vector_ref (shape_vector, scm_from_int (delta))))
style = scm_vector_ref (shape_vector, scm_from_int (delta));
if (scm_is_symbol (style))
- {
- note->set_property ("style", style);
- }
+ note->set_property ("style", style);
}
notes_.push (note);
// --> grace notes effectively do not get delayed
Moment now = now_mom ();
for (int i = 0; i < notes_.size (); i++)
- {
- play_element (notes_[i]);
- }
+ play_element (notes_[i]);
notes_.clear ();
note_evs_.clear ();
}
*/
+ max (0.0, -extents[RIGHT][LEFT] - (base_space - increment))));
-
/*
We don't do complicated stuff: (base_space - increment) is the
normal amount of white, which also determines the amount of
}
if (!mincol)
- {
- return 0;
- }
+ return 0;
return mincol;
}
for (Key_to_key_map::const_iterator i (dumper->serialized_keys_.begin ());
i != dumper->serialized_keys_.end ();
i++)
- {
- scm_gc_mark ((*i).first->self_scm ());
- }
+ scm_gc_mark ((*i).first->self_scm ());
return SCM_EOL;
}
Object_key_dumper::dump_key (Object_key const *key)
{
if (key_serial_numbers_.find (key) != key_serial_numbers_.end ())
- {
- return key_serial (key_serial_numbers_[key]);
- }
+ return key_serial (key_serial_numbers_[key]);
else if (Object_key const *serialized = serialized_keys_[key])
- {
- return key_serial (key_serial_numbers_[ serialized_keys_ [serialized] ]);
- }
+ return key_serial (key_serial_numbers_[ serialized_keys_ [serialized] ]);
return serialize_key (key);
}
Object_key_undumper *undumper = (Object_key_undumper *) SCM_CELL_WORD_1 (smob);
for (Int_to_key_map::const_iterator i (undumper->keys_.begin ());
i != undumper->keys_.end (); i++)
- {
- scm_gc_mark ((*i).second->self_scm ());
- }
+ scm_gc_mark ((*i).second->self_scm ());
return SCM_BOOL_F;
}
return buffer;
}
else
- {
- programming_error ("Cannot find OpenType table.");
- }
+ programming_error ("Cannot find OpenType table.");
return 0;
}
{
((Pango_font *) this)->register_font_file (file_name, ps_name);
pango_fc_font_unlock_face (fcfont);
-
+
SCM expr = scm_list_5 (ly_symbol2scm ("glyph-string"),
scm_makfrom0str (ps_name.to_str0 ()),
scm_from_double (size),
{
PangoStyle pstyle = PANGO_STYLE_NORMAL;
if (style == ly_symbol2scm ("italic"))
- {
- pstyle = PANGO_STYLE_ITALIC;
- }
+ pstyle = PANGO_STYLE_ITALIC;
else if (style == ly_symbol2scm ("oblique")
|| style == ly_symbol2scm ("slanted"))
- {
- pstyle = PANGO_STYLE_OBLIQUE;
- }
+ pstyle = PANGO_STYLE_OBLIQUE;
return pstyle;
}
{
PangoVariant pvariant = PANGO_VARIANT_NORMAL;
if (variant == ly_symbol2scm ("caps"))
- {
- pvariant = PANGO_VARIANT_SMALL_CAPS;
- }
+ pvariant = PANGO_VARIANT_SMALL_CAPS;
return pvariant;
}
{
PangoWeight pw = PANGO_WEIGHT_NORMAL;
if (weight == ly_symbol2scm ("bold"))
- {
- pw = PANGO_WEIGHT_BOLD;
- }
+ pw = PANGO_WEIGHT_BOLD;
if (weight == ly_symbol2scm ("heavy"))
- {
- pw = PANGO_WEIGHT_HEAVY;
- }
+ pw = PANGO_WEIGHT_HEAVY;
if (weight == ly_symbol2scm ("ultrabold"))
- {
- pw = PANGO_WEIGHT_ULTRABOLD;
- }
+ pw = PANGO_WEIGHT_ULTRABOLD;
if (weight == ly_symbol2scm ("light"))
- {
- pw = PANGO_WEIGHT_LIGHT;
- }
+ pw = PANGO_WEIGHT_LIGHT;
if (weight == ly_symbol2scm ("ultralight"))
- {
- pw = PANGO_WEIGHT_ULTRALIGHT;
- }
+ pw = PANGO_WEIGHT_ULTRALIGHT;
return pw;
}
command_column_ = new_command;
musical_column_ = new_musical;
if (new_command)
- {
- context ()->set_property ("currentCommandColumn", new_command->self_scm ());
- }
+ context ()->set_property ("currentCommandColumn", new_command->self_scm ());
if (new_musical)
- {
- context ()->set_property ("currentMusicalColumn", new_musical->self_scm ());
- }
+ context ()->set_property ("currentMusicalColumn", new_musical->self_scm ());
system_->add_column (command_column_);
system_->add_column (musical_column_);
SCM m = me->get_property ("shortest-starter-duration");
Moment s (0);
if (unsmob_moment (m))
- {
- s = *unsmob_moment (m);
- }
+ s = *unsmob_moment (m);
return s != Moment (0);
}
SCM size_key = scm_from_double (factor);
SCM handle = scm_assoc (size_key, sizes);
if (scm_is_pair (handle))
- {
- return unsmob_metrics (scm_cdr (handle));
- }
+ return unsmob_metrics (scm_cdr (handle));
PangoFontDescription *description
= pango_font_description_from_string (scm_i_string_chars (descr));
#include "warn.hh"
#include "stencil.hh"
-
LY_DEFINE (ly_make_paper_outputter, "ly:make-paper-outputter",
2, 0, 0, (SCM port, SCM format),
"Create an outputter that evaluates within "
Stencil s = brew_slash (me);
for (int i = count; i--;)
- {
- m.add_at_edge (X_AXIS, RIGHT, s, -slash_neg_kern, 0);
- }
+ m.add_at_edge (X_AXIS, RIGHT, s, -slash_neg_kern, 0);
Stencil d1 = Font_interface::get_default_font (me)->find_by_name ("dots.dot");
Stencil d2 = d1;
d1.translate_axis (0.5, Y_AXIS);
return SCM_UNSPECIFIED;
}
-
Audio_text track_name_a (Audio_text::TRACK_NAME, "Track "
+ String_convert::int2dec (0, 0, '0'));
Midi_text track_name (&track_name_a);
-
+
midi_track.add (Moment (0), &track_name);
// Some sequencers read track 0 last.
Performance::add_element (Audio_element *p)
{
if (Audio_staff *s = dynamic_cast<Audio_staff *> (p))
- {
- audio_staffs_.push (s);
- }
+ audio_staffs_.push (s);
audio_element_list_ = new Killing_cons<Audio_element> (p, audio_element_list_);
}
sprintf (outp, "%02x", *p++);
outp += 2;
if (! (i % 32))
- {
- *outp++ = '\n';
- }
+ *outp++ = '\n';
}
olen = outp - out;
}
-
}
out[olen] = 0;
return pfa_scm;
}
-
LY_DEFINE (ly_otf_to_cff, "ly:otf->cff",
1, 0, 0, (SCM otf_file_name),
"Convert the contents of a OTF file to CFF file, returning it as "
if (!mixed)
{
if (!p->start_ev_)
- {
- p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
- }
+ p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
else
s = scm_cadr (strings);
p->start_ev_ = p->event_drul_[START];
if (!mixed)
{
if (!p->start_ev_)
- {
- p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
- }
+ p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
else
s = scm_caddr (strings);
p->start_ev_ = 0;
p->finished_bracket_ = 0;
if (p->item_)
- {
- p->item_ = 0;
- }
+ p->item_ = 0;
if (p->finished_bracket_)
{
Grob *r = p->finished_bracket_->get_bound (RIGHT);
if (!r)
- {
- p->finished_bracket_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn")));
- }
+ p->finished_bracket_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn")));
p->finished_bracket_ = 0;
}
if (p->event_drul_[STOP])
{
if (!p->start_event_)
- {
- p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", String (p->name_)));
- }
+ p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", String (p->name_)));
else
{
Audio_piano_pedal *a = new Audio_piano_pedal;
{
SCM newpos = get_property ("squashedPosition");
if (scm_is_number (newpos))
- {
- i.grob ()->set_property ("staff-position", newpos);
- }
+ i.grob ()->set_property ("staff-position", newpos);
}
Pitch_squash_engraver::Pitch_squash_engraver ()
Grob_array *arr = unsmob_grob_array (elt->internal_get_object (symbol));
Link_array<Item> items;
for (int i = 0; arr && i < arr->size (); i++)
- {
- items.push (arr->item (i));
- }
+ items.push (arr->item (i));
return items;
}
: scm_c_make_hash_table (1);
}
-
LY_DEFINE (ly_property_lookup_stats, "ly:grob-property-lookup-stats",
0, 0, 0, (),
"")
opt_help.substitute (String ("\n"),
String ("\n")
+ String_convert::char_string (' ', HELP_INDENT));
-
+
opts.push (opt_spec + opt_help + "\n");
}
__FUNCTION__, "symbol");
if (ly_symbol2scm ("help") == var)
- {
- ly_option_usage ();
- }
+ ly_option_usage ();
if (val == SCM_UNDEFINED)
val = SCM_BOOL_T;
SCM handle = scm_hashq_get_handle (option_hash_, var);
if (handle == SCM_BOOL_F)
- {
- warning (_f ("no such internal option: %s", varstr.to_str0 ()));
- }
+ warning (_f ("no such internal option: %s", varstr.to_str0 ()));
internal_set_option (var, val);
return SCM_UNSPECIFIED;
quote_outlet_.set_context (cue_context);
}
else
- {
- quote_outlet_.set_context (get_outlet ());
- }
+ quote_outlet_.set_context (get_outlet ());
event_vector_ = get_music ()->get_property ("quoted-events");
if (!scm_is_string (wb) || ly_is_equal (db, wb))
{
if (s != "" || (volta_found && !scm_is_string (wb)))
- {
- context ()->set_property ("whichBar", scm_makfrom0str (s.to_str0 ()));
- }
+ context ()->set_property ("whichBar", scm_makfrom0str (s.to_str0 ()));
}
}
return last.smobbed_copy ();
}
else
- {
- return me->generic_to_relative_octave (p).smobbed_copy ();
- }
+ return me->generic_to_relative_octave (p).smobbed_copy ();
}
Moment
{
Moment m = 0;
if (Music *body = unsmob_music (me->get_property ("element")))
- {
- m = body->get_length ();
- }
+ m = body->get_length ();
return m;
}
if (body)
return body->start_mom ().smobbed_copy ();
else
- {
- return Music_sequence::minimum_start (me->get_property ("elements")).smobbed_copy ();
- }
+ return Music_sequence::minimum_start (me->get_property ("elements")).smobbed_copy ();
}
MAKE_SCHEME_CALLBACK (Repeated_music, first_start, 1);
Rests and notes.
*/
if (rests.size () > 1)
- {
- warning (_ ("too many colliding rests"));
- }
+ warning (_ ("too many colliding rests"));
Grob *rcol = 0;
Direction dir = CENTER;
me->translate_axis (ss, Y_AXIS);
}
else
- {
- me->translate_axis (ss / 2, Y_AXIS);
- }
+ me->translate_axis (ss / 2, Y_AXIS);
Grob *d = unsmob_grob (me->get_object ("dot"));
if (d && bt > 4) // UGH.
Score_performer::play_element (Audio_element *p)
{
if (Audio_item *i = dynamic_cast<Audio_item *> (p))
- {
- audio_column_->add_audio_item (i);
- }
+ audio_column_->add_audio_item (i);
performance_->add_element (p);
}
Script_column_engraver::process_acknowledged ()
{
if (!scol_ && scripts_.size () > 1)
- {
- scol_ = make_item ("ScriptColumn", SCM_EOL);
- }
+ scol_ = make_item ("ScriptColumn", SCM_EOL);
if (scol_)
{
if (last_spacings_.staff_spacing_
&& last_spacings_.staff_spacing_->get_column () == column)
- {
- last_spacings_.staff_spacing_->suicide ();
- }
+ last_spacings_.staff_spacing_->suicide ();
}
void
Separating_line_group_engraver::stop_translation_timestep ()
{
if (break_item_)
- {
- Separating_group_spanner::add_spacing_unit (sep_span_, break_item_);
- }
+ Separating_group_spanner::add_spacing_unit (sep_span_, break_item_);
if (Item *sp = current_spacings_.staff_spacing_)
{
}
if (!current_spacings_.is_empty ())
- {
- last_spacings_ = current_spacings_;
- }
+ last_spacings_ = current_spacings_;
current_spacings_.clear ();
if (musical_item_)
- {
- Separating_group_spanner::add_spacing_unit (sep_span_, musical_item_);
- }
+ Separating_group_spanner::add_spacing_unit (sep_span_, musical_item_);
musical_item_ = 0;
}
{
SCM sw = me->get_property ("X-extent");
if (is_number_pair (sw))
- {
- return ly_scm2interval (sw);
- }
+ return ly_scm2interval (sw);
Item *item = dynamic_cast<Item *> (me);
Paper_column *pc = item->get_column ();
}
while (iter_ && !iter_->ok ())
- {
- next_element (true);
- }
+ next_element (true);
last_mom_ = Moment (-1);
here_mom_ = get_music ()->start_mom ();
Grace_fixup *gf = get_grace_fixup ();
if (gf
&& gf->length_ + iter_->music_start_mom () == cp)
- {
- return here_mom_ + gf->length_ + Moment (0, gf->grace_start_);
- }
+ return here_mom_ + gf->length_ + Moment (0, gf->grace_start_);
/*
Fix-up a grace note at the start of the music.
Direction relative_dir = Direction (1);
SCM reldir = me->get_property ("side-relative-direction"); // should use a lambda.
if (is_direction (reldir))
- {
- relative_dir = to_dir (reldir);
- }
+ relative_dir = to_dir (reldir);
SCM other_elt = me->get_object ("direction-source");
Grob *e = unsmob_grob (other_elt);
if (e)
- {
- return (Direction) (relative_dir * get_grob_direction (e));
- }
+ return (Direction) (relative_dir * get_grob_direction (e));
return CENTER;
}
SCM force_return = SCM_BOOL_F;
if (!isinf (spacer.force_)
&& (spacer.is_active () || is_ragged))
- {
- force_return = scm_from_double (spacer.force_);
- }
+ force_return = scm_from_double (spacer.force_);
if (is_ragged
&& posns.top () > spacer.line_len_)
- {
- force_return = SCM_BOOL_F;
- }
+ force_return = SCM_BOOL_F;
SCM retval = SCM_EOL;
for (int i = posns.size (); i--;)
- {
- retval = scm_cons (scm_from_double (posns[i]), retval);
- }
+ retval = scm_cons (scm_from_double (posns[i]), retval);
retval = scm_cons (force_return, retval);
return retval;
Real bf = -infinity_f;
for (int i = 0; i < springs_.size (); i++)
if (springs_[i].is_active_)
- {
- bf = max (bf, springs_[i].block_force_);
- }
+ bf = max (bf, springs_[i].block_force_);
return bf;
}
}
if (!inverse_hooke)
- {
- desc.is_active_ = false;
- }
+ desc.is_active_ = false;
else
{
/*
for (int i = 0; i < icols.size (); i++)
if (scm_is_pair (icols[i]->get_object ("between-cols")))
- {
- loose_cols_.push (icols[i]);
- }
+ loose_cols_.push (icols[i]);
else
- {
- cols.push (icols[i]);
- }
+ cols.push (icols[i]);
spaced_cols_ = cols;
for (int i = 0; i < cols.size () - 1; i++)
Slash_repeat_engraver::start_translation_timestep ()
{
if (stop_mom_ == now_mom ())
- {
- repeat_ = 0;
- }
+ repeat_ = 0;
beat_slash_ = 0;
}
max_h = len / 3.0;
}
else
- {
- max_h = sqrt (max_h);
- }
+ max_h = sqrt (max_h);
Real eccentricity = robust_scm2double (state.slur_->get_property ("eccentricity"), 0);
Bezier best;
if (is_number_pair (end_ys))
- {
- best = state.configurations_[state.get_closest_index (end_ys)]->curve_;
- }
+ best = state.configurations_[state.get_closest_index (end_ys)]->curve_;
else
- {
- best = state.get_best_curve ();
- }
+ best = state.get_best_curve ();
SCM controls = SCM_EOL;
for (int i = 4; i--;)
return y;
}
-
Array<Offset>
Slur_score_state::generate_avoid_offsets () const
{
{
SCM s = scm_cdr (smob_protection_list);
while (scm_is_pair (s) && scm_car (s) == SCM_UNDEFINED)
- {
- s = scm_cdr (s);
- }
+ s = scm_cdr (s);
SCM prot = scm_cons (smob, s);
scm_set_cdr_x (smob_protection_list,
SCM next = scm_cdr (*prot_cons);
if (next == SCM_EOL)
- {
- scm_set_car_x (*prot_cons, SCM_UNDEFINED);
- }
+ scm_set_car_x (*prot_cons, SCM_UNDEFINED);
else
{
scm_set_car_x (*prot_cons, SCM_UNDEFINED);
int
Source_file::tell () const
{
- return pos_str0_ - contents_str0_;
+ return pos_str0_ - contents_str0_;
}
-std::istream*
+std::istream *
Source_file::get_istream ()
{
if (!istream_)
}
}
-
String
Source_file::quote_input (char const *pos_str0) const
{
break;
}
- char const* end_str0 = pos_str0;
+ char const *end_str0 = pos_str0;
while (end_str0 < eof_C_)
if (*end_str0++ == '\n')
{
}
String
-Source_file::line_string (char const* pos_str0) const
+Source_file::line_string (char const *pos_str0) const
{
if (!contains (pos_str0))
return "";
thislen = 1;
if (thislen == 1 && line_chars[0] == '\t')
- (*column) = (*column / 8 + 1) * 8;
+ (*column) = (*column / 8 + 1) * 8;
else
- (*column) ++;
+ (*column)++;
- (*line_char) ++;
+ (*line_char)++;
/* Advance past this character. */
line_chars += thislen;
left -= thislen;
}
void
-Source_file::set_pos (char const * pos_str0)
+Source_file::set_pos (char const *pos_str0)
{
if (contains (pos_str0))
pos_str0_ = pos_str0;
}
if (Paper_column::get_rank (p) < Paper_column::get_rank (me))
- {
- programming_error ("Adding reverse rod");
- }
+ programming_error ("Adding reverse rod");
mins = scm_cons (scm_cons (p->self_scm (), newdist), mins);
me->set_object ("minimum-distances", mins);
*/
if (! ((Paper_column::is_musical (l_neighbor) || Item::is_breakable (l_neighbor))
&& (Paper_column::is_musical (r_neighbor) || Item::is_breakable (r_neighbor))))
- {
- return false;
- }
+ return false;
/*
A rather hairy check, but we really only want to move around
dists[d] = max (dists[d], fixed_space);
}
else
- {
- programming_error ("Subversive spacing wish");
- }
+ programming_error ("Subversive spacing wish");
}
}
while (flip (&d) != LEFT);
}
if (rn_arr->size ())
- {
- cols[i]->set_object ("right-neighbors", right_neighbors);
- }
+ cols[i]->set_object ("right-neighbors", right_neighbors);
}
}
#include "staff-spacing.hh"
#include "spacing-interface.hh"
-
Rational
Spacing_spanner::effective_shortest_duration (Grob *me, Link_array<Grob> const &all)
{
SCM preset_shortest = me->get_property ("common-shortest-duration");
Rational global_shortest;
if (unsmob_moment (preset_shortest))
- {
- global_shortest = unsmob_moment (preset_shortest)->main_part_;
- }
+ global_shortest = unsmob_moment (preset_shortest)->main_part_;
else
{
global_shortest = Spacing_spanner::find_shortest (me, all);
Real compound_fixed_note_space = 0.0;
if (options->stretch_uniformly_)
- {
- compound_note_space = base_note_space;
- }
+ compound_note_space = base_note_space;
else
{
int wish_count = 0;
}
if (options->stretch_uniformly_ && l->break_status_dir () != RIGHT)
- {
- compound_fixed = 0.0;
- }
+ compound_fixed = 0.0;
assert (!isinf (compound_space));
compound_space = max (compound_space, compound_fixed);
"grace-space-factor spacing-increment base-shortest-duration strict-note-spacing "
"shortest-duration-space common-shortest-duration uniform-stretching "
- "packed-spacing "
- );
+ "packed-spacing ");
ADD_INTERFACE (Spacing_interface, "spacing-interface",
"Something to do with line breaking and spacing. "
Span_arpeggio_engraver::acknowledge_arpeggio (Grob_info info)
{
if (info.origin_contexts (this).size ()) // huh? what's this test for?
- {
- arpeggios_.push (info.grob ());
- }
+ arpeggios_.push (info.grob ());
}
void
*/
if (!span_arpeggio_ && arpeggios_.size () > 1
&& to_boolean (get_property ("connectArpeggios")))
- {
- span_arpeggio_ = make_item ("Arpeggio", SCM_EOL);
- }
+ span_arpeggio_ = make_item ("Arpeggio", SCM_EOL);
}
void
extract_grob_set (me, "elements", elements);
if (elements.is_empty ())
- {
- me->suicide ();
- }
+ me->suicide ();
}
void
extract_grob_set (me, "elements", elements);
for (int i = elements.size ();
i-- && !scm_is_string (gl);)
- {
- gl = elements[i]->get_property ("glyph");
- }
+ gl = elements[i]->get_property ("glyph");
if (!scm_is_string (gl))
{
String type = ly_scm2string (gl);
if (type == "|:")
- {
- type = ".|";
- }
+ type = ".|";
else if (type == ":|")
- {
- type = "|.";
- }
+ type = "|.";
else if (type == ":|:")
- {
- type = ".|.";
- }
+ type = ".|.";
gl = scm_makfrom0str (type.to_str0 ());
if (scm_equal_p (me->get_property ("glyph"), gl)
Span_dynamic_performer::acknowledge_audio_element (Audio_element_info i)
{
if (Audio_dynamic *d = dynamic_cast<Audio_dynamic *> (i.elem_))
- {
- last_volume_ = d->volume_;
- }
+ last_volume_ = d->volume_;
}
void
}
if (span_events_[STOP])
- {
- finished_dynamic_tuples_.top ().audio_->volume_ = last_volume_;
- }
+ finished_dynamic_tuples_.top ().audio_->volume_ = last_volume_;
if (span_events_[START])
- {
- dynamic_tuples_[0].audio_->volume_ = last_volume_;
- }
+ dynamic_tuples_[0].audio_->volume_ = last_volume_;
span_events_[START] = 0;
span_events_[STOP] = 0;
We check for System to prevent the column -> line_of_score
-> column -> line_of_score -> etc situation */
if (d == LEFT && !dynamic_cast<System *> (this))
- {
- set_parent (i, X_AXIS);
- }
+ set_parent (i, X_AXIS);
/*
Signal that this column needs to be kept alive. They need to be
*/
if (dynamic_cast<Paper_column *> (i))
- {
- Pointer_group_interface::add_grob (i, ly_symbol2scm ("bounded-by-me"), this);
- }
+ Pointer_group_interface::add_grob (i, ly_symbol2scm ("bounded-by-me"), this);
}
Spanner::Spanner (SCM s, Object_key const *key)
Staff_performer::acknowledge_audio_element (Audio_element *p)
{
if (Audio_item *ai = dynamic_cast<Audio_item *> (p))
- {
- audio_staff_->add_audio_item (ai);
- }
+ audio_staff_->add_audio_item (ai);
}
max_corr = max (max_corr, (- v[LEFT]));
}
if (Grob *a = unsmob_grob (g->get_object ("arpeggio")))
- {
- max_corr = max (max_corr, - a->extent (col, X_AXIS)[LEFT]);
- }
+ max_corr = max (max_corr, - a->extent (col, X_AXIS)[LEFT]);
/*
Let's decrease the space a little if the problem is not located
*space = *fixed;
}
else if (type == ly_symbol2scm ("extra-space"))
- {
- *space = *fixed + distance;
- }
+ *space = *fixed + distance;
else if (type == ly_symbol2scm ("semi-fixed-space"))
{
*fixed += distance / 2;
*space = *fixed + distance / 2;
}
else if (type == ly_symbol2scm ("minimum-space"))
- {
- *space = last_ext[LEFT] + max (last_ext.length (), distance);
- }
+ *space = last_ext[LEFT] + max (last_ext.length (), distance);
else if (type == ly_symbol2scm ("minimum-fixed-space"))
{
*space = last_ext[LEFT] + max (last_ext.length (), distance);
Staff_symbol_engraver::start_spanner ()
{
if (!span_)
- {
- span_ = make_spanner ("StaffSymbol", SCM_EOL);
- }
+ span_ = make_spanner ("StaffSymbol", SCM_EOL);
}
void
Staff_symbol_engraver::stop_spanner ()
{
if (finished_span_ && !finished_span_->get_bound (RIGHT))
- {
- finished_span_->set_bound (RIGHT, unsmob_grob (get_property ("currentCommandColumn")));
- }
+ finished_span_->set_bound (RIGHT, unsmob_grob (get_property ("currentCommandColumn")));
finished_span_ = 0;
}
return p;
}
else if (!st)
- {
- return me->relative_coordinate (me->get_parent (Y_AXIS), Y_AXIS) * 2;
- }
+ return me->relative_coordinate (me->get_parent (Y_AXIS), Y_AXIS) * 2;
return robust_scm2double (me->get_property ("staff-position"), p);
}
Stanza_number_engraver::acknowledge_lyric_syllable (Grob_info inf)
{
if (text_)
- {
- Side_position_interface::add_support (text_, inf.grob ());
- }
+ Side_position_interface::add_support (text_, inf.grob ());
}
void
*/
Grob *beam = get_beam (me);
if (beam)
- {
- Beam::after_line_breaking (beam->self_scm ());
- }
+ Beam::after_line_breaking (beam->self_scm ());
SCM mol = me->get_uncached_stencil ();
Interval iv;
= Staff_symbol_referencer::on_staffline (me, p) ? "0" : "1";
}
else
- {
- staffline_offs = "2";
- }
+ staffline_offs = "2";
}
else
- {
- staffline_offs = "";
- }
+ staffline_offs = "";
char dir = (get_direction (me) == UP) ? 'u' : 'd';
String font_char = flag_style
Interval r;
if (is_invisible (me))
- {
- r.set_empty ();
- }
+ r.set_empty ();
else if (unsmob_grob (me->get_object ("beam")) || abs (duration_log (me)) <= 2)
{
r = Interval (-1, 1);
scm_to_double (blot)).smobbed_copy ();
}
-
LY_DEFINE (ly_register_stencil_expression, "ly:register-stencil-expression",
1, 0, 0,
(SCM symbol),
add_stencil (moved_to_edge (a, d, s, padding, minimum));
}
-
Stencil
Stencil::in_color (Real r, Real g, Real b) const
{
System_start_delimiter_engraver::finalize ()
{
if (delim_)
- {
- delim_->set_bound (RIGHT, unsmob_grob (get_property ("currentCommandColumn")));
- }
+ delim_->set_bound (RIGHT, unsmob_grob (get_property ("currentCommandColumn")));
}
#include "translator.icc"
Direction d = DOWN;
do
- {
- bracket.add_at_edge (Y_AXIS, d, tips[d], -overlap, 0.0);
- }
- while (flip (&d) != DOWN);
+ bracket.add_at_edge (Y_AXIS, d, tips[d], -overlap, 0.0);
+ while (flip (&d) != DOWN)
+ ;
return bracket;
}
fixup_refpoints (Link_array<Grob> const &grobs)
{
for (int i = grobs.size (); i--;)
- {
- grobs[i]->fixup_refpoint ();
- }
+ grobs[i]->fixup_refpoint ();
}
SCM
Interval iv (extent (this, Y_AXIS));
if (iv.is_empty ())
- {
- programming_error ("system with empty extent");
- }
+ programming_error ("system with empty extent");
else
translate_axis (-iv[MAX], Y_AXIS);
return true;
}
else if (m->is_mus_type ("busy-playing-event"))
- {
- return note_events_.size ();
- }
+ return note_events_.size ();
return false;
}
Text_engraver::acknowledge_stem (Grob_info inf)
{
for (int i = 0; i < texts_.size (); i++)
- {
- Side_position_interface::add_support (texts_[i], inf.grob ());
- }
+ Side_position_interface::add_support (texts_[i], inf.grob ());
}
void
if (event_drul_[STOP])
{
if (!span_)
- {
- event_drul_[STOP]->origin ()->warning (_ ("can't find start of text spanner"));
- }
+ event_drul_[STOP]->origin ()->warning (_ ("can't find start of text spanner"));
else
{
finished_ = span_;
if (event_drul_[START])
{
if (current_event_)
- {
- event_drul_[START]->origin ()->warning (_ ("already have a text spanner"));
- }
+ event_drul_[START]->origin ()->warning (_ ("already have a text spanner"));
else
{
current_event_ = event_drul_[START];
Tie_engraver::try_music (Music *mus)
{
if (mus->is_mus_type ("tie-event"))
- {
- event_ = mus;
- }
+ event_ = mus;
return true;
}
Tie_engraver::process_music ()
{
if (event_)
- {
- context ()->set_property ("tieMelismaBusy", SCM_BOOL_T);
- }
+ context ()->set_property ("tieMelismaBusy", SCM_BOOL_T);
}
void
}
if (ties_.size () && ! tie_column_)
- {
- tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
- }
+ tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
if (tie_column_)
for (int i = ties_.size (); i--;)
Tie_performer::try_music (Music *mus)
{
if (mus->is_mus_type ("tie-event"))
- {
- event_ = mus;
- }
+ event_ = mus;
return true;
}
SCM s = get_property ("measurePosition");
if (unsmob_moment (s))
- {
- measposp = *unsmob_moment (s);
- }
+ measposp = *unsmob_moment (s);
else
{
measposp = now;
SCM barn = get_property ("currentBarNumber");
int b = 0;
if (scm_is_number (barn))
- {
- b = scm_to_int (barn);
- }
+ b = scm_to_int (barn);
SCM cad = get_property ("timing");
bool c = to_boolean (cad);
"Normally in @code{Score}. In order to create polyrhythmic music, "
"this engraver should be removed from @code{Score} and placed in "
"@code{Staff}. "
- "\n\nThis engraver adds the alias @code{Timing} to its containing context."
- ,
+ "\n\nThis engraver adds the alias @code{Timing} to its containing context.",
"", "", "", "");
SCM l = global_translator_dict ? global_translator_dict->to_alist () : SCM_EOL;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- {
- scm_set_car_x (s, scm_cdar (s));
- }
+ scm_set_car_x (s, scm_cdar (s));
return l;
}
for (SCM s = c->children_contexts (); scm_is_pair (s);
s = scm_cdr (s))
- {
- precomputed_recurse_over_translators (unsmob_context (scm_car (s)), idx, dir);
- }
+ precomputed_recurse_over_translators (unsmob_context (scm_car (s)), idx, dir);
if (dir == UP)
{
for (SCM s = c->children_contexts (); scm_is_pair (s);
s = scm_cdr (s))
- {
- recurse_over_translators (unsmob_context (scm_car (s)), ptr, tg_ptr, dir);
- }
+ recurse_over_translators (unsmob_context (scm_car (s)), ptr, tg_ptr, dir);
if (dir == UP)
{
{
Array<Translator_method_binding> &bindings (precomputed_method_bindings_[idx]);
for (int i = 0; i < bindings.size (); i++)
- {
- bindings[i].invoke ();
- }
+ bindings[i].invoke ();
}
void
if (event_drul_[STOP])
{
if (!span_)
- {
- event_drul_[STOP]->origin ()->warning (_ ("can't find start of trill spanner"));
- }
+ event_drul_[STOP]->origin ()->warning (_ ("can't find start of trill spanner"));
else
{
finished_ = span_;
if (event_drul_[START])
{
if (current_event_)
- {
- event_drul_[START]->origin ()->warning (_ ("already have a trill spanner"));
- }
+ event_drul_[START]->origin ()->warning (_ ("already have a trill spanner"));
else
{
current_event_ = event_drul_[START];
lily_cookie_fprintf (out, "end readonly def\n");
}
-
#define CHUNKSIZE 65534
static void
if (Note_column::has_interface (g)
&& Note_column::get_stem (g)
&& Note_column::dir (g) == my_dir)
- {
- g = Note_column::get_stem (g);
- }
+ g = Note_column::get_stem (g);
return g;
}
*/
SCM bracket = me->get_property ("bracket-visibility");
if (scm_is_bool (bracket))
- {
- bracket_visibility = ly_scm2bool (bracket);
- }
+ bracket_visibility = ly_scm2bool (bracket);
else if (bracket == ly_symbol2scm ("if-no-beam"))
bracket_visibility = !par_beam;
SCM numb = me->get_property ("number-visibility");
if (scm_is_bool (numb))
- {
- number_visibility = ly_scm2bool (numb);
- }
+ number_visibility = ly_scm2bool (numb);
else if (numb == ly_symbol2scm ("if-no-beam"))
number_visibility = !par_beam;
*/
if (bracket_visibility && number_visibility
&& mol.extent (X_AXIS).length () > w)
- {
- bracket_visibility = false;
- }
+ bracket_visibility = false;
if (bracket_visibility)
{
Direction d = LEFT;
do
- {
- straight_corners[d] += -d * shorten[d] / length * dz;
- }
- while (flip (&d) != LEFT);
+ straight_corners[d] += -d * shorten[d] / length * dz;
+ while (flip (&d) != LEFT)
+ ;
if (gap.is_empty ())
gap = Interval (0, 0);
do
- {
- gap_corners[d] = (dz * 0.5) + gap[d] / length * dz;
- }
- while (flip (&d) != LEFT);
+ gap_corners[d] = (dz * 0.5) + gap[d] / length * dz;
+ while (flip (&d) != LEFT)
+ ;
Drul_array<Offset> flare_corners = straight_corners;
do
Grob *commony = common_refpoint_of_array (columns, me, Y_AXIS);
commony = common_refpoint_of_array (tuplets, commony, Y_AXIS);
if (Grob *st = Staff_symbol_referencer::get_staff_symbol (me))
- {
- commony = st->common_refpoint (commony, Y_AXIS);
- }
+ commony = st->common_refpoint (commony, Y_AXIS);
Grob *commonx = common_refpoint_of_array (columns, me, X_AXIS);
commonx = common_refpoint_of_array (tuplets, commonx, Y_AXIS);
Real offset = 0.0;
if (!par_beam
|| get_grob_direction (par_beam) != dir)
- {
- calc_position_and_height (me, &offset, &dy);
- }
+ calc_position_and_height (me, &offset, &dy);
else
{
SCM ps = par_beam->get_property ("positions");
SCM rp = me->get_property ("right-position");
if (scm_is_number (lp) && !scm_is_number (rp))
- {
- rp = scm_from_double (scm_to_double (lp) + dy);
- }
+ rp = scm_from_double (scm_to_double (lp) + dy);
else if (scm_is_number (rp) && !scm_is_number (lp))
- {
- lp = scm_from_double (scm_to_double (rp) - dy);
- }
+ lp = scm_from_double (scm_to_double (rp) - dy);
else if (!scm_is_number (rp) && !scm_is_number (lp))
{
lp = scm_from_double (offset);
me->add_dependency (bracket);
}
-
ADD_INTERFACE (Tuplet_bracket,
"tuplet-bracket-interface",
"A bracket with a number in the middle, used for tuplets. "
}
};
-
class Tuplet_engraver : public Engraver
{
public:
ly_bool2scm (false));
}
if (prev_delta_pitch < - 1)
- {
- glyph_name = "svaticana.reverse.plica";
- }
+ glyph_name = "svaticana.reverse.plica";
else
- {
- glyph_name = "svaticana.reverse.vplica";
- }
+ glyph_name = "svaticana.reverse.vplica";
}
else // (prev_delta_pitch == 0)
{
Real interval;
SCM flexa_height_scm = me->get_property ("flexa-height");
if (flexa_height_scm != SCM_EOL)
- {
- interval = scm_to_int (flexa_height_scm);
- }
+ interval = scm_to_int (flexa_height_scm);
else
{
me->warning ("Vaticana_ligature: "
}
if (interval >= 0.0)
- {
- me->warning (_ ("ascending vaticana style flexa"));
- }
+ me->warning (_ ("ascending vaticana style flexa"));
Real width = robust_scm2double (me->get_property ("flexa-width"), 2);
= Lookup::blank (Box (Interval (0, 0.5 * flexa_width), Interval (0, 0)));
}
else if (!String::compare (glyph_name, "flexa"))
- {
- out = vaticana_brew_flexa (me, true, line_thickness);
- }
+ out = vaticana_brew_flexa (me, true, line_thickness);
else
{
out
Grob *system_;
};
-
Vertically_spaced_contexts_engraver::Vertically_spaced_contexts_engraver ()
{
system_ = 0;
{
SCM doit = get_property ("voltaOnThisStaff");
if (scm_is_bool (doit))
- {
- return to_boolean (doit);
- }
+ return to_boolean (doit);
if (!unsmob_grob (staff_))
return false;
}
if (done_count_ == 1 && alt_count_ < rep_count_)
- {
- repstr = "1.--" + to_string (rep_count_ - alt_count_ + done_count_) + ".";
- }
+ repstr = "1.--" + to_string (rep_count_ - alt_count_ + done_count_) + ".";
if (done_count_ <= alt_count_)
add_repeat_command (scm_list_n (ly_symbol2scm ("volta"),
scm_makfrom0str (repstr.to_str0 ()), SCM_UNDEFINED));
}
else
- {
- add_repeat_command (ly_symbol2scm ("end-repeat"));
- }
+ add_repeat_command (ly_symbol2scm ("end-repeat"));
}
}
(display-scheme-music music)
music)
-%#(use-modules (scm display-lily))
-%displayLilyMusic =
-%#(def-music-function (parser location music) (ly:music?)
-% (display-lily-init parser)
-% (display-lily-music music)
-% music)
+%% FIXME: guile-1.7 required?
+%% # (use-modules (scm display-lily))invalid module name for use-syntax ((srfi srfi-39))
+
+%%#(use-modules (scm display-lily))
+%%displayLilyMusic =
+%%#(def-music-function (parser location music) (ly:music?)
+%% (display-lily-init parser)
+%% (display-lily-music music)
+%% music)
applyoutput =
#(def-music-function (parser location proc) (procedure?)
projects / lilypond.git / commitdiff