#include <cassert>
#include <cstdio>
+using namespace std;
#include "memory-stream.hh"
#include <unistd.h>
#include <limits.h>
+using namespace std;
#include "config.hh"
size_t wid = 0;
for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
- wid = std::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++)
{
#define CPU_TIMER_HH
#include <ctime>
+using namespace std;
#include "real.hh"
template<class T> T minmax (Direction d, T a, T b)
{
if (d == UP)
- return std::max (a, b);
+ return max (a, b);
else
- return std::min (a, b);
+ return min (a, b);
}
#endif // DIRECTION_HH
#include <unistd.h>
#include <cstdio>
+ using namespace std;
#if (! defined (__off64_t) && ! defined (__off64_t_defined)) || ! defined (__cplusplus)
#define off64_t unsigned long long
class File_name
{
public:
- std::string root_;
- std::string dir_;
- std::string base_;
- std::string ext_;
+ string root_;
+ string dir_;
+ string base_;
+ string ext_;
- File_name (std::string = "");
+ File_name (string = "");
bool is_absolute () const;
- std::string to_string () const;
+ string to_string () const;
File_name canonicalized () const;
- std::string dir_part () const;
- std::string file_part () const;
+ string dir_part () const;
+ string file_part () const;
};
#endif /* FILE_NAME */
class File_path
{
- std::vector<std::string> dirs_;
+ vector<string> dirs_;
public:
- std::vector<std::string> directories () const;
- std::string find (const std::string &name) const;
- std::string find (const std::string &name, char const *extensions[]);
- std::string to_string () const;
- bool try_append (std::string str);
- void append (const std::string&);
- void parse_path (const std::string&);
- void prepend (const std::string&);
+ vector<string> directories () const;
+ string find (const string &name) const;
+ string find (const string &name, char const *extensions[]);
+ string to_string () const;
+ bool try_append (string str);
+ void append (const string&);
+ void parse_path (const string&);
+ void prepend (const string&);
};
-bool is_file (const std::string &file_name);
-bool is_dir (std::string file_name);
+bool is_file (const string &file_name);
+bool is_dir (string file_name);
#endif /* FILE_PATH */
class String_convert;
#include "real.hh"
+using namespace std;
template<class T> struct Interval_t;
template<class T> struct PQueue;
char const *help_str0_;
- std::string to_string () const;
- std::string str_for_help () const;
+ string to_string () const;
+ string str_for_help () const;
// NO constructor!
static int compare (Long_option_init const &, Long_option_init const &);
- static std::string table_string (Long_option_init *);
+ static string table_string (Long_option_init *);
};
/** C++ for version of long_getopt. For processing GNU style command
/**
Internationalisation: _ ("to be translated") gets "translated" by GNU gettext
*/
-std::string _ (char const *ch);
+string _ (char const *ch);
/**
Internationalisation: _f ("Usage: %s [FILE]", "lilypond") gets "translated" by
GNU gettext
*/
-std::string _f (char const *format, ...)
+string _f (char const *format, ...)
__attribute__ ((format (printf, 1, 2)));
-std::string _f (char const *format, const std::string &s, const std::string &s2 = "", const std::string &s3 = "");
+string _f (char const *format, const string &s, const string &s2 = "", const string &s3 = "");
/**
va_list version of _f
*/
-std::string v_f (char const *format, va_list args);
+string v_f (char const *format, va_list args);
#endif // INTERNATIONAL_HH
public:
Interval_set ();
- static Interval_set interval_union (std::vector<Interval>);
+ static Interval_set interval_union (vector<Interval>);
- std::vector<Interval> const &intervals () const { return intervals_; }
- std::vector<Interval>::const_iterator upper_bound (Real x) const;
+ vector<Interval> const &intervals () const { return intervals_; }
+ vector<Interval>::const_iterator upper_bound (Real x) const;
Real nearest_point (Real x, Direction dir = CENTER) const;
Interval_set complement () const;
private:
- std::vector<Interval> intervals_;
+ vector<Interval> intervals_;
};
#endif /* INTERVAL_SET_HH */
using Drul_array<T>::at;
static T infinity ();
- static std::string T_to_string (T arg);
+ static string T_to_string (T arg);
T center () const;
void translate (T t)
{
void intersect (Interval_t<T> h);
void add_point (T p)
{
- at (LEFT) = std::min (at (LEFT), p);
- at (RIGHT) = std::max (at (RIGHT), p);
+ at (LEFT) = min (at (LEFT), p);
+ at (RIGHT) = max (at (RIGHT), p);
}
T length () const;
}
Real linear_combination (Real x) const;
- std::string to_string () const;
+ string to_string () const;
bool contains (T r) const;
void negate ()
// MacOS 10.3 problems:
// #include <cmath>
+using namespace std;
template<class T>
int
void
Interval_t<T>::unite (Interval_t<T> h)
{
- at (LEFT) = std::min (h.at (LEFT), at (LEFT));
- at (RIGHT) = std::max (h.at (RIGHT), at (RIGHT));
+ at (LEFT) = min (h.at (LEFT), at (LEFT));
+ at (RIGHT) = max (h.at (RIGHT), at (RIGHT));
}
/* Unites h and this interval, but in such a way
void
Interval_t<T>::intersect (Interval_t<T> h)
{
- at (LEFT) = std::max (h.at (LEFT), at (LEFT));
- at (RIGHT) = std::min (h.at (RIGHT), at (RIGHT));
+ at (LEFT) = max (h.at (LEFT), at (LEFT));
+ at (RIGHT) = min (h.at (RIGHT), at (RIGHT));
}
template<class T>
-std::string
+string
Interval_t<T>::to_string () const
{
if (is_empty ())
return "[empty]";
- std::string s ("[");
+ string s ("[");
- return (s + T_to_string (at (LEFT)) + std::string (",")
- + T_to_string (at (RIGHT)) + std::string ("]"));
+ return (s + T_to_string (at (LEFT)) + string (",")
+ + T_to_string (at (RIGHT)) + string ("]"));
}
template<class T>
#include <cstddef>
#include <cstdarg>
+using namespace std;
#include "config.hh"
data_.resize (rows * columns, t);
else
{
- std::vector<T, A> new_data;
+ vector<T, A> new_data;
new_data.resize (rows * columns, t);
vsize cur_cols = rank_ ? data_.size () / rank_ : 0;
}
private:
- std::vector<T, A> data_;
+ vector<T, A> data_;
vsize rank_;
};
#include <cstdio>
#include <unistd.h>
+using namespace std;
#include "libc-extension.hh"
#include "file-cookie.hh"
coordinate_a_[X_AXIS] = coordinate_a_[Y_AXIS] = 0.0;
}
- std::string to_string () const;
+ string to_string () const;
Offset &mirror (Axis a)
{
#include "std-vector.hh"
+using namespace std;
template<class T>
-class Link_array : public std::vector<T *>
+class Link_array : public vector<T *>
{
};
ssize_t degree ()const;
/// coefficients
- std::vector<Real> coefs_;
+ vector<Real> coefs_;
// leading coef
Real &lc ();
void print () const;
Real eval (Real) const;
Real minmax (Real, Real, bool) const;
- void print_sols (std::vector<Real>) const;
- void check_sols (std::vector<Real>) const;
+ void print_sols (vector<Real>) const;
+ void check_sols (vector<Real>) const;
void check_sol (Real x) const;
static Polynomial multiply (const Polynomial &p1, const Polynomial &p2);
static Polynomial power (int exponent, const Polynomial &src);
void debug_clean ();
- std::vector<Real> solve_quadric ()const;
- std::vector<Real> solve_cubic ()const;
- std::vector<Real> solve_linear ()const;
+ vector<Real> solve_quadric ()const;
+ vector<Real> solve_cubic ()const;
+ vector<Real> solve_linear ()const;
- std::vector<Real> solve () const;
+ vector<Real> solve () const;
};
IMPLEMENT_ARITHMETIC_OPERATOR (Polynomial, -);
template<class T>
class PQueue
{
- std::vector<T> heap_array_;
+ vector<T> heap_array_;
T &elt (vsize i)
{
return heap_array_[i - 1];
Rational &operator %= (Rational);
static int compare (Rational const &, Rational const &);
int sign () const;
- std::string to_string () const;
+ string to_string () const;
};
#include "arithmetic-operator.hh"
#include <algorithm>
#include <climits>
#include <cmath>
+using namespace std;
typedef double Real;
extern const Real infinity_f;
#include <string>
+using namespace std;
typedef size_t ssize;
#define NPOS std::string::npos
-std::string to_string (const std::string&);
-std::string to_string (char c, int n = 1);
-std::string to_string (int i, char const *format = 0);
-std::string to_string (double f, char const *format = 0);
-std::string to_string (long);
-std::string to_string (long unsigned);
-std::string to_string (I64, char const *format = 0);
-std::string to_string (unsigned);
-std::string to_string (bool b);
-std::string to_string (char const *format, ...)
+string to_string (const string&);
+string to_string (char c, int n = 1);
+string to_string (int i, char const *format = 0);
+string to_string (double f, char const *format = 0);
+string to_string (long);
+string to_string (long unsigned);
+string to_string (I64, char const *format = 0);
+string to_string (unsigned);
+string to_string (bool b);
+string to_string (char const *format, ...)
__attribute__ ((format (printf, 1, 2)));
-std::string &replace_all (std::string *str, std::string const &find, std::string const &replace);
-std::string &replace_all (std::string *str, char find, char replace);
-char *string_copy (const std::string &s);
+string &replace_all (string *str, string const &find, string const &replace);
+string &replace_all (string *str, char find, char replace);
+char *string_copy (const string &s);
#endif /* STD_STRING_HH */
#include <cassert>
#include <string>
+using namespace std;
template<typename T>
int default_compare (T const &a, T const &b)
typedef typename __flower_vector<T>::iterator iterator;
typedef typename __flower_vector<T>::const_iterator const_iterator;
- std::vector<T, A> () : __flower_vector<T, A> ()
+ vector<T, A> () : __flower_vector<T, A> ()
{
}
- std::vector<T, A> (size_t n) : __flower_vector<T, A> (n)
+ vector<T, A> (size_t n) : __flower_vector<T, A> (n)
{
}
- std::vector<T, A> (std::vector<T, A> const &v) : __flower_vector<T, A> (v)
+ vector<T, A> (vector<T, A> const &v) : __flower_vector<T, A> (v)
{
}
- std::vector<T, A> (const_iterator b, const_iterator e) : __flower_vector<T, A> (b, e)
+ vector<T, A> (const_iterator b, const_iterator e) : __flower_vector<T, A> (b, e)
{
}
template<typename T>
T const &
-boundary (std::vector<T> const &v, int dir, vsize i)
+boundary (vector<T> const &v, int dir, vsize i)
{
assert (dir);
return v[dir == -1 ? i : v.size () - 1 - i];
template<typename T>
T &
-boundary (std::vector<T> &v, int dir, vsize i)
+boundary (vector<T> &v, int dir, vsize i)
{
assert (dir);
return v[dir == -1 ? i : v.size () - 1 - i];
template<typename T>
T const &
-back (std::vector<T> const &v, vsize i)
+back (vector<T> const &v, vsize i)
{
return v[v.size () - i - 1];
}
template<typename T>
T &
-back (std::vector<T> &v, vsize i)
+back (vector<T> &v, vsize i)
{
return v[v.size () - i - 1];
}
template<typename T>
void
-concat (std::vector<T> &v, std::vector<T> const &w)
+concat (vector<T> &v, vector<T> const &w)
{
v.insert (v.end (), w.begin (), w.end ());
}
template<typename T, typename Compare>
vsize
-lower_bound (std::vector<T> const &v,
+lower_bound (vector<T> const &v,
T const &key,
Compare less,
vsize b = 0, vsize e = VPOS)
{
if (e == VPOS)
e = v.size ();
- typename std::vector<T>::const_iterator i = lower_bound (v.begin () + b,
+ typename vector<T>::const_iterator i = lower_bound (v.begin () + b,
v.begin () + e,
key,
less);
template<typename T, typename Compare>
vsize
-upper_bound (std::vector<T> const &v,
+upper_bound (vector<T> const &v,
T const &key,
Compare less,
vsize b = 0, vsize e = VPOS)
if (e == VPOS)
e = v.size ();
- typename std::vector<T>::const_iterator i = upper_bound (v.begin () + b,
+ typename vector<T>::const_iterator i = upper_bound (v.begin () + b,
v.begin () + e,
key,
less);
template<typename T, typename Compare>
vsize
-binary_search (std::vector<T> const &v,
+binary_search (vector<T> const &v,
T const &key,
Compare less,
vsize b = 0, vsize e = VPOS)
template<typename T, typename Compare>
void
-vector_sort (std::vector<T> &v,
+vector_sort (vector<T> &v,
Compare less,
vsize b = 0, vsize e = VPOS)
{
template<typename T>
void
-reverse (std::vector<T> &v)
+reverse (vector<T> &v)
{
- // CHECKME: for a simple vector, like std::vector<int>, this should
+ // CHECKME: for a simple vector, like vector<int>, this should
// expand to memrev.
reverse (v.begin (), v.end ());
}
template<typename T>
void
-uniq (std::vector<T> &v)
+uniq (vector<T> &v)
{
v.erase (unique (v.begin (), v.end ()), v.end ());
}
template<typename T>
-typename std::vector<T>::const_iterator
-find (std::vector<T> const &v, T const &key)
+typename vector<T>::const_iterator
+find (vector<T> const &v, T const &key)
{
return find (v.begin (), v.end (), key);
}
-template<typename T> struct del : public std::unary_function<T, void>
+template<typename T> struct del : public unary_function<T, void>
{
void operator () (T x)
{
template<typename T>
void
-junk_pointers (std::vector<T> &v)
+junk_pointers (vector<T> &v)
{
// Hmm.
for_each (v.begin (), v.end (), del<T> ());
v.clear ();
}
-std::vector<std::string> string_split (std::string str, char c);
-std::string string_join (std::vector<std::string> const &strs, const std::string &infix);
+vector<string> string_split (string str, char c);
+string string_join (vector<string> const &strs, const string &infix);
#define iterof(i,s) typeof((s).begin()) i((s).begin())
/*
PROJECT: FlowerSoft C++ library
- FILE : std::string-convert.hh
+ FILE : string-convert.hh
*/
#ifndef STRING_CONVERT_HH
#define STRING_CONVERT_HH
#include <cstdarg>
+using namespace std;
#include "flower-proto.hh"
#include "std-string.hh"
-/** The functor string_convert handles all conversions to/from std::string
+/** The functor string_convert handles all conversions to/from string
(some time, anyway). The class is quite empty from data view. */
class String_convert
{
- static int hex2bin (std::string hex_string, std::string &bin_string_r);
+ static int hex2bin (string hex_string, string &bin_string_r);
static int hex2nibble (Byte byte);
static Byte nibble2hex_byte (Byte byte);
public:
- static std::string pad_to (const std::string &s, size_t length);
- static std::string bool_string (bool b);
- static std::string bin2hex (Byte bin_char);
- static std::string bin2hex (const std::string &bin_string);
- static int bin2int (const std::string &bin_string);
- static unsigned bin2unsigned (const std::string &bin_string);
- static std::string char_string (char c, int n);
- static int dec2int (const std::string &dec_string);
- static double dec2double (const std::string &dec_string);
- static std::string double_string (double f, char const *fmt = 0);
- static std::string form_string (char const *format, ...) __attribute__ ((format (printf, 1, 2)));
- static std::string vform_string (char const *format, va_list args);
- static std::string hex2bin (const std::string &str);
- static std::string int_string (int i, char const *fmt = 0);
- static std::string unsigned_string (unsigned);
- static std::string unsigned_long_string (unsigned long);
- static std::string long_string (long);
- static std::string int2hex (int i, size_t length_i, char ch);
- static std::string unsigned2hex (unsigned u, size_t length, char ch);
- static std::string int2dec (int i, size_t length_i, char ch);
- static std::string rational_string (Rational);
- static std::string pointer_string (void const *);
- static std::string precision_string (double x, int n);
- static std::string i64_string (I64, char const *fmt = 0);
- static std::string to_lower (std::string s);
- static std::string to_upper (std::string s);
- static std::string reverse (std::string s);
+ static string pad_to (const string &s, size_t length);
+ static string bool_string (bool b);
+ static string bin2hex (Byte bin_char);
+ static string bin2hex (const string &bin_string);
+ static int bin2int (const string &bin_string);
+ static unsigned bin2unsigned (const string &bin_string);
+ static string char_string (char c, int n);
+ static int dec2int (const string &dec_string);
+ static double dec2double (const string &dec_string);
+ static string double_string (double f, char const *fmt = 0);
+ static string form_string (char const *format, ...) __attribute__ ((format (printf, 1, 2)));
+ static string vform_string (char const *format, va_list args);
+ static string hex2bin (const string &str);
+ static string int_string (int i, char const *fmt = 0);
+ static string unsigned_string (unsigned);
+ static string unsigned_long_string (unsigned long);
+ static string long_string (long);
+ static string int2hex (int i, size_t length_i, char ch);
+ static string unsigned2hex (unsigned u, size_t length, char ch);
+ static string int2dec (int i, size_t length_i, char ch);
+ static string rational_string (Rational);
+ static string pointer_string (void const *);
+ static string precision_string (double x, int n);
+ static string i64_string (I64, char const *fmt = 0);
+ static string to_lower (string s);
+ static string to_upper (string s);
+ static string reverse (string s);
};
#endif // __STRING_CONVERT_HH //
#define VIRTUAL_METHODS_HH
#include <typeinfo>
+using namespace std;
/*
Virtual copy constructor. Make up for C++'s lack of a standard
extern bool warning_as_error;
/* output messages, in decreasing order of importance */
-void error (std::string s, const std::string &location = ""); // Fatal error, exits lilypond!
-void programming_error (const std::string &s, const std::string &location = "");
-void non_fatal_error (const std::string&, const std::string &location = "");
-void warning (const std::string &s, const std::string &location = "");
-void basic_progress (const std::string &s, const std::string &location = "");
+void error (string s, const string &location = ""); // Fatal error, exits lilypond!
+void programming_error (const string &s, const string &location = "");
+void non_fatal_error (const string&, const string &location = "");
+void warning (const string &s, const string &location = "");
+void basic_progress (const string &s, const string &location = "");
/* progress_indication does by default *NOT* start on a new line */
-void progress_indication (const std::string &s, bool newline = false, const std::string &location = "");
-void message (const std::string &s, bool newline = true, const std::string &location = "");
-void debug_output (const std::string &s, bool newline = true, const std::string &location = "");
+void progress_indication (const string &s, bool newline = false, const string &location = "");
+void message (const string &s, bool newline = true, const string &location = "");
+void debug_output (const string &s, bool newline = true, const string &location = "");
/* Helper functions that always print out the message. Callers should ensure
that the loglevel is obeyed */
-void print_message (int level, const std::string &location, std::string s, bool newline = true);
+void print_message (int level, const string &location, string s, bool newline = true);
bool is_loglevel (int level);
void set_loglevel (int level);
-void set_loglevel (std::string level);
+void set_loglevel (string level);
-void expect_warning (const std::string &msg);
+void expect_warning (const string &msg);
void check_expected_warnings ();
#endif /* WARN_HH */
if (last[RIGHT] >= iv[LEFT])
// overlapping intervals: merge them
- last[RIGHT] = std::max (last[RIGHT], iv[RIGHT]);
+ last[RIGHT] = max (last[RIGHT], iv[RIGHT]);
else if (!iv.is_empty ())
ret.intervals_.push_back (iv);
}
#include <cctype>
#include <cassert>
+using namespace std;
#include "libc-extension.hh"
#include <cassert>
#include <cstring>
#include <cstdlib>
+using namespace std;
#include "memory-stream.hh"
#include <cmath>
+using namespace std;
using std::vector;
/*
for (vsize i = 0; i < maxmins.size (); i++)
if (maxmins[i] >= l && maxmins[i] <= r)
sols.push_back (eval (maxmins[i]));
- vector_sort (sols, std::less<Real> ());
+ vector_sort (sols, less<Real> ());
return ret_max ? sols.back () : sols[0];
}
#include <cmath>
#include <cassert>
#include <cstdlib>
+using namespace std;
#include "string-convert.hh"
#include "libc-extension.hh"
#include "real.hh"
#include <cmath>
+using namespace std;
#ifdef INFINITY
const Real infinity_f = INFINITY;
string
to_string (char c, int n)
{
- return string (std::max (n, 0), c);
+ return string (max (n, 0), c);
}
string
#include <cstring>
#include <cstdio>
+using namespace std;
#include "libc-extension.hh"
#include "rational.hh"
string
String_convert::precision_string (double x, int n)
{
- string format = "%." + ::to_string (std::max (0, n - 1)) + "e";
+ string format = "%." + ::to_string (max (0, n - 1)) + "e";
string str = double_string (abs (x), format.c_str ());
int exp = dec2int (str.substr (str.length () - 3));
string
String_convert::pad_to (const string &s, size_t n)
{
- return s + string (std::max (int (n - s.length ()), 0), ' ');
+ return s + string (max (int (n - s.length ()), 0), ' ');
}
string
#include "yaffut-parameters.hh"
+using namespace std;
using std::string;
string slashify (string file_name);
char cwd[PATH_MAX];
if (!getcwd (cwd, PATH_MAX))
{
- std::cerr << "Could not get current work directory\n";
+ cerr << "Could not get current work directory\n";
exit (1);
}
string ly_dir = string (getenv ("top-src-dir")) + "/ly";
#include "yaffut.hh"
+using namespace std;
using std::vector;
FUNC (interval_set_union)
#define YAFFUT_MAIN
#include "yaffut.hh"
+using namespace std;
using std::vector;
template<typename T>
print (vector<T> v)
{
for (vsize i = 0; i < v.size (); i++)
- std::cout << "v[" << i << "] = " << v[i] << std::endl;
- std::cout << std::endl;
+ cout << "v[" << i << "] = " << v[i] << endl;
+ cout << endl;
}
FUNC (vector_erase)
v.sort (default_compare);
#else
//sort (v.begin (), v.end ());
- vector_sort (v, std::less<int> ());
+ vector_sort (v, less<int> ());
#endif
EQUAL (v[0], 0);
EQUAL (v[1], 1);
v.push_back (0);
v.push_back (1);
v.push_back (0);
- vector_sort (v, std::less<int> ());
+ vector_sort (v, less<int> ());
uniq (v);
EQUAL (v.size (), vsize (2));
}
v.push_back (0);
v.push_back (1);
v.push_back (2);
- vsize i = binary_search (v, 1, std::less<int> ());
+ vsize i = binary_search (v, 1, less<int> ());
EQUAL (i, vsize (1));
}
#include "yaffut.hh"
+using namespace std;
using std::string;
using std::vector;
#include "std-vector.hh"
#include "international.hh"
+using namespace std;
using std::string;
using std::vector;
Real spec_distance = 0;
if (Page_layout_problem::read_spacing_spec (spec, &spec_distance, ly_symbol2scm ("minimum-distance")))
- dy = std::max (dy, spec_distance);
+ dy = max (dy, spec_distance);
// Consider the likely final spacing when estimating distance between staves of the full score
if (INT_MAX == end && 0 == start
&& Page_layout_problem::read_spacing_spec (spec, &spec_distance, ly_symbol2scm ("basic-distance")))
- dy = std::max (dy, spec_distance);
+ dy = max (dy, spec_distance);
if (include_fixed_spacing && Page_layout_problem::is_spaceable (elems[j]) && last_spaceable_element)
{
Page_layout_problem::read_spacing_spec (spec,
&spaceable_padding,
ly_symbol2scm ("padding"));
- dy = std::max (dy, (last_spaceable_skyline.distance (skyline[-stacking_dir])
+ dy = max (dy, (last_spaceable_skyline.distance (skyline[-stacking_dir])
+ stacking_dir * (last_spaceable_element_pos - where) + spaceable_padding));
Real spaceable_min_distance = 0;
if (Page_layout_problem::read_spacing_spec (spec,
&spaceable_min_distance,
ly_symbol2scm ("minimum-distance")))
- dy = std::max (dy, spaceable_min_distance + stacking_dir * (last_spaceable_element_pos - where));
+ dy = max (dy, spaceable_min_distance + stacking_dir * (last_spaceable_element_pos - where));
- dy = std::max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
+ dy = max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
pure, start, end));
}
}
- dy = std::max (0.0, dy);
+ dy = max (0.0, dy);
down_skyline.raise (-stacking_dir * dy);
down_skyline.merge (skyline[stacking_dir]);
where += stacking_dir * dy;
// The dynamic spanner does not end with an explicit dynamic script
// event. Adjust the end volume by at most 1/4 of the available
// volume range in this case.
- dynamics_.back ()->volume_ = std::max (std::min (start_v + grow_dir_ * (max_volume_ - min_volume_) * 0.25, max_volume_), min_volume_);
+ dynamics_.back ()->volume_ = max (min (start_v + grow_dir_ * (max_volume_ - min_volume_) * 0.25, max_volume_), min_volume_);
}
Real delta_v = dynamics_.back ()->volume_ - dynamics_[0]->volume_;
(to_boolean (stem->get_property ("tuplet-start"))));
stems_->push_back (stem);
last_add_mom_ = now;
- extend_mom_ = std::max (extend_mom_, now) + get_event_length (ev, now);
+ extend_mom_ = max (extend_mom_, now) + get_event_length (ev, now);
if (recheck_needed)
recheck_beam ();
}
d = (d == CENTER) ? UP : d;
Interval_t<int> rank_span = g->spanned_rank_interval ();
- vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], std::less<vsize> ());
+ vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], less<vsize> ());
if (first_break > 0 && ranks[first_break] >= (vsize)rank_span[LEFT])
first_break--;
Axis_group_interface::relative_pure_height (Grob *me, int start, int end)
{
/* It saves a _lot_ of time if we assume a VerticalAxisGroup is additive
- (ie. height (i, k) = std::max (height (i, j) height (j, k)) for all i <= j <= k).
+ (ie. height (i, k) = max (height (i, j) height (j, k)) for all i <= j <= k).
Unfortunately, it isn't always true, particularly if there is a
VerticalAlignment somewhere in the descendants.
for (vsize j = 0; j < other_v_skylines.size (); j++)
{
Skyline_pair const &v_other = other_v_skylines[j];
- Real pad = std::max (padding, other_padding[j]);
- Real horizon_pad = std::max (horizon_padding, other_horizon_padding[j]);
+ Real pad = max (padding, other_padding[j]);
+ Real horizon_pad = max (horizon_padding, other_horizon_padding[j]);
// We need to push elt up by at least this much to be above v_other.
Real up = (*v_skyline)[DOWN].distance (v_other[UP], horizon_pad) + pad;
(*all_paddings)[dir].push_back (padding);
(*all_horizon_paddings)[dir].push_back (horizon_padding);
}
- std::swap (elements, skipped_elements);
+ swap (elements, skipped_elements);
skipped_elements.clear ();
}
}
stem->set_property ("duration-log", scm_from_int (durlog));
Moment stem_location = now - beam_start_mom_ + beam_start_location_;
beam_info_->add_stem (stem_location,
- std::max (durlog - 2, 0),
+ max (durlog - 2, 0),
Stem::is_invisible (stem),
stem_duration->factor (),
(to_boolean (stem->get_property ("tuplet-start"))));
#include <algorithm>
#include <queue>
#include <set>
+using namespace std;
#include "align-interface.hh"
#include "beam.hh"
Real inter = 0.5;
Real hang = 1.0 - (beam_thickness - slt) / 2;
- *dy = sign (*dy) * std::max (fabs (*dy),
- std::min (std::min (sit, inter), hang));
+ *dy = sign (*dy) * max (fabs (*dy),
+ min (min (sit, inter), hang));
}
}
note is reached in the opposite direction as the last-first dy
*/
int dy = positions.back () - positions[0];
- int closest = std::max (beam_dir * positions.back (), beam_dir * positions[0]);
+ int closest = max (beam_dir * positions.back (), beam_dir * positions[0]);
for (vsize i = 2; !concave && i + 1 < positions.size (); i++)
{
int inner_dy = positions[i] - positions[i - 1];
{
Real line_y = slope * i + positions[0];
- concaveness += std::max (beam_dir * (positions[i] - line_y), 0.0);
+ concaveness += max (beam_dir * (positions[i] - line_y), 0.0);
}
concaveness /= positions.size ();
Stem_info info = stem_infos_[i];
Direction d = info.dir_;
- score[d] += limit_penalty * std::max (0.0, (d * (info.shortest_y_ - current_y)));
+ score[d] += limit_penalty * max (0.0, (d * (info.shortest_y_ - current_y)));
Real ideal_diff = d * (current_y - info.ideal_y_);
Real ideal_score = shrink_extra_weight (ideal_diff, 1.5);
/* Divide by number of stems, to make the measure scale-free. */
for (DOWN_and_UP (d))
- score[d] /= std::max (count[d], 1);
+ score[d] /= max (count[d], 1);
/*
sometimes, two perfectly symmetric kneed beams will have the same score
{
Real dy = config->y.delta ();
Real dem = parameters_.MUSICAL_DIRECTION_FACTOR
- * std::max (0.0, (fabs (dy) - fabs (musical_dy_)));
+ * max (0.0, (fabs (dy) - fabs (musical_dy_)));
config->add (dem, "Sm");
}
Real extra_demerit =
parameters_.SECONDARY_BEAM_DEMERIT
- / std::max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]);
+ / max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]);
Real dem = 0.0;
Real eps = parameters_.BEAM_EPS;
k <= staff_radius_ + eps; k += 1.0)
if (gap.contains (k))
{
- Real dist = std::min (fabs (gap[UP] - k), fabs (gap[DOWN] - k));
+ Real dist = min (fabs (gap[UP] - k), fabs (gap[DOWN] - k));
/*
this parameter is tuned to grace-stem-length.ly
config->add (dem, "Fl");
dem = 0.0;
- if (std::max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]) >= 2)
+ if (max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]) >= 2)
{
Real straddle = 0.0;
Real sit = (beam_thickness_ - line_thickness_) / 2;
if (!intersection (beam_y, collision_y).is_empty ())
dist = 0.0;
else
- dist = std::min (beam_y.distance (collision_y[DOWN]),
+ dist = min (beam_y.distance (collision_y[DOWN]),
beam_y.distance (collision_y[UP]));
Real scale_free
- = std::max (parameters_.COLLISION_PADDING - dist, 0.0)
+ = max (parameters_.COLLISION_PADDING - dist, 0.0)
/ parameters_.COLLISION_PADDING;
Real collision_demerit = collisions_[i].base_penalty_ *
pow (scale_free, 3) * parameters_.COLLISION_PENALTY;
for (vsize i = 0; i < stems.size (); i++)
{
Grob *stem = stems[i];
- m = std::max (m, (Stem::beam_multiplicity (stem).length () + 1));
+ m = max (m, (Stem::beam_multiplicity (stem).length () + 1));
}
return m;
}
i != stem_segments.end (); i++)
{
vector<Beam_stem_segment> segs = (*i).second;
- vector_sort (segs, std::less<Beam_stem_segment> ());
+ vector_sort (segs, less<Beam_stem_segment> ());
Beam_segment current;
Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
- length = std::min (length,
+ length = min (length,
fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
}
current.horizontal_[event_dir] += event_dir * length;
for (vsize k = 0; k < heads.size (); k++)
current.horizontal_[event_dir]
- = event_dir * std::min (event_dir * current.horizontal_[event_dir],
+ = event_dir * min (event_dir * current.horizontal_[event_dir],
- gap_length / 2
+ event_dir
* heads[k]->extent (commonx,
for (DOWN_and_UP (d))
{
if (sign (positions[d]) == d)
- extremes[d] = d * std::max (d * positions[d], d * extremes[d]);
+ extremes[d] = d * max (d * positions[d], d * extremes[d]);
}
}
if (stem_dir)
{
count[stem_dir]++;
- total[stem_dir] += std::max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
+ total[stem_dir] += max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
}
}
if (i > 0
&& i + 1 < stems.size ()
&& Stem::is_invisible (stem))
- count = std::min (count, beaming->beamlet_count (i, -d));
+ count = min (count, beaming->beamlet_count (i, -d));
if ( ((i == 0 && d == LEFT)
|| (i == stems.size () - 1 && d == RIGHT))
= staff_space * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
+ robust_scm2double (rest->get_property ("minimum-distance"), 0.0));
- Real shift = d * std::min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
+ Real shift = d * min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
shift /= staff_space;
+ Stem::head_positions (right)[beamdir]) / 2.0
+ 4.0 * beamdir; // four staff-positions
/* and that the closest beam never crosses staff center by more than two positions */
- beam_pos = std::max (-2.0, beam_pos * beamdir) * beamdir;
+ beam_pos = max (-2.0, beam_pos * beamdir) * beamdir;
Real minimum_distance
= ss * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
- me->extent (me, Y_AXIS)[beamdir];
/* Always move by a whole number of staff spaces, always away from the beam */
- offset = floor (std::min (0.0, (offset - previous) / ss * beamdir))
+ offset = floor (min (0.0, (offset - previous) / ss * beamdir))
* ss * beamdir + previous;
return scm_from_double (offset);
Should we take invisible stems into account?
*/
if (get_grob_direction (stems[i]) == d)
- bc = std::max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
+ bc = max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
}
return bc;
int importance = infos_[i + 1].rhythmic_importance_;
int count = (importance < 0 && options.subdivide_beams_)
? subdivide_beam_count
- : std::min (std::min (infos_[i].count (non_flag_dir),
+ : min (min (infos_[i].count (non_flag_dir),
infos_[i + non_flag_dir].count (-non_flag_dir)),
infos_[i - non_flag_dir].count (non_flag_dir));
for (vsize i = 1; i < infos_.size (); i++)
if (infos_[i].invisible_)
{
- int b = std::min (infos_[i].count (LEFT), infos_[i - 1].count (LEFT));
+ int b = min (infos_[i].count (LEFT), infos_[i - 1].count (LEFT));
infos_[i].beam_count_drul_[LEFT] = b;
infos_[i].beam_count_drul_[RIGHT] = b;
}
for (vsize i = infos_.size () - 1; i--;)
if (infos_[i].invisible_)
{
- int b = std::min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT));
+ int b = min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT));
infos_[i].beam_count_drul_[LEFT] = b;
infos_[i].beam_count_drul_[RIGHT] = b;
}
Moment
Beaming_pattern::end_moment (int i) const
{
- Duration dur (2 + std::max (beamlet_count (i, LEFT),
+ Duration dur (2 + max (beamlet_count (i, LEFT),
beamlet_count (i, RIGHT)),
0);
new_pattern = new Beaming_pattern ();
for (vsize j = i + 1; j < infos_.size (); j++)
{
- count = std::max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT));
+ count = max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT));
new_pattern->add_stem (start_moment (j),
count,
invisibility (j),
#include "book.hh"
#include <cstdio>
+using namespace std;
#include "main.hh"
#include "music.hh"
- extents[next_idx][LEFT];
/* should probably junk minimum-space */
else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
- offsets[next_idx] = std::max (extents[idx][RIGHT], distance);
+ offsets[next_idx] = max (extents[idx][RIGHT], distance);
}
else
{
#include <cstdio>
#include <cstdlib>
+using namespace std;
#include "item.hh"
#include "system.hh"
if (beam_)
{
int tremolo_type = robust_scm2int (repeat_->get_property ("tremolo-type"), 1);
- int flags = std::max (0, intlog2 (tremolo_type) - 2);
+ int flags = max (0, intlog2 (tremolo_type) - 2);
int repeat_count = robust_scm2int (repeat_->get_property ("repeat-count"), 1);
- int gap_count = std::min (flags, intlog2 (repeat_count) + 1);
+ int gap_count = min (flags, intlog2 (repeat_count) + 1);
Grob *s = info.grob ();
if (previous_stem_)
*/
#include <cctype>
+using namespace std;
#include "item.hh"
#include "context.hh"
int p = (pit ? pit->steps () : 0) + c0;
- pmax = std::max (pmax, p);
- pmin = std::min (pmin, p);
+ pmax = max (pmax, p);
+ pmin = min (pmin, p);
}
beacon_ = make_item ("ClusterSpannerBeacon", cluster_notes_[0]->self_scm ());
*/
#include <cctype>
+using namespace std;
#include "dot-column.hh"
#include "dots.hh"
Moment now = now_mom ();
Moment musiclen = get_event_length (ev, now);
- note_end_mom_ = std::max (note_end_mom_, (now + musiclen));
+ note_end_mom_ = max (note_end_mom_, (now + musiclen));
do_nothing_until_ = Rational (0, 0);
}
*/
#include <cctype>
+using namespace std;
#include "dot-column.hh"
#include "dots.hh"
Moment now = now_mom ();
Moment musiclen = get_event_length (ev, now);
- rest_end_mom_ = std::max (rest_end_mom_, (now + musiclen));
+ rest_end_mom_ = max (rest_end_mom_, (now + musiclen));
do_nothing_until_ = Rational (0, 0);
}
// the top of next_line's extent.
Real refpoint_dist = tallness_ + refpoint_extent_[DOWN] - next_line.refpoint_extent_[UP];
Real space = next_line.title_ ? title_space_ : space_;
- return std::max (0.0, space - refpoint_dist);
+ return max (0.0, space - refpoint_dist);
}
Line_shape::Line_shape (Interval begin, Interval rest)
Line_shape
Line_shape::piggyback (Line_shape mount, Real padding) const
{
- Real elevation = std::max (begin_[UP] - mount.begin_[DOWN], rest_[UP] - mount.rest_[DOWN]);
+ Real elevation = max (begin_[UP] - mount.begin_[DOWN], rest_[UP] - mount.rest_[DOWN]);
Interval begin = Interval (begin_[DOWN], elevation + mount.begin_[UP] + padding);
Interval rest = Interval (rest_[DOWN], elevation + mount.rest_[UP] + padding);
return Line_shape (begin, rest);
*/
#include <cctype>
+using namespace std;
#include "item.hh"
#include "context.hh"
#include <cstdio>
#include <cmath> // rint
+using namespace std;
#include "custos.hh"
#include "direction.hh"
#include <map>
#include <set>
+using namespace std;
#include "axis-group-interface.hh"
#include "directional-element-interface.hh"
Real off = 0.0;
for (Dot_configuration::const_iterator i (begin ());
i != end (); i++)
- off = std::max (off, problem_->head_skyline_.height ((*i).first));
+ off = max (off, problem_->head_skyline_.height ((*i).first));
return off;
}
*/
#include <cctype>
+using namespace std;
#include "item.hh"
#include "duration.hh"
{
new_event_found_ = true;
Moment stop = now_mom () + get_event_length (ev, now_mom ());
- stop_moment_ = std::max (stop_moment_, stop);
+ stop_moment_ = max (stop_moment_, stop);
// Handle no-continuation here, don't even add it to the already existing
// spanner... This fixes some layout issues (figure will be placed separately)
*/
#include <map>
+using namespace std;
#include "file-name-map.hh"
#include "lily-guile.hh"
#include <cmath>
#include <cctype>
+using namespace std;
#include "dimensions.hh"
#include "modified-font-metric.hh"
#include <cctype>
#include <cstdio>
+using namespace std;
#include "articulations.hh"
#include "context.hh"
#include <cstring>
#include <map>
+using namespace std;
#include "std-string.hh"
#include "lily-guile.hh"
#include <ctype.h>
#include <cstring> /* memset */
#include <glib.h>
+using namespace std;
#include "dimensions.hh"
#include "file-name.hh"
#include "global-context.hh"
#include <cstdio>
+using namespace std;
#include "context-def.hh"
#include "dispatcher.hh"
{
string suffix ("-interface");
string lispy_name = camel_case_to_lisp_identifier (cxx_name);
- vsize end = std::max (int (0), int (lispy_name.length () - suffix.length ()));
+ vsize end = max (int (0), int (lispy_name.length () - suffix.length ()));
if (lispy_name.substr (end) != suffix)
lispy_name += suffix;
void
Grob_pq_engraver::process_acknowledged ()
{
- vector_sort (started_now_, std::less<Grob_pq_entry> ());
+ vector_sort (started_now_, less<Grob_pq_entry> ());
SCM lst = SCM_EOL;
SCM *tail = &lst;
for (vsize i = 0; i < started_now_.size (); i++)
{
Spanner *span_elt = dynamic_cast<Spanner *> (chp[i]);
if (span_elt->get_bound (RIGHT)->break_status_dir () == LEFT)
- broken_bound_padding = std::max (broken_bound_padding,
+ broken_bound_padding = max (broken_bound_padding,
robust_scm2double (span_elt->get_property ("broken-bound-padding"), 0.0));
}
x_points[d] -= d * broken_bound_padding;
for (int j = iv[LEFT]; j <= iv[RIGHT]; j++)
ranks.push_back (j);
}
- vector_sort (ranks, std::less<int> ());
+ vector_sort (ranks, less<int> ());
uniq (ranks);
SCM scm_vec = scm_c_make_vector (ranks.size (), SCM_EOL);
#include "includable-lexer.hh"
#include <sstream>
+using namespace std;
#include "config.hh"
DECLARE_SCHEME_CALLBACK (alignment_callback, (SCM element));
static void add_accidental (Grob *, Grob *, bool, long);
- static std::vector<Grob *> get_relevant_accidentals (std::vector<Grob *> const &elts, Grob *left);
+ static vector<Grob *> get_relevant_accidentals (vector<Grob *> const &elts, Grob *left);
static void split_accidentals (Grob *accs,
- std::vector<Grob *> *break_reminder,
- std::vector<Grob *> *real_acc);
+ vector<Grob *> *break_reminder,
+ vector<Grob *> *real_acc);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
};
DECLARE_SCHEME_CALLBACK (align_to_ideal_distances, (SCM));
static void align_elements_to_minimum_distances (Grob *, Axis a);
static void align_elements_to_ideal_distances (Grob *);
- static std::vector<Real> get_minimum_translations (Grob *, std::vector<Grob *> const &, Axis a);
- static std::vector<Real> get_minimum_translations_without_min_dist (Grob *, std::vector<Grob *> const &, Axis a);
- static std::vector<Real> get_pure_minimum_translations (Grob *, std::vector<Grob *> const &,
+ static vector<Real> get_minimum_translations (Grob *, vector<Grob *> const &, Axis a);
+ static vector<Real> get_minimum_translations_without_min_dist (Grob *, vector<Grob *> const &, Axis a);
+ static vector<Real> get_pure_minimum_translations (Grob *, vector<Grob *> const &,
Axis a, int start, int end);
static void set_ordered (Grob *);
static Axis axis (Grob *);
static Real get_pure_child_y_translation (Grob *, Grob *child, int start, int end);
protected:
- static std::vector<Real> internal_get_minimum_translations (Grob *, std::vector<Grob *> const &,
+ static vector<Real> internal_get_minimum_translations (Grob *, vector<Grob *> const &,
Axis a,
bool include_fixed_spacing,
bool pure, int start, int end);
int pango_dpi_;
#endif
- std::map<std::string, Index_to_charcode_map > filename_charcode_maps_map_;
+ map<string, Index_to_charcode_map > filename_charcode_maps_map_;
All_font_metrics (All_font_metrics const &);
public:
SCM mark_smob () const;
- Index_to_charcode_map const *get_index_to_charcode_map (const std::string &filename,
+ Index_to_charcode_map const *get_index_to_charcode_map (const string &filename,
int face_index,
FT_Face face);
- All_font_metrics (const std::string &search_path);
+ All_font_metrics (const string &search_path);
~All_font_metrics ();
Pango_font *find_pango_font (PangoFontDescription const *description,
Real scale);
- Font_metric *find_font (const std::string &name);
- Open_type_font *find_otf (const std::string &name);
+ Font_metric *find_font (const string &name);
+ Open_type_font *find_otf (const string &name);
SCM font_descriptions () const;
};
#include "lily-guile.hh"
#include "stream-event.hh"
-SCM articulation_list (std::vector<Stream_event *> notes,
- std::vector<Stream_event *> articulations,
+SCM articulation_list (vector<Stream_event *> notes,
+ vector<Stream_event *> articulations,
char const *articulation_name);
#endif /* ARTICULATIONS_HH */
void add_audio_item (Audio_item *i);
Moment when () const;
-
std::vector<Audio_item *> audio_items_;
+ vector<Audio_item *> audio_items_;
Moment when_;
int ticks () const;
protected:
Stream_event *event_;
Translator *origin_trans_;
- std::vector<Context *> origin_contexts (Translator *) const;
+ vector<Context *> origin_contexts (Translator *) const;
Audio_element_info (Audio_element *, Stream_event *);
Audio_element_info ();
{
public:
Direction grow_dir_;
-
std::vector<Audio_dynamic *> dynamics_;
+ vector<Audio_dynamic *> dynamics_;
Real min_volume_;
Real max_volume_;
class Audio_instrument : public Audio_item
{
public:
- Audio_instrument (std::string instrument_string);
+ Audio_instrument (string instrument_string);
- std::string str_;
+ string str_;
};
class Audio_note : public Audio_item
// with tieWaitForNote, there might be a skip between the tied notes!
void tie_to (Audio_note *, Moment skip = 0);
Audio_note *tie_head ();
- virtual std::string to_string () const;
+ virtual string to_string () const;
Pitch pitch_;
Moment length_mom_;
class Audio_piano_pedal : public Audio_item
{
public:
- std::string type_string_;
+ string type_string_;
Direction dir_;
};
MARKER, CUE_POINT
};
- Audio_text (Audio_text::Type type, const std::string &text_string);
+ Audio_text (Audio_text::Type type, const string &text_string);
Type type_;
- std::string text_string_;
+ string text_string_;
};
class Audio_tempo : public Audio_item
bool percussion_;
bool merge_unisons_;
-
std::vector<Audio_item *> audio_items_;
+ vector<Audio_item *> audio_items_;
};
// Subtype to identify a staff that represents the "control track" of a MIDI
DECLARE_SCHEME_CALLBACK (calc_pure_staff_staff_spacing, (SCM, SCM, SCM));
DECLARE_SCHEME_CALLBACK (calc_pure_relevant_grobs, (SCM));
DECLARE_SCHEME_CALLBACK (calc_pure_y_common, (SCM));
- static SCM internal_calc_pure_relevant_grobs (Grob *, const std::string&);
- static Interval relative_group_extent (std::vector<Grob *> const &list,
+ static SCM internal_calc_pure_relevant_grobs (Grob *, const string&);
+ static Interval relative_group_extent (vector<Grob *> const &list,
Grob *common, Axis);
- static Interval relative_maybe_bound_group_extent (std::vector<Grob *> const &list,
+ static Interval relative_maybe_bound_group_extent (vector<Grob *> const &list,
Grob *common, Axis, bool);
static Interval relative_pure_height (Grob *me, int start, int end);
static Interval combine_pure_heights (Grob *me, SCM, int, int);
static void add_element (Grob *me, Grob *);
static void set_axes (Grob *, Axis, Axis);
static bool has_axis (Grob *, Axis);
- static void get_children (Grob *, std::vector<Grob *> *);
+ static void get_children (Grob *, vector<Grob *> *);
static Interval staff_extent (Grob *me, Grob *ref, Axis, Grob *staff, Axis);
static SCM calc_common (Grob *, Axis);
static Real minimum_distance (Grob *, Grob *, Axis);
Interval y;
Real demerits;
#if DEBUG_BEAM_SCORING
- std::string score_card_;
+ string score_card_;
#endif
int next_scorer_todo;
Beam_configuration ();
bool done () const;
- void add (Real demerit, const std::string &reason);
+ void add (Real demerit, const string &reason);
static Beam_configuration *new_config (Interval start,
Interval offset);
};
affine linear in YL and YR. If YL == YR == 0, then we might have
stem_y != 0.0, when we're cross staff.
*/
- std::vector<Stem_info> stem_infos_;
- std::vector<Real> chord_start_y_;
- std::vector<Interval> head_positions_;
- std::vector<Slice> beam_multiplicity_;
- std::vector<bool> is_normal_;
- std::vector<Real> base_lengths_;
- std::vector<Real> stem_xpositions_;
- std::vector<Real> stem_ypositions_;
+ vector<Stem_info> stem_infos_;
+ vector<Real> chord_start_y_;
+ vector<Interval> head_positions_;
+ vector<Slice> beam_multiplicity_;
+ vector<bool> is_normal_;
+ vector<Real> base_lengths_;
+ vector<Real> stem_xpositions_;
+ vector<Real> stem_ypositions_;
bool is_xstaff_;
bool is_knee_;
// Beam_configurations.
Drul_array<Interval> quant_range_;
Real beam_translation_;
- std::vector<Beam_collision> collisions_;
- std::vector<Beam_segment> segments_;
+ vector<Beam_collision> collisions_;
+ vector<Beam_segment> segments_;
vsize first_normal_index ();
vsize last_normal_index ();
void one_scorer (Beam_configuration *config) const;
Beam_configuration *force_score (SCM inspect_quants,
- const std::vector<Beam_configuration *> &configs) const;
+ const vector<Beam_configuration *> &configs) const;
Real y_at (Real x, Beam_configuration const *c) const;
// Scoring functions:
void score_slope_direction (Beam_configuration *config) const;
void score_slope_musical (Beam_configuration *config) const;
void score_stem_lengths (Beam_configuration *config) const;
- void generate_quants (std::vector<Beam_configuration *> *scores) const;
+ void generate_quants (vector<Beam_configuration *> *scores) const;
void score_collisions (Beam_configuration *config) const;
};
static Real get_beam_translation (Grob *me);
static Real get_beam_thickness (Grob *me);
static void connect_beams (Grob *me);
- static std::vector<Beam_segment> get_beam_segments (Grob *me_grob, Grob **common);
+ static vector<Beam_segment> get_beam_segments (Grob *me_grob, Grob **common);
DECLARE_SCHEME_CALLBACK (rest_collision_callback, (SCM element, SCM prev_off));
DECLARE_SCHEME_CALLBACK (pure_rest_collision_callback, (SCM element, SCM, SCM, SCM prev_off));
friend class Beam_scoring_problem;
static Direction get_default_dir (Grob *);
- static std::vector<Beam_segment> get_beam_segments (Grob *);
+ static vector<Beam_segment> get_beam_segments (Grob *);
static void set_stem_directions (Grob *, Direction);
static void consider_auto_knees (Grob *);
static void set_stem_shorten (Grob *);
Beaming_pattern *split_pattern (int idx);
private:
- std::vector<Beam_rhythmic_element> infos_;
+ vector<Beam_rhythmic_element> infos_;
Direction flag_direction (Beaming_options const &, vsize) const;
void find_rhythmic_importance (Beaming_options const &);
void unbeam_invisible_stems ();
Bezier extract (Real, Real) const;
Real get_other_coordinate (Axis a, Real x) const;
- std::vector<Real> get_other_coordinates (Axis a, Real x) const;
- std::vector<Real> solve_point (Axis, Real coordinate) const;
+ vector<Real> get_other_coordinates (Axis a, Real x) const;
+ vector<Real> solve_point (Axis, Real coordinate) const;
Real minmax (Axis, Real, Real, Direction) const;
- std::vector<Real> solve_derivative (Offset) const;
+ vector<Real> solve_derivative (Offset) const;
Interval extent (Axis) const;
Interval control_point_extent (Axis) const;
/*
Bezier curves always have 4 control points. Making this into an
- std::vector<> gives unnecessary overhead, and makes debugging a royal
+ vector<> gives unnecessary overhead, and makes debugging a royal
pain. */
Offset control_[4];
};
-void scale (std::vector<Offset> *array, Real xscale, Real yscale);
-void rotate (std::vector<Offset> *array, Real phi);
-void translate (std::vector<Offset> *array, Offset o);
+void scale (vector<Offset> *array, Real xscale, Real yscale);
+void rotate (vector<Offset> *array, Real phi);
+void translate (vector<Offset> *array, Offset o);
Bezier slur_shape (Real width, Real height_limit,
Real height_proportion);
class Break_alignment_interface
{
public:
- static std::vector<Grob *> ordered_elements (Grob *me);
+ static vector<Grob *> ordered_elements (Grob *me);
static void add_element (Grob *me, Grob *add);
static SCM break_align_order (Item *me);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM element));
DECLARE_CLASSNAME (Change_iterator);
// returns an error message (empty on success)
- static std::string change_to (Music_iterator &it,
- SCM to_type, const std::string &to_id);
+ static string change_to (Music_iterator &it,
+ SCM to_type, const string &to_id);
private:
- void error (const std::string&);
+ void error (const string&);
};
#endif
private:
// implement in derived class to effect a context change
- virtual void change_to (const std::string &id) = 0;
+ virtual void change_to (const string &id) = 0;
private:
// There is no need to protect this in derived_mark() because it is protected
protected:
virtual void build_ligature (Spanner *ligature,
- std::vector<Grob_info> const &primitives) = 0;
+ vector<Grob_info> const &primitives) = 0;
virtual void typeset_ligature (Spanner *ligature,
- std::vector<Grob_info> const &primitives);
+ vector<Grob_info> const &primitives);
virtual void move_related_items_to_column (Item *, Paper_column *, Real);
private:
- void collect_accidentals (Spanner *, std::vector<Grob_info> const &);
+ void collect_accidentals (Spanner *, vector<Grob_info> const &);
};
#endif // COHERENT_LIGATURE_ENGRAVER_HH
struct Column_x_positions
{
- std::vector<Grob *> cols_;
- std::vector<Grob *> loose_cols_;
+ vector<Grob *> cols_;
+ vector<Grob *> loose_cols_;
- std::vector<Real> config_;
+ vector<Real> config_;
Real force_;
bool satisfies_constraints_;
Grob *last_column_;
Real force_;
Line_shape shape_;
- std::vector<Real> footnote_heights_; /* The footnotes at the bottom of the
+ vector<Real> footnote_heights_; /* The footnotes at the bottom of the
page, where each stencil represents
a different footnote. */
- std::vector<Real> in_note_heights_; /* The in-notes under a system,
+ vector<Real> in_note_heights_; /* The in-notes under a system,
where each stencil represents
a different in-note. */
Interval refpoint_extent_; /* The refpoints of the first and last
class Constrained_breaking
{
public:
- std::vector<Column_x_positions> solve (vsize start, vsize end, vsize sys_count);
- std::vector<Column_x_positions> best_solution (vsize start, vsize end);
- std::vector<Line_details> line_details (vsize start, vsize end, vsize sys_count);
+ vector<Column_x_positions> solve (vsize start, vsize end, vsize sys_count);
+ vector<Column_x_positions> best_solution (vsize start, vsize end);
+ vector<Line_details> line_details (vsize start, vsize end, vsize sys_count);
Constrained_breaking (Paper_score *ps);
- Constrained_breaking (Paper_score *ps, std::vector<vsize> const &start_col_posns);
+ Constrained_breaking (Paper_score *ps, vector<vsize> const &start_col_posns);
int max_system_count (vsize start, vsize end);
int min_system_count (vsize start, vsize end);
/* the [i](j,k)th entry is the score for fitting the first k bars onto the
first j systems, starting at the i'th allowed starting column */
- std::vector<Matrix<Constrained_break_node> > state_;
+ vector<Matrix<Constrained_break_node> > state_;
- std::vector<vsize> start_; /* the columns at which we might be asked to start breaking */
- std::vector<vsize> starting_breakpoints_; /* the corresponding index in breaks_ */
+ vector<vsize> start_; /* the columns at which we might be asked to start breaking */
+ vector<vsize> starting_breakpoints_; /* the corresponding index in breaks_ */
- std::vector<Grob *> all_;
- std::vector<vsize> breaks_;
+ vector<Grob *> all_;
+ vector<vsize> breaks_;
void initialize ();
void resize (vsize systems);
VIRTUAL_COPY_CONSTRUCTOR (Context_def, Context_def);
- std::vector<Context_def *> path_to_acceptable_context (SCM type_string,
+ vector<Context_def *> path_to_acceptable_context (SCM type_string,
Output_def *,
SCM) const;
- std::vector<Context_def *> internal_path_to_acceptable_context (SCM type_string,
+ vector<Context_def *> internal_path_to_acceptable_context (SCM type_string,
Output_def *,
SCM,
- std::set<const Context_def *> *seen) const;
+ set<const Context_def *> *seen) const;
Context *instantiate (SCM extra_ops);
SCM to_alist () const;
SCM default_child_;
SCM aliases_;
Translator_group *implementation_;
- std::string id_string_;
+ string id_string_;
/* Events reported in the context is sent to this dispatcher. */
Dispatcher *event_source_;
void unset_property_from_event (SCM);
public:
- std::string id_string () const { return id_string_; }
+ string id_string () const { return id_string_; }
SCM children_contexts () const { return context_list_; }
SCM default_child_context_name () const;
void instrumented_set_property (SCM, SCM, const char *, int, const char *);
void internal_set_property (SCM var_sym, SCM value);
- Context *create_context (Context_def *, const std::string&, SCM);
+ Context *create_context (Context_def *, const string&, SCM);
void create_context_from_event (SCM);
void acknowledge_infant (SCM);
void remove_context (SCM);
void change_parent (SCM);
void disconnect_from_parent ();
void check_removal ();
- std::string context_name () const;
+ string context_name () const;
SCM context_name_symbol () const;
Global_context *get_global_context () const;
virtual Context *get_score_context () const;
virtual Output_def *get_output_def () const;
virtual Moment now_mom () const;
- virtual Context *get_default_interpreter (const std::string &context_id = "");
+ virtual Context *get_default_interpreter (const string &context_id = "");
bool is_alias (SCM) const;
void add_alias (SCM);
bool is_removable () const;
Context *find_create_context (SCM context_name,
- const std::string &id, SCM ops);
- Context *create_unique_context (SCM context_name, const std::string &context_id,
+ const string &id, SCM ops);
+ Context *create_unique_context (SCM context_name, const string &context_id,
SCM ops);
- std::vector<Context_def *> path_to_acceptable_context (SCM alias) const;
+ vector<Context_def *> path_to_acceptable_context (SCM alias) const;
};
/*
// context and moving toward the leaves of the tree. If the starting context
// matches, it is returned. An empty ID matches any context of the given type.
Context *find_context_below (Context *where,
- SCM type_sym, const std::string &id);
+ SCM type_sym, const string &id);
// Search for a context of the given type and ID starting with the given
// context, then searching its descendants, then its parent's descendants, etc.
// An empty ID matches any context of the given type.
Context *find_context_near (Context *where,
- SCM type_sym, const std::string &id);
+ SCM type_sym, const string &id);
// Search for the top context (i.e. the ancestor with no parent) starting with
// the given context.
#endif
-std::string print_dimen (Real);
+string print_dimen (Real);
const Real point_constant = 1 PT;
const Real inch_constant = 1 INCH;
const Real cm_constant = 1 CM;
}
};
-struct Dot_configuration : public std::map<int, Dot_position>
+struct Dot_configuration : public map<int, Dot_position>
{
Dot_formatting_problem const *problem_;
void register_configuration (Dot_configuration const &);
Dot_configuration *best () const;
- Dot_formatting_problem (std::vector<Box> const &boxes, Interval base_x);
+ Dot_formatting_problem (vector<Box> const &boxes, Interval base_x);
~Dot_formatting_problem ();
};
Duration ();
Duration (int, int);
Duration (Rational, bool scale);
- std::string to_string () const;
+ string to_string () const;
Duration compressed (Rational) const;
Rational get_length () const;
class Engraver_group : public Translator_group
{
protected:
- std::vector<Grob_info> announce_infos_;
+ vector<Grob_info> announce_infos_;
Drul_array<SCM> acknowledge_hash_table_drul_;
void override (SCM);
void revert (SCM);
#include "std-string.hh"
-std::string map_file_name (const std::string &s);
+string map_file_name (const string &s);
#endif /* FILE_NAME_MAP_HH */
public:
SCM description_;
- std::string file_name_;
+ string file_name_;
- // Return stencil for given std::string. output_state may be modified to
+ // Return stencil for given string. output_state may be modified to
// record the font.
virtual Stencil text_stencil (Output_def *output_state,
- const std::string &text, bool music) const;
+ const string &text, bool music) const;
- virtual std::string font_name () const;
+ virtual string font_name () const;
virtual size_t count () const;
- virtual Offset attachment_point (const std::string&) const;
+ virtual Offset attachment_point (const string&) const;
virtual Offset get_indexed_wxwy (size_t) const;
virtual Box get_indexed_char_dimensions (size_t index) const;
- virtual size_t name_to_index (std::string) const=0;
+ virtual size_t name_to_index (string) const=0;
virtual size_t index_to_charcode (size_t) const;
virtual Real design_size () const;
- virtual Stencil find_by_name (std::string) const;
+ virtual Stencil find_by_name (string) const;
virtual SCM sub_fonts () const;
virtual SCM font_file_name () const;
void init_freetype ();
extern FT_Library freetype2_library;
-std::string freetype_error_string (FT_Error code);
+string freetype_error_string (FT_Error code);
SCM box_to_scheme_lines (Box b);
Box ly_FT_get_unscaled_indexed_char_dimensions (FT_Face const &face, size_t signed_idx);
virtual SCM get_output ();
virtual Output_def *get_output_def () const;
virtual Moment now_mom () const;
- virtual Context *get_default_interpreter (const std::string &context_id = "");
+ virtual Context *get_default_interpreter (const string &context_id = "");
Moment previous_moment () const;
protected:
virtual void listen_pes_or_flexa (Stream_event *ev);
virtual void build_ligature (Spanner *ligature,
- std::vector<Grob_info> const &primitives);
+ vector<Grob_info> const &primitives);
virtual void transform_heads (Spanner *ligature,
- std::vector<Grob_info> const &primitives) = 0;
+ vector<Grob_info> const &primitives) = 0;
void stop_translation_timestep ();
};
class Gregorian_ligature
{
public:
- static std::string prefixes_to_str (Grob *);
+ static string prefixes_to_str (Grob *);
};
/*
SCM mark_smob () const;
static const char type_p_name_[];
private:
- std::vector<Grob *> grobs_;
+ vector<Grob *> grobs_;
bool ordered_;
void remove_duplicates ();
void clear ();
void add (Grob *x) { grobs_.push_back (x); }
- void set_array (std::vector<Grob *> const &src);
- std::vector<Grob *> &array_reference ();
- std::vector<Grob *> const &array () const;
+ void set_array (vector<Grob *> const &src);
+ vector<Grob *> &array_reference ();
+ vector<Grob *> const &array () const;
static SCM make_array ();
};
-std::vector<Grob *> const &ly_scm2link_array (SCM x);
+vector<Grob *> const &ly_scm2link_array (SCM x);
SCM grob_list_to_grob_array (SCM lst);
SCM grob_array_to_list (Grob_array *array);
Context *context () const;
Stream_event *event_cause () const;
Stream_event *ultimate_event_cause () const;
- std::vector<Context *> origin_contexts (Translator *) const;
+ vector<Context *> origin_contexts (Translator *) const;
Grob_info (Translator *, Grob *);
Grob_info ();
bool is_live () const;
/* naming. */
- std::string name () const;
+ string name () const;
/* Properties */
SCM get_property_alist_chain (SCM) const;
void internal_set_property (SCM sym, SCM val);
/* messages */
- void warning (const std::string&) const;
- void programming_error (const std::string&) const;
+ void warning (const string&) const;
+ void programming_error (const string&) const;
/* class hierarchy */
virtual System *get_system () const;
}
/* unification */
-void uniquify (std::vector <Grob *> &);
+void uniquify (vector <Grob *> &);
/* refpoints */
Grob *common_refpoint_of_list (SCM elt_list, Grob *, Axis a);
-Grob *common_refpoint_of_array (std::vector<Grob *> const &, Grob *, Axis a);
-Grob *common_refpoint_of_array (std::set<Grob *> const &, Grob *, Axis a);
+Grob *common_refpoint_of_array (vector<Grob *> const &, Grob *, Axis a);
+Grob *common_refpoint_of_array (set<Grob *> const &, Grob *, Axis a);
System *get_root_system (Grob *me);
/* extents */
DECLARE_SCHEME_CALLBACK (print, (SCM));
static Stencil make_bracket (Grob *, Real, Axis, Direction);
static Stencil make_enclosing_bracket (Grob *me, Grob *refpoint,
- std::vector<Grob *> grobs,
+ vector<Grob *> grobs,
Axis a, Direction dir);
};
*/
class Includable_lexer : public yyFlexLexer
{
- std::vector<YY_BUFFER_STATE> state_stack_;
+ vector<YY_BUFFER_STATE> state_stack_;
protected:
bool close_input ();
- std::vector<Source_file *> include_stack_;
- std::vector<int> char_count_stack_;
+ vector<Source_file *> include_stack_;
+ vector<int> char_count_stack_;
public:
Includable_lexer ();
~Includable_lexer ();
- std::string main_input_name_;
+ string main_input_name_;
/// store dependencies for Makefile stuff.
- std::vector<std::string> file_name_strings_;
+ vector<string> file_name_strings_;
Source_file *get_source_file () const;
- virtual void new_input (const std::string &s, Sources *);
+ virtual void new_input (const string &s, Sources *);
- void new_input (const std::string &name, std::string data, Sources *);
+ void new_input (const string &name, string data, Sources *);
char const *here_str0 () const;
};
char const *end () const;
void set (Source_file *, char const *, char const *);
- void error (const std::string&) const;
- void programming_error (const std::string&) const;
- void non_fatal_error (const std::string&) const;
- void warning (const std::string&) const;
- void message (const std::string&) const;
- void debug_output (const std::string&) const;
+ void error (const string&) const;
+ void programming_error (const string&) const;
+ void non_fatal_error (const string&) const;
+ void warning (const string&) const;
+ void message (const string&) const;
+ void debug_output (const string&) const;
void set_spot (Input const &);
void step_forward ();
void set_location (Input const &, Input const &);
Input spot () const;
- std::string location_string () const;
- std::string line_number_string () const;
- std::string file_string ()const;
+ string location_string () const;
+ string line_number_string () const;
+ string file_string ()const;
int line_number ()const;
int column_number ()const;
Input (Input const &i);
Input ();
protected:
- std::string message_location () const;
- std::string message_string (const std::string &msg) const;
+ string message_location () const;
+ string message_string (const string &msg) const;
};
extern Input dummy_input_global;
void solve ();
private:
- std::vector<Interval> forbidden_intervals_;
+ vector<Interval> forbidden_intervals_;
Interval feasible_placements_;
Real bulk_;
};
*/
struct Keyword_table
{
- std::vector<Keyword_ent> table_;
+ vector<Keyword_ent> table_;
Keyword_table (Keyword_ent *);
vsize lookup (char const *s) const;
/**
Least squares minimisation in 2 variables.
*/
-void minimise_least_squares (Real *coef, Real *offset, std::vector<Offset> const &);
+void minimise_least_squares (Real *coef, Real *offset, vector<Offset> const &);
#endif // LEASTSQUARE_HH
void process_music ();
virtual Spanner *create_ligature_spanner () = 0;
virtual void typeset_ligature (Spanner *ligature,
- std::vector<Grob_info> const &primitives) = 0;
+ vector<Grob_info> const &primitives) = 0;
virtual Spanner *current_ligature ();
SCM brew_ligature_primitive_proc;
Drul_array<Stream_event *> events_drul_;
Spanner *ligature_;
- std::vector<Grob_info> primitives_;
+ vector<Grob_info> primitives_;
Spanner *finished_ligature_;
- std::vector<Grob_info> finished_primitives_;
+ vector<Grob_info> finished_primitives_;
Stream_event *prev_start_event_;
#if GUILEV2
// if Guile's internal representation switches to utf8, this should be
// changed accordingly for efficiency's sake. This is used for
-// strings known to be in ASCII entirely, including any std::string
+// strings known to be in ASCII entirely, including any string
// constants in the C code.
#define scm_from_ascii_string scm_from_latin1_string
#define scm_from_ascii_stringn scm_from_latin1_stringn
}
/* Using this trick we cache the value of scm_from_locale_symbol ("fooo") where
- "fooo" is a constant std::string. This is done at the cost of one static
+ "fooo" is a constant string. This is done at the cost of one static
variable per ly_symbol2scm() use, and one boolean evaluation for
every call.
*/
static SCM NAME ARGS; \
static SCM NAME ## _proc
-std::string mangle_cxx_identifier (std::string);
+string mangle_cxx_identifier (string);
-void ly_add_type_predicate (void *ptr, const std::string &name);
-std::string predicate_to_typename (void *ptr);
+void ly_add_type_predicate (void *ptr, const string &name);
+string predicate_to_typename (void *ptr);
/*
Make TYPE::FUNC available as a Scheme function.
void \
TYPE ## _ ## FUNC ## _init_functions () \
{ \
- std::string cxx = std::string (#TYPE) + "::" + std::string (#FUNC); \
- std::string id = mangle_cxx_identifier (cxx); \
+ string cxx = string (#TYPE) + "::" + string (#FUNC); \
+ string id = mangle_cxx_identifier (cxx); \
TYPE ::FUNC ## _proc = scm_c_define_gsubr (id.c_str(), \
(ARGCOUNT-OPTIONAL_COUNT), OPTIONAL_COUNT, 0, \
(scm_t_subr) TYPE::FUNC); \
#define MAKE_SCHEME_CALLBACK(TYPE, FUNC, ARGCOUNT) \
MAKE_SCHEME_CALLBACK_WITH_OPTARGS(TYPE,FUNC,ARGCOUNT, 0, "");
-void ly_add_function_documentation (SCM proc, const std::string &fname, const std::string &varlist, const std::string &doc);
-void ly_check_name (const std::string &cxx, const std::string &fname);
+void ly_add_function_documentation (SCM proc, const string &fname, const string &varlist, const string &doc);
+void ly_check_name (const string &cxx, const string &fname);
#define ADD_SCM_INIT_FUNC(name, func) \
class name ## _scm_initter \
A ly_B2A (B b); */
SCM ly_last (SCM list);
-std::string ly_scm_write_string (SCM s);
+string ly_scm_write_string (SCM s);
SCM ly_deep_copy (SCM);
SCM ly_truncate_list (int k, SCM lst);
-std::string gulp_file_to_string (const std::string &fn, bool must_exist, int size);
+string gulp_file_to_string (const string &fn, bool must_exist, int size);
-SCM ly_string2scm (std::string const &s);
-std::string ly_scm2string (SCM s);
-std::string ly_symbol2string (SCM);
-std::string robust_symbol2string (SCM, const std::string&);
+SCM ly_string2scm (string const &s);
+string ly_scm2string (SCM s);
+string ly_symbol2string (SCM);
+string robust_symbol2string (SCM, const string&);
Rational ly_scm2rational (SCM);
SCM ly_rational2scm (Rational);
SCM ly_offset2scm (Offset);
Drul_array<bool> robust_scm2booldrul (SCM, Drul_array<bool>);
Interval robust_scm2interval (SCM, Drul_array<Real>);
Offset robust_scm2offset (SCM, Offset);
-std::string robust_scm2string (SCM, const std::string&);
+string robust_scm2string (SCM, const string&);
Rational robust_scm2rational (SCM, Rational);
-std::vector<Real> ly_scm2floatvector (SCM);
-SCM ly_floatvector2scm (std::vector<Real> v);
+vector<Real> ly_scm2floatvector (SCM);
+SCM ly_floatvector2scm (vector<Real> v);
SCM ly_quote_scm (SCM s);
bool type_check_assignment (SCM val, SCM sym, SCM type_symbol);
-std::string print_scm_val (SCM val);
+string print_scm_val (SCM val);
SCM ly_number2string (SCM s);
SCM parse_symbol_list (char const *);
void ly_display_scm (SCM s);
}
-void read_lily_scm_file (std::string);
+void read_lily_scm_file (string);
void ly_c_init_guile ();
bool is_direction (SCM s);
template<class T>
SCM
-ly_cxx_vector_to_list (std::vector<T> const &src)
+ly_cxx_vector_to_list (vector<T> const &src)
{
SCM l = SCM_EOL;
for (vsize i = src.size (); i--;)
return l;
}
-SCM ly_offsets2scm (std::vector<Offset> os);
-std::vector<Offset> ly_scm2offsets (SCM s);
+SCM ly_offsets2scm (vector<Offset> os);
+vector<Offset> ly_scm2offsets (SCM s);
/* For backward compatability with Guile 1.8 */
#if !HAVE_GUILE_HASH_FUNC
static const char type_p_name_[];
virtual ~Lily_lexer ();
private:
- int lookup_keyword (const std::string&);
- int scan_bare_word (const std::string&);
- int scan_escaped_word (const std::string&);
- int scan_shorthand (const std::string&);
+ int lookup_keyword (const string&);
+ int scan_bare_word (const string&);
+ int scan_escaped_word (const string&);
+ int scan_shorthand (const string&);
int scan_scm_id (SCM);
int identifier_type (SCM);
char escaped_char (char) const;
void start_main_input ();
- virtual void new_input (const std::string &s, Sources *);
- virtual void new_input (const std::string &s, std::string d, Sources *);
+ virtual void new_input (const string &s, Sources *);
+ virtual void new_input (const string &s, string d, Sources *);
bool top_input () { return include_stack_.size () < 2; }
SCM keyword_list () const;
- SCM lookup_identifier (const std::string &s);
+ SCM lookup_identifier (const string &s);
SCM lookup_identifier_symbol (SCM s);
void push_extra_token (Input const &where,
int token_type, SCM scm = SCM_UNSPECIFIED);
Sources *sources_;
Duration default_duration_;
int default_tremolo_type_;
- std::string output_basename_;
+ string output_basename_;
SCM closures_;
int fatal_error_;
void clear ();
void do_init_file ();
- void include_string (const std::string &ly_code);
- void parse_file (const std::string &init, const std::string &name, const std::string &out_name);
- void parse_string (const std::string &ly_code);
- SCM parse_string_expression (const std::string &ly_code, const std::string &filename, int line);
- void parser_error (const std::string&);
- void parser_error (Input const &, const std::string&);
+ void include_string (const string &ly_code);
+ void parse_file (const string &init, const string &name, const string &out_name);
+ void parse_string (const string &ly_code);
+ SCM parse_string_expression (const string &ly_code, const string &filename, int line);
+ void parser_error (const string&);
+ void parser_error (Input const &, const string&);
// The following is called as yyerror
- static void parser_error (Input const *i, Lily_parser *parser, SCM *, const std::string &s);
+ static void parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s);
void set_yydebug (bool);
SCM make_scope () const;
#include "std-string.hh"
-std::string version_string ();
-std::string gnu_lilypond_string ();
-std::string gnu_lilypond_version_string ();
+string version_string ();
+string gnu_lilypond_string ();
+string gnu_lilypond_version_string ();
#endif // LILY_VERSION_HH
struct Lilypond_version
{
Lilypond_version (int major, int minor, int patch);
- Lilypond_version (const std::string &str);
+ Lilypond_version (const string &str);
- std::string to_string () const;
+ string to_string () const;
operator bool () const;
static int compare (const Lilypond_version &, const Lilypond_version &);
int major_;
int minor_;
int patch_;
- std::string extra_patch_string_;
+ string extra_patch_string_;
};
INSTANTIATE_COMPARE (const Lilypond_version &, Lilypond_version::compare);
static Stencil bracket (Axis a, Interval iv, Real thick, Real protrude, Real blot);
static Stencil circle (Real rad, Real thick, bool filled);
static Stencil rotated_box (Real slope, Real width, Real thick, Real blot);
- static Stencil round_filled_polygon (std::vector<Offset> const &points, Real blotdiameter);
+ static Stencil round_filled_polygon (vector<Offset> const &points, Real blotdiameter);
static Stencil frame (Box b, Real thick, Real blot);
static Stencil slur (Bezier controls, Real cthick, Real thick,
SCM dash_definition);
static Stencil repeat_slash (Real w, Real slope, Real th);
static Stencil horizontal_line (Interval w, Real th);
static Stencil triangle (Interval iv, Real thick, Real protrude);
- static Stencil points_to_line_stencil (Real thick, std::vector<Offset> const &points);
+ static Stencil points_to_line_stencil (Real thick, vector<Offset> const &points);
};
#endif // LOOKUP_HH
void clear_scores ();
void add_score (Score *s);
void call_constructors ();
-std::vector<std::string> get_inclusion_names ();
-void set_inclusion_names (std::vector<std::string>);
+vector<string> get_inclusion_names ();
+void set_inclusion_names (vector<string>);
-extern std::string init_name_global;
+extern string init_name_global;
/* options */
-extern std::vector<std::string> dump_header_fieldnames_global;
-extern std::vector<std::string> start_environment_global;
-extern std::string output_backend_global;
-extern std::string output_name_global;
+extern vector<string> dump_header_fieldnames_global;
+extern vector<string> start_environment_global;
+extern string output_backend_global;
+extern string output_name_global;
extern bool bigpdfs;
extern bool be_safe_global;
extern bool do_internal_type_checking_global;
-extern std::string lilypond_datadir;
+extern string lilypond_datadir;
extern bool use_object_keys;
extern bool strict_infinity_checking;
-extern std::string init_scheme_code_global;
-extern std::string init_scheme_variables_global;
+extern string init_scheme_code_global;
+extern string init_scheme_variables_global;
/*
todo: collect in Output_option struct?
*/
-extern std::string output_format_global;
+extern string output_format_global;
/* misc */
-extern std::vector<std::string> failed_files;
+extern vector<string> failed_files;
extern int exit_status_global;
extern File_path global_path;
extern const char *LILYPOND_DATADIR;
int delta_ticks_;
Midi_item *midi_;
- std::string to_string () const;
+ string to_string () const;
};
/**
class Midi_chunk
{
public:
- void set (const std::string &header_string, const std::string &data_string, const std::string &footer_string);
- virtual std::string to_string () const;
- virtual std::string data_string () const;
+ void set (const string &header_string, const string &data_string, const string &footer_string);
+ virtual string to_string () const;
+ virtual string data_string () const;
DECLARE_CLASSNAME (Midi_chunk);
virtual ~Midi_chunk ();
private:
- std::string data_string_;
- std::string footer_string_;
- std::string header_string_;
+ string data_string_;
+ string footer_string_;
+ string header_string_;
};
class Midi_header : public Midi_chunk
int port_;
DECLARE_CLASSNAME (Midi_track);
- std::vector<Midi_event *> events_;
+ vector<Midi_event *> events_;
Midi_track (int number, bool port);
~Midi_track ();
void add (int, Midi_item *midi);
- virtual std::string data_string () const;
+ virtual string data_string () const;
};
#endif /* MIDI_CHUNK_HH */
#include "audio-item.hh"
#include "std-vector.hh"
-std::string int2midi_varint_string (int i);
+string int2midi_varint_string (int i);
/**
Any piece of midi information.
static Midi_item *get_midi (Audio_item *a);
- virtual std::string to_string () const = 0;
+ virtual string to_string () const = 0;
};
class Midi_channel_item : public Midi_item
DECLARE_CLASSNAME (Midi_control_function_value_change);
Midi_control_function_value_change (Audio_control_function_value_change *ai);
virtual ~Midi_control_function_value_change ();
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_control_function_value_change::Control control_;
Real value_;
};
public:
Midi_duration (Real seconds_f);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Real seconds_;
};
Midi_instrument (Audio_instrument *);
DECLARE_CLASSNAME (Midi_instrument);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_instrument *audio_;
};
Midi_key (Audio_key *);
DECLARE_CLASSNAME (Midi_key);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_key *audio_;
};
Midi_time_signature (Audio_time_signature *);
DECLARE_CLASSNAME (Midi_time_signature);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_time_signature *audio_;
int clocks_per_1_;
int get_semitone_pitch () const;
int get_fine_tuning () const;
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_note *audio_;
Midi_note_off (Midi_note *);
DECLARE_CLASSNAME (Midi_note_off);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Midi_note *on_;
Byte aftertouch_byte_;
Midi_text (Audio_text *);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_text *audio_;
};
Midi_dynamic (Audio_dynamic *);
DECLARE_CLASSNAME (Midi_dynamic);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_dynamic *audio_;
};
Midi_piano_pedal (Audio_piano_pedal *);
DECLARE_CLASSNAME (Midi_piano_pedal);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_piano_pedal *audio_;
};
Midi_tempo (Audio_tempo *);
DECLARE_CLASSNAME (Midi_tempo);
- virtual std::string to_string () const;
+ virtual string to_string () const;
Audio_tempo *audio_;
};
#define MIDI_STREAM_HH
#include <cstdio>
+using namespace std;
#include <string.h>
#include "std-string.hh"
struct Midi_stream
{
- Midi_stream (const std::string &file_name_string);
+ Midi_stream (const string &file_name_string);
~Midi_stream ();
- void write (const std::string&);
+ void write (const string&);
void write (Midi_chunk const &);
void open ();
FILE *out_file_;
- std::string file_name_string_;
+ string file_name_string_;
};
#endif // MIDI_STREAM_HH
bool percussion_;
bool merge_unisons_;
vsize index_;
-
std::vector<Audio_item *> items_;
+ vector<Audio_item *> items_;
PQueue<Midi_note_event> stop_note_queue;
int last_tick_;
- std::vector<Midi_item *> midi_events_;
+ vector<Midi_item *> midi_events_;
};
#endif // MIDI_WALKER_HH
#define MISC_HH
#include <cstdlib>
+using namespace std;
#include "std-vector.hh"
#include "interval.hh"
Real peak_around (Real epsilon, Real threshold, Real x);
Real convex_amplifier (Real standard_x, Real increase_factor, Real x);
-std::string camel_case_to_lisp_identifier (const std::string &in);
+string camel_case_to_lisp_identifier (const string &in);
#endif
struct Modified_font_metric : public Font_metric
{
public:
- Stencil text_stencil (Output_def *output_state, const std::string&, bool) const;
+ Stencil text_stencil (Output_def *output_state, const string&, bool) const;
Real get_magnification () const;
static SCM make_scaled_font_metric (Font_metric *fm, Real magnification);
size_t count () const;
Offset get_indexed_wxwy (size_t) const;
- Offset attachment_point (const std::string&) const;
- size_t name_to_index (std::string) const;
+ Offset attachment_point (const string&) const;
+ size_t name_to_index (string) const;
size_t index_to_charcode (size_t) const;
Font_metric *original_font () const;
Modified_font_metric (Font_metric *fm, Real magnification);
SCM sub_fonts () const;
- std::string font_name () const;
+ string font_name () const;
Real design_size () const;
void derived_mark () const;
Box get_indexed_char_dimensions (size_t) const;
/*
Deliver a copy of THIS as a smobified SCM
*/
- std::string to_string () const;
+ string to_string () const;
static int compare (Moment const &, Moment const &);
SCM as_scheme () const;
};
#define IMPLEMENT_CTOR_CALLBACK(Class) \
LY_DEFINE_MEMBER_FUNCTION (Class, constructor, \
- mangle_cxx_identifier (std::string (#Class) + "::constructor").c_str(), \
+ mangle_cxx_identifier (string (#Class) + "::constructor").c_str(), \
0, 0, 0, \
(), \
"") \
class Note_collision_interface
{
public:
- static SCM automatic_shift (Grob *, Drul_array<std::vector<Grob *> >);
+ static SCM automatic_shift (Grob *, Drul_array<vector<Grob *> >);
static SCM forced_shift (Grob *);
- static std::vector<int> note_head_positions (Grob *me);
- static Drul_array<std::vector<Grob *> > get_clash_groups (Grob *me);
+ static vector<int> note_head_positions (Grob *me);
+ static Drul_array<vector<Grob *> > get_clash_groups (Grob *me);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM smob));
static void add_column (Grob *me, Grob *ncol);
};
static Real stem_attachment_coordinate (Grob *, Axis a);
static int get_balltype (Grob *);
- static Offset get_stem_attachment (Font_metric *, const std::string&);
+ static Offset get_stem_attachment (Font_metric *, const string&);
};
#endif // NOTEHEAD_HH
SCM glyph_list () const;
SCM get_glyph_outline (size_t signed_idx) const;
Box get_glyph_outline_bbox (size_t signed_idx) const;
- std::string get_otf_table (const std::string &tag) const;
- static SCM make_otf (const std::string&);
- std::string font_name () const;
+ string get_otf_table (const string &tag) const;
+ static SCM make_otf (const string&);
+ string font_name () const;
~Open_type_font ();
- Offset attachment_point (const std::string&) const;
+ Offset attachment_point (const string&) const;
size_t count () const;
Box get_indexed_char_dimensions (size_t) const;
Box get_unscaled_indexed_char_dimensions (size_t) const;
- size_t name_to_index (std::string) const;
+ size_t name_to_index (string) const;
size_t index_to_charcode (size_t) const;
void derived_mark () const;
SCM sub_fonts () const;
Real design_size () const;
};
-std::string get_otf_table (FT_Face face, const std::string &tag);
-FT_Face open_ft_face (const std::string&, FT_Long idx);
+string get_otf_table (FT_Face face, const string &tag);
+FT_Face open_ft_face (const string&, FT_Long idx);
#endif /* OPEN_TYPE_FONT_HH */
/*
variables.
*/
- SCM c_variable (const std::string &id) const;
+ SCM c_variable (const string &id) const;
SCM lookup_variable (SCM sym) const;
void set_variable (SCM sym, SCM val);
void normalize ();
public:
typedef bool (*Break_predicate) (Grob *);
typedef bool (*Prob_break_predicate) (Prob *);
- typedef std::vector<vsize> Line_division;
+ typedef vector<vsize> Line_division;
/*
TODO: naming.
vsize next_system (Break_position const &break_pos) const;
- SCM make_pages (std::vector<vsize> lines_per_page, SCM lines);
+ SCM make_pages (vector<vsize> lines_per_page, SCM lines);
vsize min_system_count (vsize start, vsize end);
vsize max_system_count (vsize start, vsize end);
vsize last_break_position () const;
- std::vector<System_spec> system_specs_;
+ vector<System_spec> system_specs_;
private:
- std::vector<Break_position> breaks_;
- std::vector<Break_position> chunks_;
- std::vector<Constrained_breaking> line_breaking_;
+ vector<Break_position> breaks_;
+ vector<Break_position> chunks_;
+ vector<Constrained_breaking> line_breaking_;
bool ragged_;
bool ragged_last_;
int systems_per_page_;
Real footnote_footer_padding_;
int orphan_penalty_;
- std::vector<Line_division> current_configurations_;
- std::vector<Break_position> current_chunks_;
+ vector<Line_division> current_configurations_;
+ vector<Break_position> current_chunks_;
vsize current_start_breakpoint_;
vsize current_end_breakpoint_;
void compute_line_heights ();
void clear_line_details_cache ();
vsize cached_configuration_index_;
- std::vector<Line_details> cached_line_details_;
- std::vector<Line_details> uncompressed_line_details_;
+ vector<Line_details> cached_line_details_;
+ vector<Line_details> uncompressed_line_details_;
Real paper_height_;
- mutable std::vector<Real> page_height_cache_;
- mutable std::vector<Real> last_page_height_cache_;
+ mutable vector<Real> page_height_cache_;
+ mutable vector<Real> last_page_height_cache_;
- std::vector<Break_position> chunk_list (vsize start, vsize end);
- Line_division system_count_bounds (std::vector<Break_position> const &chunks, bool min);
+ vector<Break_position> chunk_list (vsize start, vsize end);
+ Line_division system_count_bounds (vector<Break_position> const &chunks, bool min);
void line_breaker_args (vsize i,
Break_position const &start,
Break_position const &end,
Line_division const &max,
Line_division *cur);
- std::vector<Line_details> line_details (vsize start, vsize end, Line_division const &div);
- Page_spacing_result space_systems_on_1_page (std::vector<Line_details> const &lines, Real page_height, bool ragged);
+ vector<Line_details> line_details (vsize start, vsize end, Line_division const &div);
+ Page_spacing_result space_systems_on_1_page (vector<Line_details> const &lines, Real page_height, bool ragged);
Page_spacing_result space_systems_on_2_pages (vsize configuration_index, vsize first_page_num);
Page_spacing_result finalize_spacing_result (vsize configuration_index, Page_spacing_result);
void create_system_list ();
static bool read_spacing_spec (SCM spec, Real *dest, SCM sym);
static bool is_spaceable (Grob *g);
static SCM get_details (Grob *g);
- static std::vector<Grob *> get_footnote_grobs (SCM lines);
+ static vector<Grob *> get_footnote_grobs (SCM lines);
static vsize get_footnote_count (SCM lines);
static SCM get_footnotes_from_lines (SCM lines);
static void add_footnotes_to_lines (SCM lines, int counter, Paper_book *pb);
void solve_rod_spring_problem (bool ragged, Real fixed_force);
SCM find_system_offsets ();
- void distribute_loose_lines (std::vector<Grob *> const &, std::vector<Real> const &, Real, Real);
+ void distribute_loose_lines (vector<Grob *> const &, vector<Real> const &, Real, Real);
- static void build_system_skyline (std::vector<Grob *> const &, std::vector<Real> const &, Skyline *up, Skyline *down);
- static std::vector<Grob *> filter_dead_elements (std::vector<Grob *> const &);
+ static void build_system_skyline (vector<Grob *> const &, vector<Real> const &, Skyline *up, Skyline *down);
+ static vector<Grob *> filter_dead_elements (vector<Grob *> const &);
// This is a union (in spirit).
// Either staves must be empty or prob must be null.
typedef struct Element
{
Prob *prob;
- std::vector<Grob *> staves;
- std::vector<Real> min_offsets;
+ vector<Grob *> staves;
+ vector<Real> min_offsets;
// Store the appropriate '*-*-spacing 'padding, and skyline-distance,
// considering indentation, from the previous system.
Real min_distance;
Real padding;
- Element (std::vector<Grob *> const &a, std::vector<Real> const &o, Real m, Real p)
+ Element (vector<Grob *> const &a, vector<Real> const &o, Real m, Real p)
{
staves = a;
min_offsets = o;
static void alter_spring_from_spacing_spec (SCM spec, Spring *spring);
static void mark_as_spaceable (Grob *);
- std::vector<Spring> springs_;
- std::vector<Element> elements_;
- std::vector<Real> solution_;
+ vector<Spring> springs_;
+ vector<Element> elements_;
+ vector<Real> solution_;
Real force_;
Skyline bottom_skyline_;
Real bottom_loose_baseline_;
struct Page_spacing_result
{
- std::vector<vsize> systems_per_page_;
- std::vector<Real> force_;
+ vector<vsize> systems_per_page_;
+ vector<Real> force_;
Real penalty_;
Real demerits_;
int system_count_status_;
class Page_spacer
{
public:
- Page_spacer (std::vector<Line_details> const &lines, vsize first_page_num, Page_breaking const *);
+ Page_spacer (vector<Line_details> const &lines, vsize first_page_num, Page_breaking const *);
Page_spacing_result solve (vsize page_count);
Page_spacing_result solve ();
Page_breaking const *breaker_;
vsize first_page_num_;
- std::vector<Line_details> lines_;
+ vector<Line_details> lines_;
// If a page-count is requested, we use state_, which
// is indexed by page*system, for our dynamic programming
// intermediate storage. Otherwise, we use simple_state_,
// which is indexed only by system.
Matrix<Page_spacing_node> state_;
-
std::vector<Page_spacing_node> simple_state_;
+ vector<Page_spacing_node> simple_state_;
vsize max_page_count_;
bool ragged_;
vsize break_pos_; /* index into breaks_ */
Line_division div_;
- std::vector<vsize> system_count_; /* systems per page */
+ vector<vsize> system_count_; /* systems per page */
Break_node ()
{
}
};
- std::vector<Break_node> state_;
+ vector<Break_node> state_;
vsize total_page_count (Break_node const &b);
Break_node put_systems_on_pages (vsize start,
vsize configuration,
vsize page_number);
- SCM make_lines (std::vector<Break_node> *breaks);
- SCM make_pages (std::vector<Break_node> const &breaks, SCM systems);
+ SCM make_lines (vector<Break_node> *breaks);
+ SCM make_pages (vector<Break_node> const &breaks, SCM systems);
void calc_subproblem (vsize i);
void print_break_node (Break_node const &b);
Real);
~Pango_font ();
- std::string description_string () const;
+ string description_string () const;
SCM font_file_name () const;
- void register_font_file (const std::string &filename, const std::string &ps_name, int face_index);
+ void register_font_file (const string &filename, const string &ps_name, int face_index);
- size_t name_to_index (std::string) const;
+ size_t name_to_index (string) const;
SCM get_glyph_outline (size_t signed_idx) const;
Box get_glyph_outline_bbox (size_t signed_idx) const;
Box get_unscaled_indexed_char_dimensions (size_t) const;
Stencil pango_item_string_stencil (PangoGlyphItem const *) const;
virtual Stencil text_stencil (Output_def *output_state,
- const std::string &text, bool music) const;
+ const string &text, bool music) const;
virtual void derived_mark () const;
};
DECLARE_ACKNOWLEDGER (staff_spacing);
System *system_;
- std::vector<Stream_event *> break_events_;
- std::vector<Stream_event *> label_events_;
+ vector<Stream_event *> break_events_;
+ vector<Stream_event *> label_events_;
int breaks_; // used for stat printing
Paper_column *command_column_;
Paper_column *musical_column_;
- std::vector<Item *> items_;
+ vector<Item *> items_;
bool first_;
bool made_columns_;
Moment last_moment_;
virtual ~Paper_outputter ();
private:
SCM output_module_;
- std::string file_name_;
+ string file_name_;
SCM file_;
public:
- Paper_outputter (SCM port, const std::string &format);
+ Paper_outputter (SCM port, const string &format);
void close ();
SCM dump_string (SCM);
SCM systems_;
SCM paper_systems_;
- mutable std::vector<Grob *> cols_;
- mutable std::vector<vsize> break_indices_;
- mutable std::vector<vsize> break_ranks_;
+ mutable vector<Grob *> cols_;
+ mutable vector<vsize> break_indices_;
+ mutable vector<vsize> break_ranks_;
public:
Paper_score (Output_def *);
System *root_system () const;
void typeset_system (System *);
- std::vector<Column_x_positions> calc_breaking ();
- std::vector<vsize> get_break_indices () const;
- std::vector<vsize> get_break_ranks () const;
- std::vector<Grob *> get_columns () const;
+ vector<Column_x_positions> calc_breaking ();
+ vector<vsize> get_break_indices () const;
+ vector<vsize> get_break_ranks () const;
+ vector<Grob *> get_columns () const;
SCM get_paper_systems ();
protected:
void find_break_indices () const;
void add_element (Audio_element *p);
virtual void process ();
void remap_grace_durations ();
- void output (Midi_stream &midi_stream, const std::string &performance_name) const;
+ void output (Midi_stream &midi_stream, const string &performance_name) const;
void output_header_track (Midi_stream &midi_stream) const;
void print () const;
- void write_output (std::string filename, const std::string &performance_name) const;
+ void write_output (string filename, const string &performance_name) const;
-
std::vector<Audio_staff *> audio_staffs_;
-
std::vector<Audio_element *> audio_elements_;
+ vector<Audio_staff *> audio_staffs_;
+ vector<Audio_element *> audio_elements_;
Output_def *midi_;
bool ports_;
SCM header_;
virtual void announce_element (Audio_element_info);
protected:
-
std::vector<Audio_element_info> announce_infos_;
+ vector<Audio_element_info> announce_infos_;
virtual void acknowledge_audio_elements ();
};
int rounded_semitone_pitch () const;
int rounded_quartertone_pitch () const;
Pitch negated () const;
- std::string to_string () const;
+ string to_string () const;
DECLARE_SCHEME_CALLBACK (less_p, (SCM a, SCM b));
};
static Grob *find_grob (Grob *, SCM, bool (*pred) (Grob *));
};
-std::vector<Grob *> const &internal_extract_grob_array (Grob const *elt, SCM symbol);
-std::vector<Item *> internal_extract_item_array (Grob const *elt, SCM symbol);
+vector<Grob *> const &internal_extract_grob_array (Grob const *elt, SCM symbol);
+vector<Item *> internal_extract_item_array (Grob const *elt, SCM symbol);
#define extract_grob_array(x, prop) internal_extract_grob_array (x, ly_symbol2scm (prop))
#define extract_item_array(x, prop) internal_extract_item_array (x, ly_symbol2scm (prop))
representation of grob sets again.
*/
#define extract_grob_set(grob, prop, set) \
- std::vector<Grob*> const &set (internal_extract_grob_array (grob, ly_symbol2scm (prop)))
+ vector<Grob*> const &set (internal_extract_grob_array (grob, ly_symbol2scm (prop)))
#define extract_item_set(grob, prop, set) \
- std::vector<Item*> set (internal_extract_item_array (grob, ly_symbol2scm (prop)))
+ vector<Item*> set (internal_extract_item_array (grob, ly_symbol2scm (prop)))
#endif /* POINTER_GROUP_INTERFACE_HH */
public:
Prob (SCM, SCM);
Prob (Prob const &);
- virtual std::string name () const;
+ virtual string name () const;
SCM type () const { return type_; }
SCM get_property_alist (bool _mutable) const;
SCM internal_get_property (SCM sym) const;
SCM ly_set_option (SCM, SCM);
bool get_program_option (const char *);
-std::string get_output_backend_name ();
+string get_output_backend_name ();
#endif /* SCM_OPTION_HH */
#include "std-string.hh"
-void read_relocation_dir (const std::string &dirname);
-void read_relocation_file (const std::string &filename);
-std::string expand_environment_variables (const std::string &orig);
+void read_relocation_dir (const string &dirname);
+void read_relocation_file (const string &filename);
+string expand_environment_variables (const string &orig);
-int sane_putenv (char const *key, const std::string &value, bool overwrite);
+int sane_putenv (char const *key, const string &value, bool overwrite);
void setup_paths (char const *argv0);
extern bool relocate_binary;
public:
DECLARE_SCHEME_CALLBACK (y_offset_callback, (SCM));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- static std::string glyph_name (Grob *, int durlog, const std::string &style, bool, Real);
+ static string glyph_name (Grob *, int durlog, const string &style, bool, Real);
static Real staff_position_internal (Grob *, int /* duration_log */,
int /* dir */);
static SCM brew_internal_stencil (Grob *, bool);
struct Scale : public Smob<Scale>
{
virtual ~Scale ();
- Scale (std::vector<Rational> const &);
+ Scale (vector<Rational> const &);
Scale (Scale const &);
Rational tones_at_step (int step, int octave) const;
private:
- std::vector<Rational> step_tones_;
+ vector<Rational> step_tones_;
};
extern Scale *default_global_scale;
{
System *system_;
- std::vector<Grob *> elems_;
+ vector<Grob *> elems_;
Paper_score *pscore_;
void typeset_all ();
public:
Input *origin () const;
- std::vector<Output_def *> defs_;
+ vector<Output_def *> defs_;
bool error_found_;
Score ();
static void add_side_positioned (Grob *, Grob *);
DECLARE_SCHEME_CALLBACK (before_line_breaking, (SCM));
DECLARE_SCHEME_CALLBACK (row_before_line_breaking, (SCM));
- static void order_grobs (std::vector<Grob *> grobs);
+ static void order_grobs (vector<Grob *> grobs);
};
DECLARE_SCHEME_CALLBACK (calc_skylines, (SCM));
DECLARE_SCHEME_CALLBACK (print, (SCM));
- static std::vector<Box> boxes (Grob *me, Grob *left);
+ static vector<Box> boxes (Grob *me, Grob *left);
static Skyline conditional_skyline (Grob *, Grob *);
static Grob *extremal_break_aligned_grob (Grob *, Direction, Interval *);
static Real set_distance (Item *left, Item *right, Real padding);
Real range_ideal_len (int l, int r) const;
Real range_stiffness (int l, int r, bool stretch) const;
Real configuration_length (Real) const;
- std::vector<Real> spring_positions () const;
+ vector<Real> spring_positions () const;
void set_force (Real force);
Real force () const;
Real compress_line ();
Real rod_force (int l, int r, Real dist);
- std::vector<Spring> springs_;
+ vector<Spring> springs_;
Real line_len_;
Real force_;
bool ragged_;
};
/* returns a vector of dimensions breaks.size () * breaks.size () */
-std::vector<Real> get_line_forces (std::vector<Grob *> const &columns,
+vector<Real> get_line_forces (vector<Grob *> const &columns,
Real line_len,
Real indent,
bool ragged);
-Column_x_positions get_line_configuration (std::vector<Grob *> const &columns,
+Column_x_positions get_line_configuration (vector<Grob *> const &columns,
Real line_len,
Real indent,
bool ragged);
public:
Skyline_pair ();
- Skyline_pair (std::vector<Box> const &boxes, Axis a);
- Skyline_pair (std::vector<Drul_array<Offset> > const &buildings, Axis a);
- Skyline_pair (std::vector<Skyline_pair> const &skypairs);
+ Skyline_pair (vector<Box> const &boxes, Axis a);
+ Skyline_pair (vector<Drul_array<Offset> > const &buildings, Axis a);
+ Skyline_pair (vector<Skyline_pair> const &skypairs);
Skyline_pair (Box const &, Axis a);
Real left () const;
public:
static const char type_p_name_[];
private:
- std::list<Building> buildings_;
+ list<Building> buildings_;
Direction sky_;
- void internal_merge_skyline (std::list<Building> *, std::list<Building> *,
- std::list<Building> *result) const;
- std::list<Building> internal_build_skyline (std::list<Building> *) const;
+ void internal_merge_skyline (list<Building> *, list<Building> *,
+ list<Building> *result) const;
+ list<Building> internal_build_skyline (list<Building> *) const;
Real internal_distance (Skyline const &, Real horizon_padding, Real *touch_point) const;
Real internal_distance (Skyline const &, Real *touch_point) const;
void normalize ();
public:
Skyline ();
Skyline (Direction sky);
- Skyline (std::vector<Box> const &bldgs, Axis a, Direction sky);
- Skyline (std::vector<Drul_array<Offset> > const &bldgs, Axis a, Direction sky);
- Skyline (std::vector<Skyline_pair> const &skypairs, Direction sky);
+ Skyline (vector<Box> const &bldgs, Axis a, Direction sky);
+ Skyline (vector<Drul_array<Offset> > const &bldgs, Axis a, Direction sky);
+ Skyline (vector<Skyline_pair> const &skypairs, Direction sky);
Skyline (Box const &b, Axis a, Direction sky);
- std::vector<Offset> to_points (Axis) const;
+ vector<Offset> to_points (Axis) const;
void merge (Skyline const &);
void insert (Box const &, Axis);
void print () const;
class Slur_configuration
{
Real score_;
- std::string score_card_;
+ string score_card_;
public:
Drul_array<Offset> attachment_;
Slur_configuration ();
Real score () const { return score_; }
- std::string card () const { return score_card_; }
- void add_score (Real, const std::string&);
+ string card () const { return score_card_; }
+ void add_score (Real, const string&);
void generate_curve (Slur_score_state const &state, Real r0, Real h_inf,
- std::vector<Offset> const &);
+ vector<Offset> const &);
void run_next_scorer (Slur_score_state const &);
bool done () const;
static Slur_configuration *new_config (Drul_array<Offset> const &offs, int idx);
event_name_ (event_name) {}
// protected so that subclasses can see them
- std::vector<Stream_event *> start_events_;
- std::vector<Stream_event *> stop_events_;
- std::vector<Grob *> slurs_;
- std::vector<Grob *> end_slurs_;
- std::vector<Grob_info> objects_to_acknowledge_;
+ vector<Stream_event *> start_events_;
+ vector<Stream_event *> stop_events_;
+ vector<Grob *> slurs_;
+ vector<Grob *> end_slurs_;
+ vector<Grob_info> objects_to_acknowledge_;
const char* double_property_name_;
const char* grob_name_;
const char* object_name_;
void stop_translation_timestep ();
void process_music ();
- bool can_create_slur (const std::string&, vsize, vsize *, Stream_event *);
- void create_slur (const std::string &spanner_id, Stream_event *ev_cause, Grob *g_cause, Direction dir, bool left_broken);
+ bool can_create_slur (const string&, vsize, vsize *, Stream_event *);
+ void create_slur (const string &spanner_id, Stream_event *ev_cause, Grob *g_cause, Direction dir, bool left_broken);
bool try_to_end (Stream_event *ev);
virtual void set_melisma (bool);
bool has_same_beam_;
Real musical_dy_;
- std::vector<Grob *> columns_;
- std::vector<Encompass_info> encompass_infos_;
- std::vector<Extra_collision_info> extra_encompass_infos_;
+ vector<Grob *> columns_;
+ vector<Encompass_info> encompass_infos_;
+ vector<Extra_collision_info> extra_encompass_infos_;
Direction dir_;
Slur_score_parameters parameters_;
Drul_array<Bound_info> extremes_;
Drul_array<Offset> base_attachments_;
- std::vector<Slur_configuration *> configurations_;
+ vector<Slur_configuration *> configurations_;
Real staff_space_;
Real line_thickness_;
Real thickness_;
void fill (Grob *);
Direction slur_direction () const;
- std::vector<Offset> generate_avoid_offsets () const;
+ vector<Offset> generate_avoid_offsets () const;
Drul_array<Bound_info> get_bound_info () const;
void generate_curves () const;
- std::vector<Slur_configuration *> enumerate_attachments (Drul_array<Real> end_ys) const;
+ vector<Slur_configuration *> enumerate_attachments (Drul_array<Real> end_ys) const;
Drul_array<Offset> get_base_attachments () const;
Drul_array<Real> get_y_attachment_range () const;
Encompass_info get_encompass_info (Grob *col) const;
- std::vector<Extra_collision_info> get_extra_encompass_infos () const;
+ vector<Extra_collision_info> get_extra_encompass_infos () const;
Real move_away_from_staffline (Real y, Grob *on_staff) const;
Interval breakable_bound_extent (Direction) const;
static void add_column (Grob *me, Grob *col);
static void add_extra_encompass (Grob *me, Grob *col);
static void replace_breakable_encompass_objects (Grob *me);
- static void auxiliary_acknowledge_extra_object (Grob_info const &, std::vector<Grob *> &, std::vector<Grob *> &);
+ static void auxiliary_acknowledge_extra_object (Grob_info const &, vector<Grob *> &, vector<Grob *> &);
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (calc_control_points, (SCM));
DECLARE_SCHEME_CALLBACK (calc_direction, (SCM));
debugging purposes. If the class does not define this function,
the output will be #<Classname> when printing.
- - a static const type_p_name_[] std::string set to something like
+ - a static const type_p_name_[] string set to something like
"ly:grob?". When provided, an accordingly named function for
checking for the given smob type will be available in Scheme.
static scm_t_bits smob_tag_;
static Scm_init scm_init_;
static void init (void);
- static std::string smob_name_;
+ static string smob_name_;
protected:
static Super *unchecked_unsmob (SCM s)
{
static void smob_proc_init (scm_t_bits) { };
// type_p_name_ can be overriden in the Super class with a static
- // const char [] std::string. This requires both a declaration in the
+ // const char [] string. This requires both a declaration in the
// class as well as a single instantiation outside. Using a
- // template specialization for supplying a different std::string name
+ // template specialization for supplying a different string name
// right in Smob_base<Super> itself seems tempting, but the C++
// rules would then require a specialization declaration at the
// class definition site as well as a specialization instantiation
extern bool parsed_objects_should_be_dead;
class parsed_dead
{
- static
std::vector<parsed_dead *> elements;
+ static vector<parsed_dead *> elements;
SCM data;
SCM readout_one ()
{
Scm_init Smob_base<Super>::scm_init_ (init);
template <class Super>
-std::string Smob_base<Super>::smob_name_;
+string Smob_base<Super>::smob_name_;
template <class Super>
void Smob_base<Super>::init ()
{
SCM subr = scm_c_define_gsubr (Super::type_p_name_, 1, 0, 0,
(scm_t_subr) smob_p);
- std::string fundoc = std::string("Is @var{x} a @code{") + smob_name_
+ string fundoc = string("Is @var{x} a @code{") + smob_name_
+ "} object?";
ly_add_function_documentation (subr, Super::type_p_name_, "(SCM x)",
fundoc);
#include "smobs.hh"
#include <iostream>
+using namespace std;
/**
class for reading and mapping a file.
static const char type_p_name_[];
virtual ~Source_file ();
private:
- std::vector<char const *> newline_locations_;
- std::istream *istream_;
- std::vector<char> characters_;
+ vector<char const *> newline_locations_;
+ istream *istream_;
+ vector<char> characters_;
SCM str_port_;
void load_stdin ();
void init ();
public:
- Source_file (const std::string &fn);
- Source_file (const std::string&, const std::string&);
+ Source_file (const string &fn);
+ Source_file (const string&, const string&);
char const *c_str () const;
- virtual std::string quote_input (char const *pos_str0) const;
- std::istream *get_istream ();
+ virtual string quote_input (char const *pos_str0) const;
+ istream *get_istream ();
bool contains (char const *pos_str0) const;
int length () const;
virtual int get_line (char const *pos_str0) const;
void set_line (char const *pos_str0, int i);
- std::string name_string () const;
- std::string file_line_column_string (char const *str0) const;
+ string name_string () const;
+ string file_line_column_string (char const *str0) const;
Slice line_slice (char const *pos_str0) const;
- std::string line_string (char const *pos_str0) const;
+ string line_string (char const *pos_str0) const;
void get_counts (char const *pos_str0, int *, int *, int *, int *) const;
SCM get_port () const;
- std::string name_;
+ string name_;
protected:
int line_offset_;
};
-std::vector<char> gulp_file (const std::string &fn, int desired);
+vector<char> gulp_file (const string &fn, int desired);
#endif /* SOURCE_FILE_HH */
class Sources
{
Sources (Sources const &); // Do not define! Not copyable!
- std::vector<Source_file *> sourcefiles_;
+ vector<Source_file *> sourcefiles_;
public:
Sources ();
~Sources ();
- Source_file *get_file (std::string file_name, std::string const ¤tpath);
+ Source_file *get_file (string file_name, string const ¤tpath);
void add (Source_file *sourcefile);
void set_path (File_path *);
struct Spacing_interface
{
static Real minimum_distance (Grob *me, Grob *right_col);
- static std::vector<Item *> right_note_columns (Grob *me);
- static std::vector<Item *> left_note_columns (Grob *me);
+ static vector<Item *> right_note_columns (Grob *me);
+ static vector<Item *> left_note_columns (Grob *me);
static Item *right_column (Grob *me);
static Item *left_column (Grob *me);
static Drul_array<Skyline> skylines (Grob *me, Grob *right_col);
Paper_column *nextr,
Spacing_options const *options);
static Real default_bar_spacing (Grob *, Grob *, Grob *, Moment);
- static Rational effective_shortest_duration (Grob *me, std::vector<Grob *> const &all);
+ static Rational effective_shortest_duration (Grob *me, vector<Grob *> const &all);
static void breakable_column_spacing (Grob *, Item *l, Item *r, Spacing_options const *);
- static void prune_loose_columns (Grob *, std::vector<Grob *> *cols, Spacing_options *);
- static void set_explicit_neighbor_columns (std::vector<Grob *> const &cols);
- static void set_implicit_neighbor_columns (std::vector<Grob *> const &cols);
- static void generate_springs (Grob *me, std::vector<Grob *> const &cols, Spacing_options const *);
+ static void prune_loose_columns (Grob *, vector<Grob *> *cols, Spacing_options *);
+ static void set_explicit_neighbor_columns (vector<Grob *> const &cols);
+ static void set_implicit_neighbor_columns (vector<Grob *> const &cols);
+ static void generate_springs (Grob *me, vector<Grob *> const &cols, Spacing_options const *);
static void musical_column_spacing (Grob *, Item *, Item *, Spacing_options const *);
static bool fills_measure (Grob *, Item *, Item *);
public:
- static std::vector<Grob *> get_columns (Grob *me);
+ static vector<Grob *> get_columns (Grob *me);
static Spring note_spacing (Grob *, Grob *, Grob *, Spacing_options const *);
static Spring standard_breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *);
DECLARE_SCHEME_CALLBACK (bounds_width, (SCM));
DECLARE_SCHEME_CALLBACK (kill_zero_spanned_time, (SCM));
- std::vector<Spanner *> broken_intos_;
+ vector<Spanner *> broken_intos_;
vsize get_break_index () const;
Spanner *broken_neighbor (Direction d) const;
bool operator > (Spring const &) const;
};
-Spring merge_springs (std::vector<Spring> const &springs);
+Spring merge_springs (vector<Spring> const &springs);
#endif /* SPRING_HH */
static Real get_line_thickness (Grob *);
static Real get_ledger_line_thickness (Grob *);
- static std::vector<Real> line_positions (Grob *);
- static std::vector<Real> ledger_positions (Grob *me, int pos);
+ static vector<Real> line_positions (Grob *);
+ static vector<Real> ledger_positions (Grob *me, int pos);
static int line_count (Grob *);
static bool on_line (Grob *me, int pos, bool allow_ledger = true);
static Interval line_span (Grob *);
class Stem
{
public:
- static std::vector<int> note_head_positions (Grob *, bool filter = false);
+ static vector<int> note_head_positions (Grob *, bool filter = false);
static int duration_log (Grob *);
static void set_beaming (Grob *, int, Direction d);
static int get_beaming (Grob *, Direction d);
#define STENCIL_HH
#include <cstdlib> // size_t
+using namespace std;
#include "lily-proto.hh"
#include "box.hh"
Grob *get_pure_bound (Direction dir, int start, int end);
Grob *get_maybe_pure_bound (Direction dir, bool pure, int start, int end);
int get_rank () const;
- std::vector<Real> get_footnote_heights_in_range (vsize st, vsize end);
- std::vector<Real> get_in_note_heights_in_range (vsize st, vsize end);
- std::vector<Real> internal_get_note_heights_in_range (vsize st, vsize end, bool foot);
- std::vector<Grob *> get_footnote_grobs_in_range (vsize st, vsize end);
+ vector<Real> get_footnote_heights_in_range (vsize st, vsize end);
+ vector<Real> get_in_note_heights_in_range (vsize st, vsize end);
+ vector<Real> internal_get_note_heights_in_range (vsize st, vsize end, bool foot);
+ vector<Grob *> get_footnote_grobs_in_range (vsize st, vsize end);
vsize num_footnotes ();
void do_break_substitution_and_fixup_refpoints ();
void post_processing ();
int element_count () const;
int spanner_count () const;
- void break_into_pieces (std::vector<Column_x_positions> const &);
+ void break_into_pieces (vector<Column_x_positions> const &);
- std::vector<Item *> broken_col_range (Item const *, Item const *) const;
- std::vector<Grob *> used_columns () const;
+ vector<Item *> broken_col_range (Item const *, Item const *) const;
+ vector<Grob *> used_columns () const;
Paper_column *column (vsize i) const;
void add_column (Paper_column *);
class Tie_configuration
{
#if DEBUG_SLUR_SCORING
- std::string score_card_;
+ string score_card_;
#endif
Real score_;
bool scored_;
public:
Real score () const { return score_; }
- std::string card () const { return score_card_; }
+ string card () const { return score_card_; }
int position_;
Direction dir_;
/* computed. */
Interval attachment_x_;
- void add_score (Real, const std::string&);
+ void add_score (Real, const string&);
Tie_configuration ();
void center_tie_vertically (Tie_details const &);
Bezier get_transformed_bezier (Tie_details const &) const;
INSTANTIATE_COMPARE (Tie_configuration, Tie_configuration::compare);
-class Ties_configuration : public std::vector<Tie_configuration>
+class Ties_configuration : public vector<Tie_configuration>
{
Real score_;
- std::string score_card_;
+ string score_card_;
bool scored_;
- std::vector<std::string> tie_score_cards_;
+ vector<string> tie_score_cards_;
friend class Tie_formatting_problem;
public:
Ties_configuration ();
- void add_score (Real amount, const std::string &description);
- void add_tie_score (Real amount, int i, const std::string &description);
+ void add_score (Real amount, const string &description);
+ void add_tie_score (Real amount, int i, const string &description);
Real score () const;
void reset_score ();
- std::string card () const;
- std::string tie_card (int i) const { return tie_score_cards_[i]; }
- std::string complete_tie_card (vsize i) const;
- std::string complete_score_card () const;
+ string card () const;
+ string tie_card (int i) const { return tie_score_cards_[i]; }
+ string complete_tie_card (vsize i) const;
+ string complete_score_card () const;
};
#endif /* TIE_CONFIGURATION_HH */
#include <map>
#include <set>
-typedef std::map< Tuple<int, 4>, Tie_configuration *> Tie_configuration_map;
+typedef map< Tuple<int, 4>, Tie_configuration *> Tie_configuration_map;
struct Tie_configuration_variation
{
- std::vector<std::pair<int, Tie_configuration *> > index_suggestion_pairs_;
+ vector<pair<int, Tie_configuration *> > index_suggestion_pairs_;
void add_suggestion (int index, Tie_configuration *suggestion)
{
- index_suggestion_pairs_.push_back (std::make_pair (index, suggestion));
+ index_suggestion_pairs_.push_back (make_pair (index, suggestion));
}
};
-typedef std::map < Tuple<int, 2>, Skyline> Chord_outline_map;
-typedef std::map < Tuple<int, 2>, Box> Column_extent_map;
-typedef std::map <int, Slice> Position_extent_map;
+typedef map < Tuple<int, 2>, Skyline> Chord_outline_map;
+typedef map < Tuple<int, 2>, Box> Column_extent_map;
+typedef map <int, Slice> Position_extent_map;
class Tie_formatting_problem
{
Column_extent_map head_extents_;
Position_extent_map head_positions_;
- std::set<int> dot_positions_;
+ set<int> dot_positions_;
Interval dot_x_;
- std::vector<Tie_specification> specifications_;
+ vector<Tie_specification> specifications_;
bool use_horizontal_spacing_;
Tie_configuration_map possibilities_;
Tie_configuration *get_configuration (int position, Direction dir, Drul_array<int> cols, bool tune_y) const;
Tie_configuration *generate_configuration (int position, Direction dir, Drul_array<int> cols, bool tune_y) const;
- std::vector<Tie_configuration_variation> generate_collision_variations (Ties_configuration const &ties) const;
- std::vector<Tie_configuration_variation> generate_extremal_tie_variations (Ties_configuration const &ties) const;
- std::vector<Tie_configuration_variation> generate_single_tie_variations (Ties_configuration const &ties) const;
+ vector<Tie_configuration_variation> generate_collision_variations (Ties_configuration const &ties) const;
+ vector<Tie_configuration_variation> generate_extremal_tie_variations (Ties_configuration const &ties) const;
+ vector<Tie_configuration_variation> generate_single_tie_variations (Ties_configuration const &ties) const;
void score_configuration (Tie_configuration *) const;
Real score_aptitude (Tie_configuration *, Tie_specification const &,
Slice head_positions_slice (int) const;
Ties_configuration generate_base_chord_configuration ();
Ties_configuration find_best_variation (Ties_configuration const &base,
- std::vector<Tie_configuration_variation> const &vars);
+ vector<Tie_configuration_variation> const &vars);
public:
Tie_details details_;
Ties_configuration generate_optimal_configuration ();
Ties_configuration generate_ties_configuration (Ties_configuration const &);
- void from_ties (std::vector<Grob *> const &ties);
+ void from_ties (vector<Grob *> const &ties);
void from_tie (Grob *tie);
- void from_semi_ties (std::vector<Grob *> const &, Direction head_dir);
- void set_chord_outline (std::vector<Item *>, Direction);
- void set_column_chord_outline (std::vector<Item *>, Direction, int rank);
+ void from_semi_ties (vector<Grob *> const &, Direction head_dir);
+ void set_chord_outline (vector<Item *>, Direction);
+ void set_column_chord_outline (vector<Item *>, Direction, int rank);
void set_manual_tie_configuration (SCM);
Interval get_attachment (Real, Drul_array<int>) const;
Grob *common_x_refpoint () const;
class Engraver_dispatch_list : public Simple_smob<Engraver_dispatch_list>
{
- std::vector<Engraver_dispatch_entry> dispatch_entries_;
+ vector<Engraver_dispatch_entry> dispatch_entries_;
public:
void apply (Grob_info);
SCM static create (SCM trans_list,
virtual ~Translator_group ();
private:
void precompute_method_bindings ();
- std::vector<Translator_method_binding>
+ vector<Translator_method_binding>
precomputed_method_bindings_[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
Translator_group_void_method
NAME (); \
VIRTUAL_COPY_CONSTRUCTOR (Translator, NAME); \
static SCM static_description_; \
- static Drul_array<
std::vector<Acknowledge_information> > acknowledge_static_array_drul_; \
+ static Drul_array<vector<Acknowledge_information> > acknowledge_static_array_drul_; \
virtual void fetch_precomputable_methods (Callback methods[]); \
virtual SCM static_translator_description () const; \
virtual SCM translator_description () const; \
/* end define */
#define DEFINE_ACKNOWLEDGERS(classname) \
- Drul_array<
std::vector<Acknowledge_information> > classname::acknowledge_static_array_drul_; \
+ Drul_array< vector<Acknowledge_information> > classname::acknowledge_static_array_drul_; \
Translator::Grob_info_callback \
classname::static_get_acknowledger (SCM sym) \
{ \
void add_acknowledger (Translator::Grob_info_callback ptr,
char const *func_name,
-
std::vector<Acknowledge_information> *ack_array);
+ vector<Acknowledge_information> *ack_array);
Translator::Grob_info_callback
generic_get_acknowledger (SCM sym,
-
std::vector<Acknowledge_information> const *ack_array);
+ vector<Acknowledge_information> const *ack_array);
#define ADD_ACKNOWLEDGER(CLASS, NAME) \
void CLASS ## NAME ## _ack_adder () \
static void add_column (Grob *me, Item *);
static void add_script (Grob *me, Item *);
static void add_beam (Grob *me, Grob *);
- static Grob *parallel_beam (Grob *me, std::vector<Grob *> const &cols,
+ static Grob *parallel_beam (Grob *me, vector<Grob *> const &cols,
bool *equally_long);
static void calc_position_and_height (Grob *, Real *, Real *dy);
static Stencil make_bracket (Grob *me, Axis protrusion_axis,
static Real calc_offset (Spanner *me, Axis a); // not used
- static Grob *select_reference_stem (Grob *me, std::vector<Grob *> const &cols);
+ static Grob *select_reference_stem (Grob *me, vector<Grob *> const &cols);
static Drul_array<Grob *> adjacent_note_columns (Grob *me, Grob *ref_stem);
static bool knee_position_against_beam (Grob *me, Grob *ref_stem);
};
#include "input.hh"
#include <cstdio>
+using namespace std;
#include "international.hh"
#include "lily-imports.hh"
#include <cstring>
#include <cstdlib>
+using namespace std;
/* for qsort */
bool tab_less (Keyword_ent const &p1, Keyword_ent const &p2)
*/
#include <map>
+using namespace std;
#include "note-head.hh"
#include "staff-symbol-referencer.hh"
continue;
current_extents[vdir].unite (head_extent);
- current_head_width = std::max (current_head_width, head_extent.length ());
+ current_head_width = max (current_head_width, head_extent.length ());
}
if (previous_column && current_column)
reqs[rank][vdir].ledger_extent_.unite (ledger_extent);
reqs[rank][vdir].head_extent_.unite (head_extent);
reqs[rank][vdir].position_
- = vdir * std::max (vdir * reqs[rank][vdir].position_, vdir * pos);
+ = vdir * max (vdir * reqs[rank][vdir].position_, vdir * pos);
}
}
- sign (i->second[d].position_)));
Real limit = (center + (both ? which * gap / 2 : 0));
lr.ledger_extent_.at (-which)
- = which * std::max (which * lr.ledger_extent_[-which], which * limit);
+ = which * max (which * lr.ledger_extent_[-which], which * limit);
}
}
}
head_size[LEFT]),
0.0);
- Real left_shorten = std::max (-ledger_size[LEFT] + d, 0.0);
+ Real left_shorten = max (-ledger_size[LEFT] + d, 0.0);
x_extent[LEFT] += left_shorten;
/*
#define LEXER_CC
#include <iostream>
+using namespace std;
#include "context-def.hh"
#include "duration.hh"
#include <cstring> /* strdup, strchr */
#include <cctype>
+using namespace std;
#include "dimensions.hh"
#include "direction.hh"
#include <cctype>
#include <sstream>
+using namespace std;
#include "context.hh" // for nested_property_alist
#include "international.hh"
Line_interface::make_dashed_line (Real thick, Offset from, Offset to,
Real dash_period, Real dash_fraction)
{
- dash_fraction = std::min (std::max (dash_fraction, 0.0), 1.0);
+ dash_fraction = min (max (dash_fraction, 0.0), 1.0);
Real on = dash_fraction * dash_period + thick;
- Real off = std::max (0.0, dash_period - on);
+ Real off = max (0.0, dash_period - on);
SCM at = scm_list_n (ly_symbol2scm ("dashed-line"),
scm_from_double (thick),
? 0.0
: robust_scm2double (me->get_property ("dash-fraction"), 0.4);
- fraction = std::min (std::max (fraction, 0.0), 1.0);
+ fraction = min (max (fraction, 0.0), 1.0);
Real period = Staff_symbol_referencer::staff_space (me)
* robust_scm2double (me->get_property ("dash-period"), 1.0);
Real len = (to - from).length ();
int n = (int) rint ((len - period * fraction) / period);
- n = std::max (0, n);
+ n = max (0, n);
if (n > 0)
{
/*
#include <cmath>
#include <cctype>
+using namespace std;
#include "line-interface.hh"
#include "warn.hh"
Lookup::round_filled_box (Box b, Real blotdiameter)
{
Real width = b.x ().delta ();
- blotdiameter = std::min (blotdiameter, width);
+ blotdiameter = min (blotdiameter, width);
Real height = b.y ().delta ();
- blotdiameter = std::min (blotdiameter, height);
+ blotdiameter = min (blotdiameter, height);
if (blotdiameter < 0.0)
{
{
Box b;
b[X_AXIS] = Interval (0, iv.length ());
- b[Y_AXIS] = Interval (std::min (0., protrude), std::max (0.0, protrude));
+ b[Y_AXIS] = Interval (min (0., protrude), max (0.0, protrude));
vector<Offset> points;
points.push_back (Offset (iv[LEFT], 0));
if ((e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
&& music_context_)
- busy_moment_ = std::max (music_context_->now_mom (),
+ busy_moment_ = max (music_context_->now_mom (),
busy_moment_);
}
Real right_point
= left_point + (robust_scm2double (minlen, 0));
- right_point = std::min (right_point, me->get_system ()->get_bound (RIGHT)->relative_coordinate (common, X_AXIS));
+ right_point = min (right_point, me->get_system ()->get_bound (RIGHT)->relative_coordinate (common, X_AXIS));
if (heads.size ())
- right_point = std::max (right_point, heads.back ()->extent (common, X_AXIS)[RIGHT]);
+ right_point = max (right_point, heads.back ()->extent (common, X_AXIS)[RIGHT]);
Real h = sl * robust_scm2double (me->get_property ("thickness"), 0);
Drul_array<Real> paddings (robust_scm2double (me->get_property ("left-padding"), h),
robust_scm2double (me->get_property ("right-padding"), h));
if (right_text)
- right_point = std::min (right_point, (robust_relative_extent (right_text, common, X_AXIS)[LEFT] - paddings[RIGHT]));
+ right_point = min (right_point, (robust_relative_extent (right_text, common, X_AXIS)[LEFT] - paddings[RIGHT]));
/* run to end of line. */
if (me->get_bound (RIGHT)->break_status_dir ())
- right_point = std::max (right_point, (robust_relative_extent (me->get_bound (RIGHT), common, X_AXIS)[LEFT] - paddings[RIGHT]));
+ right_point = max (right_point, (robust_relative_extent (me->get_bound (RIGHT), common, X_AXIS)[LEFT] - paddings[RIGHT]));
left_point += paddings[LEFT];
Real w = right_point - left_point;
&& !bounds[RIGHT]->break_status_dir ())
{
Real minimum_length = robust_scm2double (me->get_property ("minimum-length"), .3);
- dash_length = std::max ((l - 2 * padding), minimum_length);
+ dash_length = max ((l - 2 * padding), minimum_length);
}
Real space_left = l - dash_length - (n - 1) * dash_period;
&& !bounds[RIGHT]->break_status_dir ())
return SCM_EOL;
- space_left = std::max (space_left, 0.0);
+ space_left = max (space_left, 0.0);
Box b (Interval (0, dash_length), Interval (h, h + th));
Stencil dash_mol (Lookup::round_filled_box (b, 0.8 * lt));
#include <cstring>
#include <cerrno>
#include <cstdio>
+using namespace std;
#include <unistd.h>
#include <sys/types.h>
*/
#include <cctype>
+using namespace std;
#include "engraver.hh"
*/
#include <cctype>
+using namespace std;
#include "engraver.hh"
Midi_note::Midi_note (Audio_note *a)
: Midi_channel_item (a),
audio_ (a),
- dynamic_byte_ (std::min (std::max (Byte ((a->dynamic_ && a->dynamic_->volume_ >= 0
+ dynamic_byte_ (min (max (Byte ((a->dynamic_ && a->dynamic_->volume_ >= 0
? a->dynamic_->volume_ * 0x7f : 0x5a)
+ a->extra_velocity_),
Byte (0)), Byte (0x7f)))
#include "midi-stream.hh"
#include <cerrno>
+using namespace std;
#include "international.hh"
#include "main.hh"
{
if (x < 0)
return 1.0;
- return std::max (- epsilon * (x - threshold) / ((x + epsilon) * threshold), 0.0);
+ return max (- epsilon * (x - threshold) / ((x + epsilon) * threshold), 0.0);
}
/*
along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cctype>
+using namespace std;
#include "modified-font-metric.hh"
#include "pango-font.hh"
we gotta stay clear of sp_iv, so move a bit to the right if
needed.
*/
- x_off += std::max (sp_iv[LEFT] - rx, 0.0);
+ x_off += max (sp_iv[LEFT] - rx, 0.0);
/*
center between stuff.
we gotta stay clear of sp_iv, so move a bit to the right if
needed.
*/
- Real x_off = std::max (sp_iv[LEFT] - rx, 0.0);
+ Real x_off = max (sp_iv[LEFT] - rx, 0.0);
Stencil mol;
mol.add_stencil (symbol_stencil (me, space));
Real slt = me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
Real y = slt * thick_thick / 2 * ss;
Real ythick = hair_thick * slt * ss;
- Box b (Interval (0.0, std::max (0.0, (width - 2 * ythick))), Interval (-y, y));
+ Box b (Interval (0.0, max (0.0, (width - 2 * ythick))), Interval (-y, y));
- Real blot = width ? (.8 * std::min (y, ythick)) : 0.0;
+ Real blot = width ? (.8 * min (y, ythick)) : 0.0;
Stencil m = Lookup::round_filled_box (b, blot);
Stencil yb = Lookup::round_filled_box (Box (Interval (-0.5, 0.5) * ythick, Interval (-ss, ss)), blot);
rod.item_drul_[LEFT] = li;
rod.item_drul_[RIGHT] = ri;
- rod.distance_ = std::max (Paper_column::minimum_distance (li, ri) + length,
+ rod.distance_ = max (Paper_column::minimum_distance (li, ri) + length,
minlen);
rod.add_to_cols ();
}
*/
#include <cstdio>
+using namespace std;
#include "warn.hh"
#include "music.hh"
else
{
Moment l = m->get_length ();
- dur = std::max (dur, l);
+ dur = max (dur, l);
}
}
Moment m;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- m = std::min (m, unsmob<Music> (scm_car (s))->start_mom ());
+ m = min (m, unsmob<Music> (scm_car (s))->start_mom ());
return m;
}
}
}
- vector_sort (*scripts, std::less<Finger_tuple> ());
+ vector_sort (*scripts, less<Finger_tuple> ());
bool up_p = scm_is_true (scm_c_memq (ly_symbol2scm ("up"), orientations));
bool down_p = scm_is_true (scm_c_memq (ly_symbol2scm ("down"), orientations));
// check if we cross the opposite-stemmed voices
if (d * extents[d][i][-d] < d * extent_union[-d][d])
- offset = std::max (offset, 0.5);
+ offset = max (offset, 0.5);
if (extents[-d].size ()
&& extents[d][i][UP] > extents[-d][0][DOWN]
&& extents[d][i][DOWN] < extents[-d][0][UP])
- offset = std::max (offset, 1.0);
+ offset = max (offset, 1.0);
}
offsets[d].push_back (d * offset);
}
out.insert (out.end (), nhp.begin (), nhp.end ());
}
- vector_sort (out, std::less<int> ());
+ vector_sort (out, less<int> ());
return out;
}
#include "note-column.hh"
#include <cmath> // ceil
+using namespace std;
#include "accidental-placement.hh"
#include "axis-group-interface.hh"
#include <cctype>
#include <algorithm> // min, max
+using namespace std;
#include "directional-element-interface.hh"
#include "font-interface.hh"
{
string style = robust_symbol2string (me->get_property ("style"), "default");
- string suffix = ::to_string (std::min (robust_scm2int (me->get_property ("duration-log"), 2), 2));
+ string suffix = ::to_string (min (robust_scm2int (me->get_property ("duration-log"), 2), 2));
if (style != "default")
suffix = robust_scm2string (me->get_property ("glyph-name"), "");
// The +1 and -1 come from the fact that we only want to add
// the interval between the note and the first ledger line, not
// the whole interval between the note and the staff.
- Interval iv (std::min (0.0, lines[UP] - my_ext[DOWN] + 1),
- std::max (0.0, lines[DOWN] - my_ext[UP] - 1));
+ Interval iv (min (0.0, lines[UP] - my_ext[DOWN] + 1),
+ max (0.0, lines[DOWN] - my_ext[UP] - 1));
return ly_interval2scm (iv);
}
#include "engraver.hh"
#include <cctype>
+using namespace std;
#include "duration.hh"
#include "item.hh"
Real ideal = base.distance () - increment + left_head_end;
Drul_array<Skyline> skys = Spacing_interface::skylines (me, right_col);
Real distance = skys[LEFT].distance (skys[RIGHT], robust_scm2double (right_col->get_property ("skyline-vertical-padding"), 0.0));
- Real min_dist = std::max (0.0, distance);
+ Real min_dist = max (0.0, distance);
base.set_min_distance (min_dist);
/* If we have a NonMusical column on the right, we measure the ideal distance
but keep at least half the gap we would have had to a note */
Real min_desired_space = (ideal + min_dist) / 2.0;
ideal -= right_col->extent (right_col, X_AXIS)[RIGHT];
- ideal = std::max (ideal, min_desired_space);
+ ideal = max (ideal, min_desired_space);
}
}
stem_dir_correction (me, right_col, increment, &ideal);
- base.set_distance (std::max (0.0, ideal));
+ base.set_distance (max (0.0, ideal));
return base;
}
/*
Ugh. 7 is hardcoded.
*/
- ret = std::min (ret / 7, 1.0)
+ ret = min (ret / 7, 1.0)
* left_stem_dir
* robust_scm2double (note_spacing->get_property ("stem-spacing-correction"), 0);
}
vector<Grob *> cols = ps->root_system ()->used_columns ();
// No indent, "infinite" line width, ragged.
- Column_x_positions pos = get_line_configuration (cols, std::numeric_limits<Real>::max (), 0, true);
+ Column_x_positions pos = get_line_configuration (cols, numeric_limits<Real>::max (), 0, true);
vector<Column_x_positions> positions;
positions.push_back (pos);
SCM systems = scm_list_1 (system->self_scm ());
SCM pages = make_pages (lines_per_page, systems);
- max_width = std::max (max_width, system->extent (system, X_AXIS).length ());
+ max_width = max (max_width, system->extent (system, X_AXIS).length ());
all_pages = scm_cons (scm_car (pages), all_pages);
}
else if (Prob *pb = system_specs_[i].prob_)
#include <cstdio>
+using namespace std;
#include FT_TRUETYPE_TABLES_H
? 0.0 : text.extent (X_AXIS)[RIGHT] + 0.3;
span_points[LEFT]
- = std::min (span_points[LEFT],
+ = min (span_points[LEFT],
(span_points[RIGHT] - text_size
- robust_scm2double (me->get_property ("minimum-length"), -1.0)));
paper_height_ = robust_scm2double (pb->paper_->c_variable ("paper-height"), 1.0);
ragged_ = to_boolean (pb->paper_->c_variable ("ragged-bottom"));
ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last-bottom"));
- systems_per_page_ = std::max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0));
- max_systems_per_page_ = std::max (0, robust_scm2int (pb->paper_->c_variable ("max-systems-per-page"), 0));
- min_systems_per_page_ = std::max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0));
+ systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0));
+ max_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("max-systems-per-page"), 0));
+ min_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0));
orphan_penalty_ = robust_scm2int (pb->paper_->c_variable ("orphan-penalty"), 100000);
Stencil footnote_separator = Page_layout_problem::get_footnote_separator_stencil (pb->paper_);
dems_and_indices.push_back (pair<Real, vsize> (dem, i));
}
- vector_sort (dems_and_indices,
std::less<pair<Real, vsize> > ());
+ vector_sort (dems_and_indices, less<pair<Real, vsize> > ());
vector<Line_division> best_5_configurations;
for (vsize i = 0; i < 5; i++)
others_min += min_sys[i];
others_max += max_sys[i];
}
- others_max = std::min (others_max, (int) system_count);
- int real_min = std::max ((int) min_sys[my_index], (int) system_count - others_max);
- int real_max = std::min ((int) max_sys[my_index], (int) system_count - others_min);
+ others_max = min (others_max, (int) system_count);
+ int real_min = max ((int) min_sys[my_index], (int) system_count - others_max);
+ int real_max = min ((int) max_sys[my_index], (int) system_count - others_min);
if (real_min > real_max || real_min < 0)
{
Real a = shape.begin_[UP];
Real b = shape.rest_[UP];
bool title = cur.title_;
- Real refpoint_hanging = std::max (prev_hanging_begin + a, prev_hanging_rest + b);
+ Real refpoint_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b);
if (i > 0)
{
Real min_dist = title
? prev.title_min_distance_
: prev.min_distance_;
- refpoint_hanging = std::max (refpoint_hanging + padding,
+ refpoint_hanging = max (refpoint_hanging + padding,
prev_refpoint_hanging - prev.refpoint_extent_[DOWN]
+ cur.refpoint_extent_[UP] + min_dist);
}
Real hanging_begin = refpoint_hanging - shape.begin_[DOWN];
Real hanging_rest = refpoint_hanging - shape.rest_[DOWN];
- Real hanging = std::max (hanging_begin, hanging_rest);
+ Real hanging = max (hanging_begin, hanging_rest);
cur.tallness_ = hanging - prev_hanging;
prev_hanging = hanging;
prev_hanging_begin = hanging_begin;
{
Real f = res.force_[i];
- page_demerits += std::min (f * f, BAD_SPACING_PENALTY);
+ page_demerits += min (f * f, BAD_SPACING_PENALTY);
}
/* for a while we tried averaging page and line forces across pages instead
}
ret.systems_per_page_.push_back (lines.size ());
- ret.force_.push_back (ragged ? std::min (space.force_, 0.0) : space.force_);
+ ret.force_.push_back (ragged ? min (space.force_, 0.0) : space.force_);
ret.penalty_ = line_count_penalty (line_count) + lines.back ().page_penalty_ + lines.back ().turn_penalty_;
ret.system_count_status_ |= line_count_status (line_count);
ly_symbol2scm ("padding"));
// FIXME: take into account the height of the header
- Real translate = std::max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
- return std::max (0.0, std::max (padding, min_distance - translate));
+ Real translate = max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
+ return max (0.0, max (padding, min_distance - translate));
}
Real
ly_symbol2scm ("padding"));
// FIXME: take into account the height of the footer
- Real translate = std::min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);
- return std::max (0.0, std::max (padding, min_distance + translate));
+ Real translate = min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);
+ return max (0.0, max (padding, min_distance + translate));
}
int
numbers = scm_cons (stencil, numbers);
if (!st->extent (X_AXIS).is_empty ())
- max_length = std::max (max_length, st->extent (X_AXIS)[RIGHT]);
+ max_length = max (max_length, st->extent (X_AXIS)[RIGHT]);
counter++;
}
if (sky)
{
- minimum_distance = std::max ((*sky)[UP].distance (bottom_skyline_),
+ minimum_distance = max ((*sky)[UP].distance (bottom_skyline_),
bottom_loose_baseline_);
bottom_skyline_ = (*sky)[DOWN];
}
{
SCM forced = robust_list_ref (spaceable_index - 1, manual_dists);
if (scm_is_number (forced))
- ret = std::max (ret, scm_to_double (forced));
+ ret = max (ret, scm_to_double (forced));
}
}
force_ = -infinity_f;
else
force_ = (height - rod_height_ - last_line_.bottom_padding_ - spring_len_)
- / std::max (0.1, inverse_spring_k_);
+ / max (0.1, inverse_spring_k_);
}
void
// Clamp the demerits at BAD_SPACING_PENALTY, even if the page
// is overfull. This ensures that TERRIBLE_SPACING_PENALTY takes
// precedence over overfull pages.
- demerits = std::min (demerits, BAD_SPACING_PENALTY);
+ demerits = min (demerits, BAD_SPACING_PENALTY);
demerits += (prev ? prev->demerits_ : 0);
Real penalty = breaker_->line_count_penalty (line_count);
return ret;
}
- Real new_pen = std::max (penalty_, penalty.penalty_);
+ Real new_pen = max (penalty_, penalty.penalty_);
if (duration_[LEFT] < penalty.duration_[LEFT])
ret.push_back (Page_turn_event (duration_[LEFT], penalty.duration_[LEFT], permission_, penalty_));
Grob *
Page_turn_engraver::breakable_column (Page_turn_event const &brk)
{
- vsize start = lower_bound (breakable_moments_, brk.duration_[LEFT], std::less<Rational> ());
- vsize end = upper_bound (breakable_moments_, brk.duration_[RIGHT], std::less<Rational> ());
+ vsize start = lower_bound (breakable_moments_, brk.duration_[LEFT], less<Rational> ());
+ vsize end = upper_bound (breakable_moments_, brk.duration_[RIGHT], less<Rational> ());
if (start == breakable_moments_.size ())
return NULL;
if (pc)
{
SCM perm = max_permission (pc->get_property ("page-turn-permission"), brk.permission_);
- Real pen = std::min (robust_scm2double (pc->get_property ("page-turn-penalty"), infinity_f), brk.penalty_);
+ Real pen = min (robust_scm2double (pc->get_property ("page-turn-penalty"), infinity_f), brk.penalty_);
pc->set_property ("page-turn-permission", perm);
pc->set_property ("page-turn-penalty", scm_from_double (pen));
}
/* heuristic: we've just added a breakpoint, we'll need at least as
many systems as before */
- min_sys_count = std::max (min_sys_count, prev_best_system_count);
+ min_sys_count = max (min_sys_count, prev_best_system_count);
for (vsize sys_count = min_sys_count; sys_count <= max_sys_count && ok_page; sys_count++)
{
set_current_breakpoints (start, end, sys_count, min_division, max_division);
skys[RIGHT].merge (Separation_item::conditional_skyline (right, left));
- return std::max (0.0, skys[LEFT].distance (skys[RIGHT]));
+ return max (0.0, skys[LEFT].distance (skys[RIGHT]));
}
Interval
#include <cmath>
#include <ctime>
+using namespace std;
#include "dimensions.hh"
#include "file-name.hh"
#include "parse-scm.hh"
#include <cstdio>
+using namespace std;
#include "lily-parser.hh"
#include "lily-lexer.hh"
#include <cctype>
#include <cstdlib>
#include <cstdio>
+using namespace std;
#include "book.hh"
#include "context-def.hh"
for (size_t i = 0; i < NUM_PARTS; i++)
if (iterators_[i]->ok ())
- p = std::min (p, iterators_[i]->pending_moment ());
+ p = min (p, iterators_[i]->pending_moment ());
return p;
}
*/
#include <glib.h>
+using namespace std;
#include "international.hh"
#include "warn.hh"
#include "performance.hh"
#include <ctime>
+using namespace std;
#include "audio-column.hh"
#include "audio-item.hh"
Moment start_mom = 0;
for (vsize i = 0; i < audio_elements_.size (); i++)
if (Audio_item *item = dynamic_cast<Audio_item *>(audio_elements_[i]))
- start_mom = std::min (start_mom, item->audio_column_->when ());
+ start_mom = min (start_mom, item->audio_column_->when ());
for (vsize i = 0; i < audio_staffs_.size (); i++)
{
#include <cstdlib>
#include <cstdio>
#include <cstring>
+using namespace std;
#include "program-option.hh"
#include "source-file.hh"
#include <cstdio>
#include <cstring>
+using namespace std;
#include "profile.hh"
#include "international.hh"
}
string help ("Options supported by `ly:set-option':\n\n");
- vector_sort (opts, std::less<string> ());
+ vector_sort (opts, less<string> ());
for (vsize i = 0; i < opts.size (); i++)
help += opts[i];
return help;
Moment m (infty);
if (Music_wrapper_iterator::ok ())
- m = std::min (m, Music_wrapper_iterator::pending_moment ());
+ m = min (m, Music_wrapper_iterator::pending_moment ());
/*
In case event_idx_ < 0, we're not initted yet, and the wrapped
music expression determines the starting moment.
*/
if (quote_ok ())
- m = std::min (m, vector_moment (event_idx_) - start_moment_);
+ m = min (m, vector_moment (event_idx_) - start_moment_);
return m;
}
#include "rest-collision.hh"
#include <cmath> // ceil.
+using namespace std;
#include "directional-element-interface.hh"
#include "duration.hh"
notedim.unite (notes[i]->extent (common, Y_AXIS));
}
- Real y = dir * std::max (0.0,
+ Real y = dir * max (0.0,
-dir * restdim[-dir] + dir * notedim[dir] + minimum_dist);
// move discretely by half spaces.
#include <cstdio>
#include <algorithm>
+using namespace std;
/*
#include <cstdio>
+using namespace std;
#include "book.hh"
#include "cpu-timer.hh"
rod.add_to_cols ();
}
- return std::max (dist, 0.0);
+ return max (dist, 0.0);
}
bool
#include <set>
#include <map>
+using namespace std;
#include "accidental-interface.hh"
#include "accidental-placement.hh"
total_off = minimum_space * dir;
if (current_off)
- total_off = dir * std::max (dir * total_off,
+ total_off = dir * max (dir * total_off,
dir * (*current_off));
/* FIXME: 1000 should relate to paper size. */
Real diff = (dir * staff_extent[dir] + staff_padding
- dir * total_off
+ dir * (staff_position - parent_position));
- total_off += dir * std::max (diff, 0.0);
+ total_off += dir * max (diff, 0.0);
}
}
return scm_from_double (total_off);
return;
}
- force_ = std::max (force_, block_force);
+ force_ = max (force_, block_force);
for (int i = l; i < r; i++)
- springs_[i].set_blocking_force (std::max (block_force, springs_[i].blocking_force ()));
+ springs_[i].set_blocking_force (max (block_force, springs_[i].blocking_force ()));
}
Real
if (line_len_ > (1 + 1e-6) * cur_len)
programming_error ("misuse of compress_line");
vector<Spring> sorted_springs = springs_;
- sort (sorted_springs.begin (), sorted_springs.end (), std::greater<Spring> ());
+ sort (sorted_springs.begin (), sorted_springs.end (), greater<Spring> ());
/* inv_hooke is the total flexibility of currently-active springs */
double inv_hooke = 0;
void
Simple_spacer::add_spring (Spring const &sp)
{
- force_ = std::max (force_, sp.blocking_force ());
+ force_ = max (force_, sp.blocking_force ());
springs_.push_back (sp);
}
but according to the amount of whitespace that is present after the end
of the line. */
if (ragged)
- return std::max (0.0, line_len_ - configuration_length (0.0));
+ return max (0.0, line_len_ - configuration_length (0.0));
/* Use a convex compression penalty. */
Real f = force_;
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
{
Music_iterator *it = unsmob<Music_iterator> (scm_car (s));
- next = std::min (next, it->pending_moment ());
+ next = min (next, it->pending_moment ());
}
return next;
Real
Skyline_pair::left () const
{
- return std::min (skylines_[UP].left (), skylines_[DOWN].left ());
+ return min (skylines_[UP].left (), skylines_[DOWN].left ());
}
Real
Skyline_pair::right () const
{
- return std::max (skylines_[UP].right (), skylines_[DOWN].right ());
+ return max (skylines_[UP].right (), skylines_[DOWN].right ());
}
void
// too steep to be stored in slope-intercept form, given round-off error
{
slope_ = 0.0;
- y_intercept_ = std::max (start_height, end_height);
+ y_intercept_ = max (start_height, end_height);
}
else
y_intercept_ = start_height - slope_ * start;
}
/* 'c' continues further, so move it into 'b' for the next pass. */
b = c;
- std::swap (sb, sc);
+ swap (sb, sc);
}
else /* b.end_ > c.end_ so finish with c */
{
Offset left = seg[LEFT];
Offset right = seg[RIGHT];
if (left[horizon_axis] > right[horizon_axis])
- std::swap (left, right);
+ swap (left, right);
Real x1 = left[horizon_axis];
Real x2 = right[horizon_axis];
Real touch = -infinity_f;
while (i != buildings_.end () && j != other.buildings_.end ())
{
- Real end = std::min (i->end_, j->end_);
+ Real end = min (i->end_, j->end_);
Real start_dist = i->height (start) + j->height (start);
Real end_dist = i->height (end) + j->height (end);
- dist = std::max (dist, std::max (start_dist, end_dist));
+ dist = max (dist, max (start_dist, end_dist));
if (end_dist == dist)
touch = end;
list<Building>::const_iterator i;
for (i = buildings_.begin (); i != buildings_.end (); ++i)
{
- ret = std::max (ret, i->height (i->start_));
- ret = std::max (ret, i->height (i->end_));
+ ret = max (ret, i->height (i->start_));
+ ret = max (ret, i->height (i->end_));
}
return sky_ * ret;
Real y = curve.get_other_coordinate (X_AXIS, p[X_AXIS]);
if (y)
- fit_factor = std::max (fit_factor, (p[Y_AXIS] / y));
+ fit_factor = max (fit_factor, (p[Y_AXIS] / y));
}
return fit_factor;
}
(control3 - control0). */
Real max_indent = len / 3.1;
- indent = std::min (indent, max_indent);
+ indent = min (indent, max_indent);
Real a1 = sqr (len) / 3.0;
Real a2 = 0.75 * sqr (indent + len / 3.0);
Real ff = fit_factor (dz_unit, dz_perp, state.parameters_.close_to_edge_length_,
curve, state.dir_, avoid);
- height = std::max (height, std::min (height * ff, max_h));
+ height = max (height, min (height * ff, max_h));
curve.control_[0] = attachment_[LEFT];
curve.control_[1] = attachment_[LEFT] + dz_perp * height * state.dir_
Real hd = (head_dy)
? (1 / fabs (head_dy) - 1 / state.parameters_.free_head_distance_)
: state.parameters_.head_encompass_penalty_;
- hd = std::min (std::max (hd, 0.0), state.parameters_.head_encompass_penalty_);
+ hd = min (max (hd, 0.0), state.parameters_.head_encompass_penalty_);
demerit += hd;
}
{
Real closest
- = state.dir_ * std::max (state.dir_ * state.encompass_infos_[j].get_point (state.dir_), state.dir_ * line_y);
+ = state.dir_ * max (state.dir_ * state.encompass_infos_[j].get_point (state.dir_), state.dir_ * line_y);
Real d = fabs (closest - y);
convex_head_distances.push_back (d);
for (vsize j = 0; j < n; j++)
{
- min_dist = std::min (min_dist, convex_head_distances[j]);
+ min_dist = min (min_dist, convex_head_distances[j]);
avg_distance += convex_head_distances[j];
}
Real variance_penalty = state.parameters_.head_slur_distance_max_ratio_;
if (min_dist > 0.0)
variance_penalty
- = std::min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty);
+ = min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty);
- variance_penalty = std::max (variance_penalty, 0.0);
+ variance_penalty = max (variance_penalty, 0.0);
variance_penalty *= state.parameters_.head_slur_distance_factor_;
add_score (variance_penalty, "variance");
else
programming_error ("unknown avoidance type");
- dist = std::max (dist, 0.0);
+ dist = max (dist, 0.0);
Real penalty = info.penalty_ * peak_around (0.1 * state.parameters_.extra_encompass_free_distance_,
state.parameters_.extra_encompass_free_distance_,
Real slur_dy = slur_dz[Y_AXIS];
Real demerit = 0.0;
- demerit += std::max ((fabs (slur_dy / slur_dz[X_AXIS])
+ demerit += max ((fabs (slur_dy / slur_dz[X_AXIS])
- state.parameters_.max_slope_), 0.0)
* state.parameters_.max_slope_factor_;
if (!state.is_broken_)
demerit += state.parameters_.steeper_slope_factor_
- * (std::max (fabs (slur_dy) - max_dy, 0.0));
+ * (max (fabs (slur_dy) - max_dy, 0.0));
- demerit += std::max ((fabs (slur_dy / slur_dz[X_AXIS])
+ demerit += max ((fabs (slur_dy / slur_dz[X_AXIS])
- state.parameters_.max_slope_), 0.0)
* state.parameters_.max_slope_factor_;
slur_->warning ("slur trying to encompass an empty note column.");
else
end_ys[d] = dir_
- * std::max (std::max (dir_ * (base_attachments_[d][Y_AXIS]
+ * max (max (dir_ * (base_attachments_[d][Y_AXIS]
+ parameters_.region_size_ * dir_),
dir_ * (dir_ + nc_extent[dir_])),
dir_ * base_attachments_[-d][Y_AXIS]);
continue;
Encompass_info inf (get_encompass_info (encompasses[i]));
- Real y = dir_ * (std::max (dir_ * inf.head_, dir_ * inf.stem_));
+ Real y = dir_ * (max (dir_ * inf.head_, dir_ * inf.stem_));
avoid.push_back (Offset (inf.x_, y + dir_ * parameters_.free_head_distance_));
}
}
}
- Real avoidance_offset = do_shift ? curve.minmax (X_AXIS, std::max (xext[LEFT], curve.control_[0][X_AXIS] + EPS), std::min (xext[RIGHT], curve.control_[3][X_AXIS] - EPS), dir) - yext[-dir] : 0.0;
+ Real avoidance_offset = do_shift ? curve.minmax (X_AXIS, max (xext[LEFT], curve.control_[0][X_AXIS] + EPS), min (xext[RIGHT], curve.control_[3][X_AXIS] - EPS), dir) - yext[-dir] : 0.0;
return scm_from_double (offset + avoidance_offset);
}
#else
#include <strstream>
#endif
+using namespace std;
#include "file-name-map.hh"
#include "international.hh"
int read_count = real_size;
if (desired_size > 0)
- read_count = std::min (read_count, desired_size);
+ read_count = min (read_count, desired_size);
rewind (f);
else
{
istream_ = new istringstream ("");
- istream_->setstate (std::ios::eofbit);
- // istream_->set (std::ios::eofbit);
+ istream_->setstate (ios::eofbit);
+ // istream_->set (ios::eofbit);
}
}
return istream_;
/* this will find the '\n' character at the end of our line */
vsize lo = lower_bound (newline_locations_,
pos_str0,
- std::less<char const *> ());
+ less<char const *> ());
/* the return value will be indexed from 1 */
return lo + 1 + line_offset_;
Spring
Spacing_spanner::standard_breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *options)
{
- Real min_dist = std::max (0.0, Paper_column::minimum_distance (l, r));
+ Real min_dist = max (0.0, Paper_column::minimum_distance (l, r));
if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
{
if (Moment *measure_len = get_measure_length (lc))
{
- delta_t = std::min (delta_t, *measure_len);
+ delta_t = min (delta_t, *measure_len);
/*
The following is an extra safety measure, such that
the length of a mmrest event doesn't cause havoc.
*/
- shortest_playing_len = std::min (shortest_playing_len, *measure_len);
+ shortest_playing_len = min (shortest_playing_len, *measure_len);
}
Spring ret;
ret = Spring (fraction * len, fraction * min);
// Stretch proportional to the space between canonical bare noteheads
- ret.set_inverse_stretch_strength (fraction * std::max (0.1, (len - min)));
+ ret.set_inverse_stretch_strength (fraction * max (0.1, (len - min)));
}
else if (delta_t.grace_part_)
{
Spring base = note_spacing (me, lc, rc, options);
Spring spring = Note_spacing::get_spacing (sp, rc, base, options->increment_);
- dists[d] = std::max (dists[d], spring.min_distance ());
+ dists[d] = max (dists[d], spring.min_distance ());
}
else if (has_interface<Staff_spacing> (sp))
{
Spring spring = Staff_spacing::get_spacing (sp, rc, 0.0);
- dists[d] = std::max (dists[d], spring.min_distance ());
+ dists[d] = max (dists[d], spring.min_distance ());
}
else
programming_error ("Subversive spacing wish");
if (ev)
{
Moment m = get_event_length (ev);
- shortest_playing = std::min (shortest_playing, m);
+ shortest_playing = min (shortest_playing, m);
}
}
Moment starter;
Moment m = get_event_length (now_durations_[i].info_.event_cause ());
if (m.to_bool ())
{
- starter = std::min (starter, m);
+ starter = min (starter, m);
playing_durations_.insert (now_durations_[i]);
}
}
now_durations_.clear ();
- shortest_playing = std::min (shortest_playing, starter);
+ shortest_playing = min (shortest_playing, starter);
assert (starter.to_bool ());
SCM sh = shortest_playing.smobbed_copy ();
{
Drul_array<Skyline> skylines = Spacing_interface::skylines (me, right);
- return std::max (0.0, skylines[LEFT].distance (skylines[RIGHT]));
+ return max (0.0, skylines[LEFT].distance (skylines[RIGHT]));
}
/*
}
Real loose_col_horizontal_length = loose_col->extent (loose_col, X_AXIS).length ();
- base_note_space = std::max (base_note_space, loose_col_horizontal_length);
- tight_note_space = std::max (tight_note_space, loose_col_horizontal_length);
+ base_note_space = max (base_note_space, loose_col_horizontal_length);
+ tight_note_space = max (tight_note_space, loose_col_horizontal_length);
clique_spacing.push_back (base_note_space);
clique_tight_spacing.push_back (tight_note_space);
sum_tight_spacing += clique_tight_spacing[j];
sum_spacing += clique_spacing[j];
}
- Real scale_factor = std::max (0.0, std::min (1.0, (permissible_distance - left_padding - sum_tight_spacing) / (sum_spacing - sum_tight_spacing)));
+ Real scale_factor = max (0.0, min (1.0, (permissible_distance - left_padding - sum_tight_spacing) / (sum_spacing - sum_tight_spacing)));
for (vsize j = clique.size () - 2; j > 0; j--)
{
Paper_column *clique_col = dynamic_cast<Paper_column *> (clique[j]);
SCM st = cols[i]->get_property ("shortest-starter-duration");
Moment this_shortest = *unsmob<Moment> (st);
assert (this_shortest.to_bool ());
- shortest_in_measure = std::min (shortest_in_measure, this_shortest.main_part_);
+ shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
}
else if (!shortest_in_measure.is_infinity ()
&& Paper_column::is_breakable (cols[i]))
d = m->main_part_;
if (max_idx != VPOS)
- d = std::min (d, durations[max_idx]);
+ d = min (d, durations[max_idx]);
return Moment (d).smobbed_copy ();
}
/* min rather than max because stickout will be negative if the right-hand column
sticks out a lot to the left */
- Real stickout = std::min (skys ? (*skys)[LEFT].max_height () : 0.0,
+ Real stickout = min (skys ? (*skys)[LEFT].max_height () : 0.0,
Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
Real prev_distances = 0.0;
Item *lb = l->find_prebroken_piece (RIGHT);
Real dist = Separation_item::set_distance (l, r, padding);
- distances[i] = std::max (distances[i], dist - prev_distances);
+ distances[i] = max (distances[i], dist - prev_distances);
if (lb)
{
// right than the unbroken version, by extending farther and/or
// nesting more closely;
if (j == i - 1) // check this, the first time we see each lb.
- overhangs[j] = std::max (overhangs[j],
+ overhangs[j] = max (overhangs[j],
lb->extent (lb, X_AXIS)[RIGHT]
+ distances[i] - dist);
}
prev_distances += distances[j];
}
- overhangs[i] = std::max (overhangs[i],
+ overhangs[i] = max (overhangs[i],
overhangs[i - 1] - distances[i]);
}
}
if (Paper_column::is_extraneous_column_from_ligature (left_col))
spring.set_distance (spring.min_distance ());
else
- spring.set_distance (std::max (left_col->extent (left_col, X_AXIS)[RIGHT],
+ spring.set_distance (max (left_col->extent (left_col, X_AXIS)[RIGHT],
spring.min_distance ()));
spring.set_inverse_stretch_strength (1.0);
void
Spring::operator *= (Real r)
{
- distance_ = std::max (min_distance_, distance_ * r);
- inverse_compress_strength_ = std::max (0.0, distance_ - min_distance_);
+ distance_ = max (min_distance_, distance_ * r);
+ inverse_compress_strength_ = max (0.0, distance_ - min_distance_);
inverse_stretch_strength_ *= r;
update_blocking_force ();
}
avg_distance += springs[i].distance ();
avg_stretch += springs[i].inverse_stretch_strength ();
avg_compress += 1 / springs[i].inverse_compress_strength ();
- min_distance = std::max (springs[i].min_distance (), min_distance);
+ min_distance = max (springs[i].min_distance (), min_distance);
}
avg_stretch /= Real (springs.size ());
avg_compress /= Real (springs.size ());
avg_distance /= Real (springs.size ());
- avg_distance = std::max (min_distance + 0.3, avg_distance);
+ avg_distance = max (min_distance + 0.3, avg_distance);
Spring ret = Spring (avg_distance, min_distance);
ret.set_inverse_stretch_strength (avg_stretch);
void
Spring::ensure_min_distance (Real d)
{
- set_min_distance (std::max (d, min_distance_));
+ set_min_distance (max (d, min_distance_));
}
void
Real
Spring::length (Real f) const
{
- Real force = std::max (f, blocking_force_);
+ Real force = max (f, blocking_force_);
Real inv_k = force < 0.0 ? inverse_compress_strength_ : inverse_stretch_strength_;
if (isinf (force))
// There is a corner case here: if min_distance_ is larger than
// distance_ but the spring is fixed, then inv_k will be zero
// and we need to make sure that we return min_distance_.
- return std::max (min_distance_, distance_ + force * inv_k);
+ return max (min_distance_, distance_ + force * inv_k);
}
#include "staff-spacing.hh"
#include <cstdio>
+using namespace std;
#include "international.hh"
#include "paper-column.hh"
stem_posns.intersect (bar_height);
- ret = std::min (abs (stem_posns.length () / 7.0), 1.0);
+ ret = min (abs (stem_posns.length () / 7.0), 1.0);
ret *= robust_scm2double (me->get_property ("stem-spacing-correction"), 1);
}
}
Real max_optical = 0.0;
for (vsize i = 0; i < note_columns.size (); i++)
- max_optical = std::max (max_optical, optical_correction (me, note_columns[i], bar_size));
+ max_optical = max (max_optical, optical_correction (me, note_columns[i], bar_size));
return max_optical;
}
ideal = fixed + distance / 2;
}
else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
- ideal = last_ext[LEFT] + std::max (last_ext.length (), distance);
+ ideal = last_ext[LEFT] + max (last_ext.length (), distance);
else if (scm_is_eq (type, ly_symbol2scm ("minimum-fixed-space")))
{
- fixed = last_ext[LEFT] + std::max (last_ext.length (), distance);
+ fixed = last_ext[LEFT] + max (last_ext.length (), distance);
ideal = fixed;
}
Real min_dist = Paper_column::minimum_distance (left_col, right_col);
/* ensure that the "fixed" distance will leave a gap of at least 0.3 ss. */
- Real min_dist_correction = std::max (0.0, 0.3 + min_dist - fixed);
+ Real min_dist_correction = max (0.0, 0.3 + min_dist - fixed);
fixed += min_dist_correction;
- ideal = std::max (ideal, fixed);
+ ideal = max (ideal, fixed);
Spring ret (ideal, min_dist);
- ret.set_inverse_stretch_strength (std::max (0.0, stretchability));
- ret.set_inverse_compress_strength (std::max (0.0, ideal - fixed));
+ ret.set_inverse_stretch_strength (max (0.0, stretchability));
+ ret.set_inverse_compress_strength (max (0.0, ideal - fixed));
return ret;
}
int beam_count = Stem::beam_multiplicity (stem).length () + 1;
Real beam_translation = get_beam_translation (me);
- ph = ph - dir * std::max (beam_count, 1) * beam_translation;
+ ph = ph - dir * max (beam_count, 1) * beam_translation;
ph = ph - ph.center ();
return ly_interval2scm (ph);
Stem_info si = Stem::get_stem_info (stem);
ph[-dir] = si.shortest_y_;
- return (ph - dir * std::max (beam_count, 1) * beam_translation)[dir] - dir * 0.5 * me->pure_y_extent (me, 0, INT_MAX).length ();
+ return (ph - dir * max (beam_count, 1) * beam_translation)[dir] - dir * 0.5 * me->pure_y_extent (me, 0, INT_MAX).length ();
}
Real end_y
= (pure
? stem->pure_y_extent (stem, 0, INT_MAX)[dir]
: stem->extent (stem, Y_AXIS)[dir])
- - dir * std::max (beam_count, 1) * beam_translation
+ - dir * max (beam_count, 1) * beam_translation
- Stem::beam_end_corrective (stem);
if (!beam && Stem::duration_log (stem) >= 3)
#include "spanner.hh"
#include <cmath> // rint
+using namespace std;
#include "beam.hh"
#include "directional-element-interface.hh"
SCM lst = index_get_cell (pair, d);
int len = scm_ilength (lst);
- return std::max (len, 0);
+ return max (len, 0);
}
Interval
height[-d] = (height[d] - d
* (0.5 * beam_thickness
- + beam_translation * std::max (0, (beam_count - 1))
+ + beam_translation * max (0, (beam_count - 1))
+ stemlet_length));
}
else if (!stemlet && beam)
ps.push_back (p);
}
- vector_sort (ps, std::less<int> ());
+ vector_sort (ps, less<int> ());
return ps;
}
for (vsize i = 0; i < my_stems.size (); i++)
{
coords.push_back (my_stems[i]->pure_relative_y_coordinate (common, 0, INT_MAX));
- min_pos = std::min (min_pos, coords[i]);
- max_pos = std::max (max_pos, coords[i]);
+ min_pos = min (min_pos, coords[i]);
+ max_pos = max (max_pos, coords[i]);
}
for (vsize i = 0; i < heights.size (); i++)
{
{
SCM sshorten = ly_assoc_get (ly_symbol2scm ("stem-shorten"), details, SCM_EOL);
SCM scm_shorten = scm_is_pair (sshorten)
- ? robust_list_ref (std::max (duration_log (me) - 2, 0), sshorten) : SCM_EOL;
+ ? robust_list_ref (max (duration_log (me) - 2, 0), sshorten) : SCM_EOL;
Real shorten_property = 2 * robust_scm2double (scm_shorten, 0);
/* change in length between full-size and shortened stems is executed gradually.
"transition area" = stems between full-sized and fully-shortened.
(but not greater than 1/2 and not smaller than 1/4).
value 6 is heuristic; it determines the suggested transition slope steepnesas.
*/
- Real shortening_step = std::min (std::max (0.25, (shorten_property / 6)), 0.5);
+ Real shortening_step = min (max (0.25, (shorten_property / 6)), 0.5);
/* Shortening of unflagged stems should begin on the first stem that sticks
more than 1 staffspace (2 units) out of the staff.
Shortening of flagged stems begins in the same moment as unflagged ones,
but not earlier than on the middle line note.
*/
- Real which_step = (std::min (1.0, quarter_stem_length - (2 * staff_rad) - 2.0)) + abs (hp[dir]);
- Real shorten = std::min (std::max (0.0, (shortening_step * which_step)), shorten_property);
+ Real which_step = (min (1.0, quarter_stem_length - (2 * staff_rad) - 2.0)) + abs (hp[dir]);
+ Real shorten = min (max (0.0, (shortening_step * which_step)), shorten_property);
length -= shorten;
}
if (dir == UP)
minlen += beam_trans;
}
- length = std::max (length, minlen + 1.0);
+ length = max (length, minlen + 1.0);
}
Real stem_end = dir ? hp[dir] + dir * length : 0;
Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
- Interval stem_y = Interval (std::min (y1, y2), std::max (y2, y1)) * half_space;
+ Interval stem_y = Interval (min (y1, y2), max (y2, y1)) * half_space;
return stem_y;
}
Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
- Interval stem_y = Interval (std::min (y1, y2), std::max (y2, y1)) * half_space;
+ Interval stem_y = Interval (min (y1, y2), max (y2, y1)) * half_space;
stem_y[dir] -= beam_end_corrective (me);
/* stem only extends to center of beam */
- 0.5 * beam_thickness;
- ideal_length = std::max (ideal_length, ideal_minimum_length);
+ ideal_length = max (ideal_length, ideal_minimum_length);
/* Convert to Y position, calculate for dir == UP */
Real note_start
{
/* Highest beam of (UP) beam must never be lower than middle
staffline */
- ideal_y = std::max (ideal_y, 0.0);
+ ideal_y = max (ideal_y, 0.0);
/* Lowest beam of (UP) beam must never be lower than second staffline */
- ideal_y = std::max (ideal_y, (-staff_space
+ ideal_y = max (ideal_y, (-staff_space
- beam_thickness + height_of_my_beams));
}
* length_fraction)
: 0.0);
- Real minimum_length = std::max (minimum_free, height_of_my_trem)
+ Real minimum_length = max (minimum_free, height_of_my_trem)
+ height_of_my_beams
/* stem only extends to center of beam */
- 0.5 * beam_thickness;
#include "skyline.hh"
#include "skyline-pair.hh"
#include "spanner.hh"
+using namespace std;
using std::string;
using std::vector;
//////////////////////
if (x1 < x0)
{
- std::swap (x0, x1);
- std::swap (y0, y1);
+ swap (x0, x1);
+ swap (y0, y1);
}
Offset left (x0, y0);
Offset right (x1, y1);
Offset ep (cos (end) * x_rad, sin (end) * y_rad);
//////////////////////
Drul_array<vector<Offset> > points;
- int quantization = std::max (1, (int) (((x_rad * trans.xx) + (y_rad * trans.yy)) * M_PI / QUANTIZATION_UNIT));
+ int quantization = max (1, (int) (((x_rad * trans.xx) + (y_rad * trans.yy)) * M_PI / QUANTIZATION_UNIT));
for (DOWN_and_UP (d))
{
for (vsize i = 0; i < 1 + (vsize) quantization; i++)
{
assert (abs (xlen - ylen) < 10e-3);
- Real scale_factor = std::max (xlen, ylen);
+ Real scale_factor = max (xlen, ylen);
// the three operations below move the stencil from its original coordinates to current coordinates
pango_matrix_translate (&transcopy, kerned_bbox[X_AXIS][LEFT],
kerned_bbox[Y_AXIS][DOWN] - real_bbox[Y_AXIS][DOWN]);
/* See scheme Function. */
// Any stencil that is empty in the orthogonal axis is spacing.
-// Spacing is not subjected to the std::max (0) rule and can thus be
+// Spacing is not subjected to the max (0) rule and can thus be
// negative.
void
int
lo = 0;
- int hi = std::max ((int) fm->count () - 1, 2);
+ int hi = max ((int) fm->count () - 1, 2);
/* do a binary search for each Y, not very efficient, but passable? */
Box b;
#include "engraver.hh"
+using namespace std;
#include "articulations.hh"
#include "duration.hh"
#include "engraver.hh"
+using namespace std;
#include "context.hh"
#include "item.hh"
int max_length = 0;
for (SCM s = replacement_alist; scm_is_pair (s); s = scm_cdr (s))
{
- max_length = std::max (max_length, scm_to_int
+ max_length = max (max_length, scm_to_int
(scm_string_length (scm_caar (s))));
}
#include "tie-formatting-problem.hh"
#include "tie-configuration.hh"
+using namespace std;
using std::vector;
void
for (vsize i = 0; i < bounds.size (); i++)
ranks.push_back (bounds[i]->get_column ()->get_rank ());
- vector_sort (ranks, std::less<int> ());
+ vector_sort (ranks, less<int> ());
uniq (ranks);
for (vsize i = 0; i < ranks.size (); i++)
}
if (y_tune
- && std::max (fabs (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y),
+ && max (fabs (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y),
fabs (get_head_extent (columns[RIGHT], RIGHT, Y_AXIS)[dir] - y)) < 0.25
&& !Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos))
{
continue;
conf->attachment_x_[d]
- = d * std::min (d * conf->attachment_x_[d],
+ = d * min (d * conf->attachment_x_[d],
d * (get_stem_extent (conf->column_ranks_[d], d, X_AXIS)[-d] - d * details_.stem_gap_));
}
}
}
{
- Real relevant_dist = std::max (fabs (curve_y - tie_y) - 0.5, 0.0);
+ Real relevant_dist = max (fabs (curve_y - tie_y) - 0.5, 0.0);
Real p = details_.vertical_distance_penalty_factor_ * convex_amplifier (1.0, 0.9, relevant_dist);
if (ties_conf)
ties_conf->add_tie_score (p, tie_idx, "vdist");
if (to_boolean (me->get_property ("full-length-to-extent")))
coord = robust_relative_extent (bounds[d], commonx, X_AXIS)[LEFT];
- coord = std::max (coord, x_span[LEFT]);
+ coord = max (coord, x_span[LEFT]);
x_span[d] = coord - padding;
}
Tuplet_iterator::pending_moment () const
{
Moment next_mom = Music_wrapper_iterator::pending_moment ();
- next_mom = std::min (next_mom, next_split_mom_);
+ next_mom = min (next_mom, next_split_mom_);
return next_mom;
}
if (m.main_part_ < music_get_length ().main_part_)
{
spanner_duration_ =
- std::min (music_get_length () - next_split_mom_, spanner_duration_);
+ min (music_get_length () - next_split_mom_, spanner_duration_);
tuplet_handler_.set_context (get_outlet ());
report_event (create_event (START));
++count;
}
- return std::max (0, count - 1);
+ return max (0, count - 1);
}
MAKE_SCHEME_CALLBACK (Tuplet_number, calc_y_offset, 1);
: staff_ext_y[DOWN] > ref_stem_ext[UP];
if (move)
{
- Interval ledger_domain = Interval (std::min (staff_ext_y[UP], ref_stem_ext[UP]),
- std::max (staff_ext_y[DOWN], ref_stem_ext[DOWN]));
+ Interval ledger_domain = Interval (min (staff_ext_y[UP], ref_stem_ext[UP]),
+ max (staff_ext_y[DOWN], ref_stem_ext[DOWN]));
Interval num_y (me->extent (commony, Y_AXIS));
num_y.translate (y_offset);
Interval num_ledger_overlap (num_y);
add_mora_column (prev_primitive->get_column ());
#if 0 // experimental code to collapse spacing after ligature
- /* TODO: set to std::max (old/new spacing-increment), since other
+ /* TODO: set to max (old/new spacing-increment), since other
voices/staves also may want to set this property. */
Item *first_primitive = dynamic_cast<Item *> (primitives[0].grob ());
Paper_column *paper_column = first_primitive->get_column ();
*/
Real left_height
= right_height
- + std::min (0.12 * abs (interval), 0.3) * staff_space;
+ + min (0.12 * abs (interval), 0.3) * staff_space;
/*
* Compensate optical illusion regarding vertical position of left
*/
#include <cstring>
+using namespace std;
#include "warn.hh"
#include "font-interface.hh"
projects / lilypond.git / commitdiff