Issue 4550 (2/2) Avoid "using namespace std;" in included files

These changes are produced by a rather long shell script that is
posted in the code review for this issue.  Summary:

* remove "using namespace std;" everywhere
* add "std::" in *.hh and other included files
* add "std::" to functions and lesser-used types in *.cc files

269 files changed, 819 insertions, 901 deletions

diff --git a/flower/file-cookie.cc b/flower/file-cookie.cc
index 762acb1c06..36871d705d 100644
--- a/flower/file-cookie.cc
+++ b/flower/file-cookie.cc
@@ -1,7 +1,6 @@
 
 #include <cassert>
 #include <cstdio>
-using namespace std;
 
 #include "memory-stream.hh"
 
diff --git a/flower/file-name.cc b/flower/file-name.cc
index 71b3bf27b5..24db2021b0 100644
--- a/flower/file-name.cc
+++ b/flower/file-name.cc
@@ -25,7 +25,6 @@
 #include <unistd.h>
 #include <limits.h>
 
-using namespace std;
 
 #include "config.hh"
 
diff --git a/flower/getopt-long.cc b/flower/getopt-long.cc
index 49f7c8831d..658faed921 100644
--- a/flower/getopt-long.cc
+++ b/flower/getopt-long.cc
@@ -318,7 +318,7 @@ Long_option_init::table_string (Long_option_init *l)
 
   size_t wid = 0;
   for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
-    wid = max (wid, l[i].str_for_help ().length ());
+    wid = std::max (wid, l[i].str_for_help ().length ());
 
   for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
     {
diff --git a/flower/include/cpu-timer.hh b/flower/include/cpu-timer.hh
index 3c492eeef9..e77cc1f2a6 100644
--- a/flower/include/cpu-timer.hh
+++ b/flower/include/cpu-timer.hh
@@ -21,7 +21,6 @@
 #define CPU_TIMER_HH
 
 #include <ctime>
-using namespace std;
 
 #include "real.hh"
 
diff --git a/flower/include/direction.hh b/flower/include/direction.hh
index 0d36c0f7c7..dff5467497 100644
--- a/flower/include/direction.hh
+++ b/flower/include/direction.hh
@@ -71,9 +71,9 @@ operator - (Direction d)
 template<class T> T minmax (Direction d, T a, T b)
 {
   if (d == UP)
-    return max (a, b);
+    return std::max (a, b);
   else
-    return min (a, b);
+    return std::min (a, b);
 }
 
 #endif // DIRECTION_HH
diff --git a/flower/include/file-cookie.hh b/flower/include/file-cookie.hh
index 6bdb236699..d55a918c87 100644
--- a/flower/include/file-cookie.hh
+++ b/flower/include/file-cookie.hh
@@ -5,7 +5,6 @@ extern "C" {
 #include <unistd.h>
 
 #include <cstdio>
-  using namespace std;
 
 #if (! defined (__off64_t) && ! defined (__off64_t_defined)) || ! defined (__cplusplus)
 #define off64_t unsigned long long
diff --git a/flower/include/file-name.hh b/flower/include/file-name.hh
index 6f2da75093..6f05a03635 100644
--- a/flower/include/file-name.hh
+++ b/flower/include/file-name.hh
@@ -29,18 +29,18 @@ std::string get_working_directory ();
 class File_name
 {
 public:
-  string root_;
-  string dir_;
-  string base_;
-  string ext_;
+  std::string root_;
+  std::string dir_;
+  std::string base_;
+  std::string ext_;
 
-  File_name (string = "");
+  File_name (std::string = "");
 
   bool is_absolute () const;
-  string to_string () const;
+  std::string to_string () const;
   File_name canonicalized () const;
-  string dir_part () const;
-  string file_part () const;
+  std::string dir_part () const;
+  std::string file_part () const;
 };
 
 #endif /* FILE_NAME */
diff --git a/flower/include/file-path.hh b/flower/include/file-path.hh
index 1c039cf4ab..c3597934d9 100644
--- a/flower/include/file-path.hh
+++ b/flower/include/file-path.hh
@@ -34,20 +34,20 @@
 
 class File_path
 {
-  vector<string> dirs_;
+  std::vector<std::string> dirs_;
 
 public:
-  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&);
+  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&);
 };
 
-bool is_file (const string &file_name);
-bool is_dir (string file_name);
+bool is_file (const std::string &file_name);
+bool is_dir (std::string file_name);
 
 #endif /* FILE_PATH */
diff --git a/flower/include/flower-proto.hh b/flower/include/flower-proto.hh
index 33e587d000..1ba3760f2e 100644
--- a/flower/include/flower-proto.hh
+++ b/flower/include/flower-proto.hh
@@ -27,7 +27,6 @@ typedef long long I64;
 class String_convert;
 
 #include "real.hh"
-using namespace std;
 
 template<class T> struct Interval_t;
 template<class T> struct PQueue;
diff --git a/flower/include/getopt-long.hh b/flower/include/getopt-long.hh
index 52c819822c..2e13188a60 100644
--- a/flower/include/getopt-long.hh
+++ b/flower/include/getopt-long.hh
@@ -20,12 +20,12 @@ struct Long_option_init
 
   char const *help_str0_;
 
-  string to_string () const;
-  string str_for_help () const;
+  std::string to_string () const;
+  std::string str_for_help () const;
   //   NO constructor!
 
   static int compare (Long_option_init const &, Long_option_init const &);
-  static string table_string (Long_option_init *);
+  static std::string table_string (Long_option_init *);
 };
 
 /** C++ for version of long_getopt.  For processing GNU style command
diff --git a/flower/include/international.hh b/flower/include/international.hh
index f2f48996de..90495578cd 100644
--- a/flower/include/international.hh
+++ b/flower/include/international.hh
@@ -35,19 +35,19 @@
 /**
    Internationalisation: _ ("to be translated") gets "translated" by GNU gettext
 */
-string _ (char const *ch);
+std::string _ (char const *ch);
 
 /**
    Internationalisation: _f ("Usage: %s [FILE]", "lilypond") gets "translated" by
    GNU gettext
 */
-string _f (char const *format, ...)
+std::string _f (char const *format, ...)
 __attribute__ ((format (printf, 1, 2)));
-string _f (char const *format, const string &s, const string &s2 = "", const string &s3 = "");
+std::string _f (char const *format, const std::string &s, const std::string &s2 = "", const std::string &s3 = "");
 /**
    va_list version of _f
  */
-string v_f (char const *format, va_list args);
+std::string v_f (char const *format, va_list args);
 
 #endif // INTERNATIONAL_HH
 
diff --git a/flower/include/interval-set.hh b/flower/include/interval-set.hh
index 84f6debb30..610866be32 100644
--- a/flower/include/interval-set.hh
+++ b/flower/include/interval-set.hh
@@ -28,15 +28,15 @@ class Interval_set
 public:
   Interval_set ();
 
-  static Interval_set interval_union (vector<Interval>);
+  static Interval_set interval_union (std::vector<Interval>);
 
-  vector<Interval> const &intervals () const { return intervals_; }
-  vector<Interval>::const_iterator upper_bound (Real x) const;
+  std::vector<Interval> const &intervals () const { return intervals_; }
+  std::vector<Interval>::const_iterator upper_bound (Real x) const;
   Real nearest_point (Real x, Direction dir = CENTER) const;
   Interval_set complement () const;
 
 private:
-  vector<Interval> intervals_;
+  std::vector<Interval> intervals_;
 };
 
 #endif /* INTERVAL_SET_HH */
diff --git a/flower/include/interval.hh b/flower/include/interval.hh
index 88cd01f89f..c4beb9bb99 100644
--- a/flower/include/interval.hh
+++ b/flower/include/interval.hh
@@ -35,7 +35,7 @@ struct Interval_t : public Drul_array<T>
   using Drul_array<T>::at;
 
   static T infinity ();
-  static string T_to_string (T arg);
+  static std::string T_to_string (T arg);
   T center () const;
   void translate (T t)
   {
@@ -65,8 +65,8 @@ struct Interval_t : public Drul_array<T>
   void intersect (Interval_t<T> h);
   void add_point (T p)
   {
-    at (LEFT) = min (at (LEFT), p);
-    at (RIGHT) = max (at (RIGHT), p);
+    at (LEFT) = std::min (at (LEFT), p);
+    at (RIGHT) = std::max (at (RIGHT), p);
   }
   T length () const;
 
@@ -120,7 +120,7 @@ struct Interval_t : public Drul_array<T>
   }
 
   Real linear_combination (Real x) const;
-  string to_string () const;
+  std::string to_string () const;
 
   bool contains (T r) const;
   void negate ()
diff --git a/flower/include/interval.tcc b/flower/include/interval.tcc
index 72be6e81e9..f0973b8b09 100644
--- a/flower/include/interval.tcc
+++ b/flower/include/interval.tcc
@@ -27,7 +27,6 @@
 
 // MacOS 10.3 problems:
 // #include <cmath>
-using namespace std;
 
 template<class T>
 int
@@ -103,8 +102,8 @@ template<class T>
 void
 Interval_t<T>::unite (Interval_t<T> h)
 {
-  at (LEFT) = min (h.at (LEFT), at (LEFT));
-  at (RIGHT) = max (h.at (RIGHT), at (RIGHT));
+  at (LEFT) = std::min (h.at (LEFT), at (LEFT));
+  at (RIGHT) = std::max (h.at (RIGHT), at (RIGHT));
 }
 
 /* Unites h and this interval, but in such a way
@@ -136,20 +135,20 @@ template<class T>
 void
 Interval_t<T>::intersect (Interval_t<T> h)
 {
-  at (LEFT) = max (h.at (LEFT), at (LEFT));
-  at (RIGHT) = min (h.at (RIGHT), at (RIGHT));
+  at (LEFT) = std::max (h.at (LEFT), at (LEFT));
+  at (RIGHT) = std::min (h.at (RIGHT), at (RIGHT));
 }
 
 template<class T>
-string
+std::string
 Interval_t<T>::to_string () const
 {
   if (is_empty ())
     return "[empty]";
-  string s ("[");
+  std::string s ("[");
 
-  return (s + T_to_string (at (LEFT)) + string (",")
-          + T_to_string (at (RIGHT)) + string ("]"));
+  return (s + T_to_string (at (LEFT)) + std::string (",")
+          + T_to_string (at (RIGHT)) + std::string ("]"));
 }
 
 template<class T>
diff --git a/flower/include/libc-extension.hh b/flower/include/libc-extension.hh
index 04056e6c49..974b5521ab 100644
--- a/flower/include/libc-extension.hh
+++ b/flower/include/libc-extension.hh
@@ -22,7 +22,6 @@
 
 #include <cstddef>
 #include <cstdarg>
-using namespace std;
 
 #include "config.hh"
 
diff --git a/flower/include/matrix.hh b/flower/include/matrix.hh
index a6c13f837c..6b2e61c359 100644
--- a/flower/include/matrix.hh
+++ b/flower/include/matrix.hh
@@ -57,7 +57,7 @@ public:
       data_.resize (rows * columns, t);
     else
       {
-        vector<T, A> new_data;
+        std::vector<T, A> new_data;
         new_data.resize (rows * columns, t);
         vsize cur_cols = rank_ ? data_.size () / rank_ : 0;
 
@@ -70,7 +70,7 @@ public:
   }
 
 private:
-  vector<T, A> data_;
+  std::vector<T, A> data_;
   vsize rank_;
 };
 
diff --git a/flower/include/memory-stream.hh b/flower/include/memory-stream.hh
index 2cce5986b5..3a355e9337 100644
--- a/flower/include/memory-stream.hh
+++ b/flower/include/memory-stream.hh
@@ -22,7 +22,6 @@
 
 #include <cstdio>
 #include <unistd.h>
-using namespace std;
 
 #include "libc-extension.hh"
 #include "file-cookie.hh"
diff --git a/flower/include/offset.hh b/flower/include/offset.hh
index 8f395398b7..b34964c9e8 100644
--- a/flower/include/offset.hh
+++ b/flower/include/offset.hh
@@ -101,7 +101,7 @@ public:
     coordinate_a_[X_AXIS] = coordinate_a_[Y_AXIS] = 0.0;
   }
 
-  string to_string () const;
+  std::string to_string () const;
 
   Offset &mirror (Axis a)
   {
diff --git a/flower/include/parray.hh b/flower/include/parray.hh
index 9ef9ddb217..471b9f5858 100644
--- a/flower/include/parray.hh
+++ b/flower/include/parray.hh
@@ -22,10 +22,9 @@
 
 #include "std-vector.hh"
 
-using namespace std;
 
 template<class T>
-class Link_array : public vector<T *>
+class Link_array : public std::vector<T *>
 {
 
 };
diff --git a/flower/include/polynomial.hh b/flower/include/polynomial.hh
index f80b53c2ee..379609bcaf 100644
--- a/flower/include/polynomial.hh
+++ b/flower/include/polynomial.hh
@@ -36,7 +36,7 @@ struct Polynomial
   ssize_t degree ()const;
 
   /// coefficients
-  vector<Real> coefs_;
+  std::vector<Real> coefs_;
 
   // leading coef
   Real &lc ();
@@ -46,8 +46,8 @@ struct Polynomial
   void print () const;
   Real eval (Real) const;
   Real minmax (Real, Real, bool) const;
-  void print_sols (vector<Real>) const;
-  void check_sols (vector<Real>) const;
+  void print_sols (std::vector<Real>) const;
+  void check_sols (std::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);
@@ -73,11 +73,11 @@ struct Polynomial
 
   void debug_clean ();
 
-  vector<Real> solve_quadric ()const;
-  vector<Real> solve_cubic ()const;
-  vector<Real> solve_linear ()const;
+  std::vector<Real> solve_quadric ()const;
+  std::vector<Real> solve_cubic ()const;
+  std::vector<Real> solve_linear ()const;
 
-  vector<Real> solve () const;
+  std::vector<Real> solve () const;
 };
 
 IMPLEMENT_ARITHMETIC_OPERATOR (Polynomial, -);
diff --git a/flower/include/pqueue.hh b/flower/include/pqueue.hh
index 6f1ebc53b6..923773f500 100644
--- a/flower/include/pqueue.hh
+++ b/flower/include/pqueue.hh
@@ -45,7 +45,7 @@ int compare (PQueue_ent<K, T> const &e1, PQueue_ent<K, T> const &e2)
 template<class T>
 class PQueue
 {
-  vector<T> heap_array_;
+  std::vector<T> heap_array_;
   T &elt (vsize i)
   {
     return heap_array_[i - 1];
diff --git a/flower/include/rational.hh b/flower/include/rational.hh
index f829e531ec..d8051c922a 100644
--- a/flower/include/rational.hh
+++ b/flower/include/rational.hh
@@ -86,7 +86,7 @@ public:
   Rational &operator %= (Rational);
   static int compare (Rational const &, Rational const &);
   int sign () const;
-  string to_string () const;
+  std::string to_string () const;
 };
 
 #include "arithmetic-operator.hh"
diff --git a/flower/include/real.hh b/flower/include/real.hh
index d7208b4e56..0b0cf59419 100644
--- a/flower/include/real.hh
+++ b/flower/include/real.hh
@@ -23,7 +23,6 @@
 #include <algorithm>
 #include <climits>
 #include <cmath>
-using namespace std;
 
 typedef double Real;
 extern const Real infinity_f;
diff --git a/flower/include/std-string.hh b/flower/include/std-string.hh
index bdb85795ab..2e2908f7a2 100644
--- a/flower/include/std-string.hh
+++ b/flower/include/std-string.hh
@@ -33,25 +33,24 @@
 
 #include <string>
 
-using namespace std;
 
 typedef size_t ssize;
 #define NPOS std::string::npos
 
-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, ...)
+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, ...)
 __attribute__ ((format (printf, 1, 2)));
 
-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);
+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);
 
 #endif /* STD_STRING_HH */
diff --git a/flower/include/std-vector.hh b/flower/include/std-vector.hh
index fae955854b..7b50f27b4b 100644
--- a/flower/include/std-vector.hh
+++ b/flower/include/std-vector.hh
@@ -36,7 +36,6 @@
 #include <cassert>
 #include <string>
 
-using namespace std;
 
 template<typename T>
 int default_compare (T const &a, T const &b)
@@ -86,19 +85,19 @@ public:
   typedef typename __flower_vector<T>::iterator iterator;
   typedef typename __flower_vector<T>::const_iterator const_iterator;
 
-  vector<T, A> () : __flower_vector<T, A> ()
+  std::vector<T, A> () : __flower_vector<T, A> ()
   {
   }
 
-  vector<T, A> (size_t n) : __flower_vector<T, A> (n)
+  std::vector<T, A> (size_t n) : __flower_vector<T, A> (n)
   {
   }
 
-  vector<T, A> (vector<T, A> const &v) : __flower_vector<T, A> (v)
+  std::vector<T, A> (std::vector<T, A> const &v) : __flower_vector<T, A> (v)
   {
   }
 
-  vector<T, A> (const_iterator b, const_iterator e) : __flower_vector<T, A> (b, e)
+  std::vector<T, A> (const_iterator b, const_iterator e) : __flower_vector<T, A> (b, e)
   {
   }
 
@@ -121,7 +120,7 @@ public:
 
 template<typename T>
 T const &
-boundary (vector<T> const &v, int dir, vsize i)
+boundary (std::vector<T> const &v, int dir, vsize i)
 {
   assert (dir);
   return v[dir == -1 ? i : v.size () - 1 - i];
@@ -129,7 +128,7 @@ boundary (vector<T> const &v, int dir, vsize i)
 
 template<typename T>
 T &
-boundary (vector<T> &v, int dir, vsize i)
+boundary (std::vector<T> &v, int dir, vsize i)
 {
   assert (dir);
   return v[dir == -1 ? i : v.size () - 1 - i];
@@ -137,35 +136,35 @@ boundary (vector<T> &v, int dir, vsize i)
 
 template<typename T>
 T const &
-back (vector<T> const &v, vsize i)
+back (std::vector<T> const &v, vsize i)
 {
   return v[v.size () - i - 1];
 }
 
 template<typename T>
 T &
-back (vector<T> &v, vsize i)
+back (std::vector<T> &v, vsize i)
 {
   return v[v.size () - i - 1];
 }
 
 template<typename T>
 void
-concat (vector<T> &v, vector<T> const &w)
+concat (std::vector<T> &v, std::vector<T> const &w)
 {
   v.insert (v.end (), w.begin (), w.end ());
 }
 
 template<typename T, typename Compare>
 vsize
-lower_bound (vector<T> const &v,
+lower_bound (std::vector<T> const &v,
              T const &key,
              Compare less,
              vsize b = 0, vsize e = VPOS)
 {
   if (e == VPOS)
     e = v.size ();
-  typename vector<T>::const_iterator i = lower_bound (v.begin () + b,
+  typename std::vector<T>::const_iterator i = lower_bound (v.begin () + b,
                                                       v.begin () + e,
                                                       key,
                                                       less);
@@ -175,7 +174,7 @@ lower_bound (vector<T> const &v,
 
 template<typename T, typename Compare>
 vsize
-upper_bound (vector<T> const &v,
+upper_bound (std::vector<T> const &v,
              T const &key,
              Compare less,
              vsize b = 0, vsize e = VPOS)
@@ -183,7 +182,7 @@ upper_bound (vector<T> const &v,
   if (e == VPOS)
     e = v.size ();
 
-  typename vector<T>::const_iterator i = upper_bound (v.begin () + b,
+  typename std::vector<T>::const_iterator i = upper_bound (v.begin () + b,
                                                       v.begin () + e,
                                                       key,
                                                       less);
@@ -193,7 +192,7 @@ upper_bound (vector<T> const &v,
 
 template<typename T, typename Compare>
 vsize
-binary_search (vector<T> const &v,
+binary_search (std::vector<T> const &v,
                T const &key,
                Compare less,
                vsize b = 0, vsize e = VPOS)
@@ -207,7 +206,7 @@ binary_search (vector<T> const &v,
 
 template<typename T, typename Compare>
 void
-vector_sort (vector<T> &v,
+vector_sort (std::vector<T> &v,
              Compare less,
              vsize b = 0, vsize e = VPOS)
 {
@@ -219,28 +218,28 @@ vector_sort (vector<T> &v,
 
 template<typename T>
 void
-reverse (vector<T> &v)
+reverse (std::vector<T> &v)
 {
-  // CHECKME: for a simple vector, like vector<int>, this should
+  // CHECKME: for a simple vector, like std::vector<int>, this should
   // expand to memrev.
   reverse (v.begin (), v.end ());
 }
 
 template<typename T>
 void
-uniq (vector<T> &v)
+uniq (std::vector<T> &v)
 {
   v.erase (unique (v.begin (), v.end ()), v.end ());
 }
 
 template<typename T>
-typename vector<T>::const_iterator
-find (vector<T> const &v, T const &key)
+typename std::vector<T>::const_iterator
+find (std::vector<T> const &v, T const &key)
 {
   return find (v.begin (), v.end (), key);
 }
 
-template<typename T> struct del : public unary_function<T, void>
+template<typename T> struct del : public std::unary_function<T, void>
 {
   void operator () (T x)
   {
@@ -251,15 +250,15 @@ template<typename T> struct del : public unary_function<T, void>
 
 template<typename T>
 void
-junk_pointers (vector<T> &v)
+junk_pointers (std::vector<T> &v)
 {
   // Hmm.
   for_each (v.begin (), v.end (), del<T> ());
   v.clear ();
 }
 
-vector<string> string_split (string str, char c);
-string string_join (vector<string> const &strs, const string &infix);
+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);
 
 #define iterof(i,s) typeof((s).begin()) i((s).begin())
 
diff --git a/flower/include/string-convert.hh b/flower/include/string-convert.hh
index 8e1695bd5c..f8984de0cc 100644
--- a/flower/include/string-convert.hh
+++ b/flower/include/string-convert.hh
@@ -1,52 +1,51 @@
 /*
   PROJECT: FlowerSoft C++ library
-  FILE   : string-convert.hh
+  FILE   : std::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 string
+/** The functor string_convert handles all conversions to/from std::string
     (some time, anyway).  The class is quite empty from data view.  */
 class String_convert
 {
-  static int hex2bin (string hex_string, string &bin_string_r);
+  static int hex2bin (std::string hex_string, std::string &bin_string_r);
   static int hex2nibble (Byte byte);
   static Byte nibble2hex_byte (Byte byte);
 public:
-  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);
+  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);
 };
 
 #endif // __STRING_CONVERT_HH //
diff --git a/flower/include/virtual-methods.hh b/flower/include/virtual-methods.hh
index dc91d7b669..5a907b2cf7 100644
--- a/flower/include/virtual-methods.hh
+++ b/flower/include/virtual-methods.hh
@@ -21,7 +21,6 @@
 #define VIRTUAL_METHODS_HH
 
 #include <typeinfo>
-using namespace std;
 
 /*
 Virtual copy constructor.  Make up for C++'s lack of a standard
diff --git a/flower/include/warn.hh b/flower/include/warn.hh
index f52d3818cc..dcc6f0ee24 100644
--- a/flower/include/warn.hh
+++ b/flower/include/warn.hh
@@ -44,25 +44,25 @@ extern int loglevel;
 extern bool warning_as_error;
 
 /* output messages, in decreasing order of importance */
-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 = "");
+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 = "");
 /* progress_indication does by default *NOT* start on a new line */
-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 = "");
+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 = "");
 
 /* Helper functions that always print out the message. Callers should ensure
    that the loglevel is obeyed */
-void print_message (int level, const string &location, string s, bool newline = true);
+void print_message (int level, const std::string &location, std::string s, bool newline = true);
 
 bool is_loglevel (int level);
 void set_loglevel (int level);
-void set_loglevel (string level);
+void set_loglevel (std::string level);
 
-void expect_warning (const string &msg);
+void expect_warning (const std::string &msg);
 void check_expected_warnings ();
 
 #endif /* WARN_HH */
diff --git a/flower/interval-set.cc b/flower/interval-set.cc
index acc282bbdb..fca942b966 100644
--- a/flower/interval-set.cc
+++ b/flower/interval-set.cc
@@ -58,7 +58,7 @@ Interval_set::interval_union (vector<Interval> ivs)
 
       if (last[RIGHT] >= iv[LEFT])
         // overlapping intervals: merge them
-        last[RIGHT] = max (last[RIGHT], iv[RIGHT]);
+        last[RIGHT] = std::max (last[RIGHT], iv[RIGHT]);
       else if (!iv.is_empty ())
         ret.intervals_.push_back (iv);
     }
diff --git a/flower/libc-extension.cc b/flower/libc-extension.cc
index 1b8060cde2..2e4b58407f 100644
--- a/flower/libc-extension.cc
+++ b/flower/libc-extension.cc
@@ -24,7 +24,6 @@
 #include <cctype>
 #include <cassert>
 
-using namespace std;
 
 #include "libc-extension.hh"
 
diff --git a/flower/memory-stream.cc b/flower/memory-stream.cc
index 511657f5fc..cc4608c383 100644
--- a/flower/memory-stream.cc
+++ b/flower/memory-stream.cc
@@ -20,7 +20,6 @@
 #include <cassert>
 #include <cstring>
 #include <cstdlib>
-using namespace std;
 
 #include "memory-stream.hh"
 
diff --git a/flower/polynomial.cc b/flower/polynomial.cc
index a3f679cd60..ad218b29bb 100644
--- a/flower/polynomial.cc
+++ b/flower/polynomial.cc
@@ -23,7 +23,6 @@
 
 #include <cmath>
 
-using namespace std;
 using std::vector;
 
 /*
@@ -83,7 +82,7 @@ Polynomial::minmax (Real l, Real r, bool ret_max) const
   for (vsize i = 0; i < maxmins.size (); i++)
     if (maxmins[i] >= l && maxmins[i] <= r)
       sols.push_back (eval (maxmins[i]));
-  vector_sort (sols, less<Real> ());
+  vector_sort (sols, std::less<Real> ());
 
   return ret_max ? sols.back () : sols[0];
 }
diff --git a/flower/rational.cc b/flower/rational.cc
index e93f65112e..4214237f35 100644
--- a/flower/rational.cc
+++ b/flower/rational.cc
@@ -22,7 +22,6 @@
 #include <cmath>
 #include <cassert>
 #include <cstdlib>
-using namespace std;
 
 #include "string-convert.hh"
 #include "libc-extension.hh"
diff --git a/flower/real.cc b/flower/real.cc
index 20d8069669..e81577c05f 100644
--- a/flower/real.cc
+++ b/flower/real.cc
@@ -1,7 +1,6 @@
 #include "real.hh"
 
 #include <cmath>
-using namespace std;
 
 #ifdef INFINITY
 const Real infinity_f = INFINITY;
diff --git a/flower/std-string.cc b/flower/std-string.cc
index b03d3cca59..5dc5a3dce8 100644
--- a/flower/std-string.cc
+++ b/flower/std-string.cc
@@ -33,7 +33,7 @@ to_string (const string &s)
 string
 to_string (char c, int n)
 {
-  return string (max (n, 0), c);
+  return string (std::max (n, 0), c);
 }
 
 string
diff --git a/flower/string-convert.cc b/flower/string-convert.cc
index 13788a4a84..cbbde1e9d6 100644
--- a/flower/string-convert.cc
+++ b/flower/string-convert.cc
@@ -8,7 +8,6 @@
 
 #include <cstring>
 #include <cstdio>
-using namespace std;
 
 #include "libc-extension.hh"
 #include "rational.hh"
@@ -299,7 +298,7 @@ String_convert::pointer_string (void const *l)
 string
 String_convert::precision_string (double x, int n)
 {
-  string format = "%." + ::to_string (max (0, n - 1)) + "e";
+  string format = "%." + ::to_string (std::max (0, n - 1)) + "e";
   string str = double_string (abs (x), format.c_str ());
 
   int exp = dec2int (str.substr (str.length () - 3));
@@ -354,7 +353,7 @@ String_convert::unsigned_long_string (unsigned long ul)
 string
 String_convert::pad_to (const string &s, size_t n)
 {
-  return s + string (max (int (n - s.length ()), 0), ' ');
+  return s + string (std::max (int (n - s.length ()), 0), ' ');
 }
 
 string
diff --git a/flower/test-file-name.cc b/flower/test-file-name.cc
index 04ee34b51f..04aa6afdb5 100644
--- a/flower/test-file-name.cc
+++ b/flower/test-file-name.cc
@@ -2,7 +2,6 @@
 
 #include "yaffut-parameters.hh"
 
-using namespace std;
 using std::string;
 
 string slashify (string file_name);
diff --git a/flower/test-file-path.cc b/flower/test-file-path.cc
index e55309a3f7..fa23bddedd 100644
--- a/flower/test-file-path.cc
+++ b/flower/test-file-path.cc
@@ -15,7 +15,7 @@ TEST (File_path, Find)
   char cwd[PATH_MAX];
   if (!getcwd (cwd, PATH_MAX))
     {
-      cerr << "Could not get current work directory\n";
+      std::cerr << "Could not get current work directory\n";
       exit (1);
     }
   string ly_dir = string (getenv ("top-src-dir")) + "/ly";
diff --git a/flower/test-interval-set.cc b/flower/test-interval-set.cc
index 6d8d3823d3..d78bbdfdf6 100644
--- a/flower/test-interval-set.cc
+++ b/flower/test-interval-set.cc
@@ -21,7 +21,6 @@
 
 #include "yaffut.hh"
 
-using namespace std;
 using std::vector;
 
 FUNC (interval_set_union)
diff --git a/flower/test-std.cc b/flower/test-std.cc
index 711e9237b6..667afc124a 100644
--- a/flower/test-std.cc
+++ b/flower/test-std.cc
@@ -6,7 +6,6 @@
 #define YAFFUT_MAIN
 #include "yaffut.hh"
 
-using namespace std;
 using std::vector;
 
 template<typename T>
@@ -14,8 +13,8 @@ void
 print (vector<T> v)
 {
   for (vsize i = 0; i < v.size (); i++)
-    cout << "v[" << i << "] = " << v[i] << endl;
-  cout << endl;
+    std::cout << "v[" << i << "] = " << v[i] << std::endl;
+  std::cout << std::endl;
 }
 
 FUNC (vector_erase)
@@ -64,7 +63,7 @@ FUNC (vector_sorting)
   v.sort (default_compare);
 #else
   //sort (v.begin (), v.end ());
-  vector_sort (v, less<int> ());
+  vector_sort (v, std::less<int> ());
 #endif
   EQUAL (v[0], 0);
   EQUAL (v[1], 1);
@@ -137,7 +136,7 @@ FUNC (parray_uniq)
   v.push_back (0);
   v.push_back (1);
   v.push_back (0);
-  vector_sort (v, less<int> ());
+  vector_sort (v, std::less<int> ());
   uniq (v);
   EQUAL (v.size (), vsize (2));
 }
@@ -148,6 +147,6 @@ FUNC (vector_search)
   v.push_back (0);
   v.push_back (1);
   v.push_back (2);
-  vsize i = binary_search (v, 1, less<int> ());
+  vsize i = binary_search (v, 1, std::less<int> ());
   EQUAL (i, vsize (1));
 }
diff --git a/flower/test-string.cc b/flower/test-string.cc
index f5524bba74..1ab747d9bb 100644
--- a/flower/test-string.cc
+++ b/flower/test-string.cc
@@ -5,7 +5,6 @@
 
 #include "yaffut.hh"
 
-using namespace std;
 using std::string;
 using std::vector;
 
diff --git a/flower/warn.cc b/flower/warn.cc
index 422dea8027..39723ae8a3 100644
--- a/flower/warn.cc
+++ b/flower/warn.cc
@@ -25,7 +25,6 @@
 #include "std-vector.hh"
 #include "international.hh"
 
-using namespace std;
 using std::string;
 using std::vector;
 
diff --git a/lily/align-interface.cc b/lily/align-interface.cc
index fed8f39746..d5f2140d62 100644
--- a/lily/align-interface.cc
+++ b/lily/align-interface.cc
@@ -234,11 +234,11 @@ Align_interface::internal_get_minimum_translations (Grob *me,
 
           Real spec_distance = 0;
           if (Page_layout_problem::read_spacing_spec (spec, &spec_distance, ly_symbol2scm ("minimum-distance")))
-            dy = max (dy, spec_distance);
+            dy = std::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 = max (dy, spec_distance);
+            dy = std::max (dy, spec_distance);
 
           if (include_fixed_spacing && Page_layout_problem::is_spaceable (elems[j]) && last_spaceable_element)
             {
@@ -250,21 +250,21 @@ Align_interface::internal_get_minimum_translations (Grob *me,
               Page_layout_problem::read_spacing_spec (spec,
                                                       &spaceable_padding,
                                                       ly_symbol2scm ("padding"));
-              dy = max (dy, (last_spaceable_skyline.distance (skyline[-stacking_dir])
+              dy = std::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 = max (dy, spaceable_min_distance + stacking_dir * (last_spaceable_element_pos - where));
+                dy = std::max (dy, spaceable_min_distance + stacking_dir * (last_spaceable_element_pos - where));
 
-              dy = max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
+              dy = std::max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
                                                                     pure, start, end));
             }
         }
 
-      dy = max (0.0, dy);
+      dy = std::max (0.0, dy);
       down_skyline.raise (-stacking_dir * dy);
       down_skyline.merge (skyline[stacking_dir]);
       where += stacking_dir * dy;
diff --git a/lily/audio-item.cc b/lily/audio-item.cc
index 5f1814f98e..0639508b6f 100644
--- a/lily/audio-item.cc
+++ b/lily/audio-item.cc
@@ -169,7 +169,7 @@ Audio_span_dynamic::render ()
       // 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_ = max (min (start_v + grow_dir_ * (max_volume_ - min_volume_) * 0.25, max_volume_), min_volume_);
+      dynamics_.back ()->volume_ = std::max (std::min (start_v + grow_dir_ * (max_volume_ - min_volume_) * 0.25, max_volume_), min_volume_);
     }
 
   Real delta_v = dynamics_.back ()->volume_ - dynamics_[0]->volume_;
diff --git a/lily/auto-beam-engraver.cc b/lily/auto-beam-engraver.cc
index c1be5d985f..6f3a4c0179 100644
--- a/lily/auto-beam-engraver.cc
+++ b/lily/auto-beam-engraver.cc
@@ -442,7 +442,7 @@ Auto_beam_engraver::acknowledge_stem (Grob_info info)
                        (to_boolean (stem->get_property ("tuplet-start"))));
   stems_->push_back (stem);
   last_add_mom_ = now;
-  extend_mom_ = max (extend_mom_, now) + get_event_length (ev, now);
+  extend_mom_ = std::max (extend_mom_, now) + get_event_length (ev, now);
   if (recheck_needed)
     recheck_beam ();
 }
diff --git a/lily/axis-group-interface.cc b/lily/axis-group-interface.cc
index 717ae1945f..8f6b91c2b4 100644
--- a/lily/axis-group-interface.cc
+++ b/lily/axis-group-interface.cc
@@ -273,7 +273,7 @@ Axis_group_interface::adjacent_pure_heights (SCM smob)
       d = (d == CENTER) ? UP : d;
 
       Interval_t<int> rank_span = g->spanned_rank_interval ();
-      vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], less<vsize> ());
+      vsize first_break = lower_bound (ranks, (vsize)rank_span[LEFT], std::less<vsize> ());
       if (first_break > 0 && ranks[first_break] >= (vsize)rank_span[LEFT])
         first_break--;
 
@@ -327,7 +327,7 @@ Interval
 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) = max (height (i, j) height (j, k)) for all i <= j <= k).
+     (ie. height (i, k) = std::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.
 
@@ -689,8 +689,8 @@ avoid_outside_staff_collisions (Grob *elt,
   for (vsize j = 0; j < other_v_skylines.size (); j++)
     {
       Skyline_pair const &v_other = other_v_skylines[j];
-      Real pad = max (padding, other_padding[j]);
-      Real horizon_pad = max (horizon_padding, other_horizon_padding[j]);
+      Real pad = std::max (padding, other_padding[j]);
+      Real horizon_pad = std::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;
@@ -841,7 +841,7 @@ add_grobs_of_one_priority (Grob *me,
           (*all_paddings)[dir].push_back (padding);
           (*all_horizon_paddings)[dir].push_back (horizon_padding);
         }
-      swap (elements, skipped_elements);
+      std::swap (elements, skipped_elements);
       skipped_elements.clear ();
     }
 }
diff --git a/lily/beam-engraver.cc b/lily/beam-engraver.cc
index e6ca4caf16..753a056449 100644
--- a/lily/beam-engraver.cc
+++ b/lily/beam-engraver.cc
@@ -305,7 +305,7 @@ Beam_engraver::acknowledge_stem (Grob_info info)
   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,
-                        max (durlog - 2, 0),
+                        std::max (durlog - 2, 0),
                         Stem::is_invisible (stem),
                         stem_duration->factor (),
                         (to_boolean (stem->get_property ("tuplet-start"))));
diff --git a/lily/beam-quanting.cc b/lily/beam-quanting.cc
index 740f286908..8cf8a345a3 100644
--- a/lily/beam-quanting.cc
+++ b/lily/beam-quanting.cc
@@ -23,7 +23,6 @@
 #include <algorithm>
 #include <queue>
 #include <set>
-using namespace std;
 
 #include "align-interface.hh"
 #include "beam.hh"
@@ -449,8 +448,8 @@ set_minimum_dy (Grob *me, Real *dy)
       Real inter = 0.5;
       Real hang = 1.0 - (beam_thickness - slt) / 2;
 
-      *dy = sign (*dy) * max (fabs (*dy),
-                              min (min (sit, inter), hang));
+      *dy = sign (*dy) * std::max (fabs (*dy),
+                              std::min (std::min (sit, inter), hang));
     }
 }
 
@@ -614,7 +613,7 @@ is_concave_single_notes (vector<int> const &positions, Direction beam_dir)
     note is reached in the opposite direction as the last-first dy
   */
   int dy = positions.back () - positions[0];
-  int closest = max (beam_dir * positions.back (), beam_dir * positions[0]);
+  int closest = std::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];
@@ -645,7 +644,7 @@ calc_positions_concaveness (vector<int> const &positions, Direction beam_dir)
     {
       Real line_y = slope * i + positions[0];
 
-      concaveness += max (beam_dir * (positions[i] - line_y), 0.0);
+      concaveness += std::max (beam_dir * (positions[i] - line_y), 0.0);
     }
 
   concaveness /= positions.size ();
@@ -1081,7 +1080,7 @@ Beam_scoring_problem::score_stem_lengths (Beam_configuration *config) const
       Stem_info info = stem_infos_[i];
       Direction d = info.dir_;
 
-      score[d] += limit_penalty * max (0.0, (d * (info.shortest_y_ - current_y)));
+      score[d] += limit_penalty * std::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);
@@ -1098,7 +1097,7 @@ Beam_scoring_problem::score_stem_lengths (Beam_configuration *config) const
 
   /* Divide by number of stems, to make the measure scale-free. */
   for (DOWN_and_UP (d))
-    score[d] /= max (count[d], 1);
+    score[d] /= std::max (count[d], 1);
 
   /*
     sometimes, two perfectly symmetric kneed beams will have the same score
@@ -1148,7 +1147,7 @@ Beam_scoring_problem::score_slope_musical (Beam_configuration *config) const
 {
   Real dy = config->y.delta ();
   Real dem = parameters_.MUSICAL_DIRECTION_FACTOR
-             * max (0.0, (fabs (dy) - fabs (musical_dy_)));
+             * std::max (0.0, (fabs (dy) - fabs (musical_dy_)));
   config->add (dem, "Sm");
 }
 
@@ -1207,7 +1206,7 @@ Beam_scoring_problem::score_forbidden_quants (Beam_configuration *config) const
 
   Real extra_demerit =
     parameters_.SECONDARY_BEAM_DEMERIT
-    / max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]);
+    / std::max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]);
   
   Real dem = 0.0;
   Real eps = parameters_.BEAM_EPS;
@@ -1237,7 +1236,7 @@ Beam_scoring_problem::score_forbidden_quants (Beam_configuration *config) const
                k <= staff_radius_ + eps; k += 1.0)
             if (gap.contains (k))
               {
-                Real dist = min (fabs (gap[UP] - k), fabs (gap[DOWN] - k));
+                Real dist = std::min (fabs (gap[UP] - k), fabs (gap[DOWN] - k));
 
                 /*
                   this parameter is tuned to grace-stem-length.ly
@@ -1260,7 +1259,7 @@ Beam_scoring_problem::score_forbidden_quants (Beam_configuration *config) const
 
   config->add (dem, "Fl");
   dem = 0.0;
-  if (max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]) >= 2)
+  if (std::max (edge_beam_counts_[LEFT], edge_beam_counts_[RIGHT]) >= 2)
     {
       Real straddle = 0.0;
       Real sit = (beam_thickness_ - line_thickness_) / 2;
@@ -1316,12 +1315,12 @@ Beam_scoring_problem::score_collisions (Beam_configuration *config) const
       if (!intersection (beam_y, collision_y).is_empty ())
         dist = 0.0;
       else 
-        dist = min (beam_y.distance (collision_y[DOWN]),
+        dist = std::min (beam_y.distance (collision_y[DOWN]),
                     beam_y.distance (collision_y[UP]));
 
       
       Real scale_free
-        = max (parameters_.COLLISION_PADDING - dist, 0.0)
+        = std::max (parameters_.COLLISION_PADDING - dist, 0.0)
           / parameters_.COLLISION_PADDING;
       Real collision_demerit = collisions_[i].base_penalty_ *
          pow (scale_free, 3) * parameters_.COLLISION_PENALTY;
diff --git a/lily/beam.cc b/lily/beam.cc
index 6bdaab9d9f..d1032184a9 100644
--- a/lily/beam.cc
+++ b/lily/beam.cc
@@ -142,7 +142,7 @@ Beam::get_beam_count (Grob *me)
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *stem = stems[i];
-      m = max (m, (Stem::beam_multiplicity (stem).length () + 1));
+      m = std::max (m, (Stem::beam_multiplicity (stem).length () + 1));
     }
   return m;
 }
@@ -441,7 +441,7 @@ Beam::calc_beam_segments (SCM smob)
        i != stem_segments.end (); i++)
     {
       vector<Beam_stem_segment> segs = (*i).second;
-      vector_sort (segs, less<Beam_stem_segment> ());
+      vector_sort (segs, std::less<Beam_stem_segment> ());
 
       Beam_segment current;
 
@@ -515,7 +515,7 @@ Beam::calc_beam_segments (SCM smob)
                           Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
                           Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
 
-                          length = min (length,
+                          length = std::min (length,
                                         fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
                         }
                       current.horizontal_[event_dir] += event_dir * length;
@@ -540,7 +540,7 @@ Beam::calc_beam_segments (SCM smob)
 
                           for (vsize k = 0; k < heads.size (); k++)
                             current.horizontal_[event_dir]
-                              = event_dir * min (event_dir * current.horizontal_[event_dir],
+                              = event_dir * std::min (event_dir * current.horizontal_[event_dir],
                                                  - gap_length / 2
                                                  + event_dir
                                                  * heads[k]->extent (commonx,
@@ -773,7 +773,7 @@ Beam::get_default_dir (Grob *me)
       for (DOWN_and_UP (d))
         {
           if (sign (positions[d]) == d)
-            extremes[d] = d * max (d * positions[d], d * extremes[d]);
+            extremes[d] = d * std::max (d * positions[d], d * extremes[d]);
         }
     }
 
@@ -800,7 +800,7 @@ Beam::get_default_dir (Grob *me)
       if (stem_dir)
         {
           count[stem_dir]++;
-          total[stem_dir] += max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
+          total[stem_dir] += std::max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
         }
     }
 
@@ -1153,7 +1153,7 @@ Beam::set_beaming (Grob *me, Beaming_pattern const *beaming)
               if (i > 0
                   && i + 1 < stems.size ()
                   && Stem::is_invisible (stem))
-                count = min (count, beaming->beamlet_count (i, -d));
+                count = std::min (count, beaming->beamlet_count (i, -d));
 
               if ( ((i == 0 && d == LEFT)
                     || (i == stems.size () - 1 && d == RIGHT))
@@ -1288,7 +1288,7 @@ Beam::rest_collision_callback (SCM smob, SCM prev_offset)
     = staff_space * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
                      + robust_scm2double (rest->get_property ("minimum-distance"), 0.0));
 
-  Real shift = d * min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
+  Real shift = d * std::min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
 
   shift /= staff_space;
 
@@ -1367,7 +1367,7 @@ Beam::pure_rest_collision_callback (SCM smob,
                    + 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 = max (-2.0, beam_pos * beamdir) * beamdir;
+  beam_pos = std::max (-2.0, beam_pos * beamdir) * beamdir;
 
   Real minimum_distance
     = ss * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
@@ -1377,7 +1377,7 @@ Beam::pure_rest_collision_callback (SCM smob,
                 - me->extent (me, Y_AXIS)[beamdir];
 
   /* Always move by a whole number of staff spaces, always away from the beam */
-  offset = floor (min (0.0, (offset - previous) / ss * beamdir))
+  offset = floor (std::min (0.0, (offset - previous) / ss * beamdir))
            * ss * beamdir + previous;
 
   return scm_from_double (offset);
@@ -1439,7 +1439,7 @@ Beam::get_direction_beam_count (Grob *me, Direction d)
         Should we take invisible stems into account?
       */
       if (get_grob_direction (stems[i]) == d)
-        bc = max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
+        bc = std::max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
     }
 
   return bc;
diff --git a/lily/beaming-pattern.cc b/lily/beaming-pattern.cc
index 5510965c31..53a8c354ea 100644
--- a/lily/beaming-pattern.cc
+++ b/lily/beaming-pattern.cc
@@ -173,7 +173,7 @@ Beaming_pattern::beamify (Beaming_options const &options)
             int importance = infos_[i + 1].rhythmic_importance_;
             int count = (importance < 0 && options.subdivide_beams_) 
                         ? subdivide_beam_count
-                        : min (min (infos_[i].count (non_flag_dir),
+                        : std::min (std::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));
 
@@ -317,7 +317,7 @@ Beaming_pattern::unbeam_invisible_stems ()
   for (vsize i = 1; i < infos_.size (); i++)
     if (infos_[i].invisible_)
       {
-        int b = min (infos_[i].count (LEFT), infos_[i - 1].count (LEFT));
+        int b = std::min (infos_[i].count (LEFT), infos_[i - 1].count (LEFT));
         infos_[i].beam_count_drul_[LEFT] = b;
         infos_[i].beam_count_drul_[RIGHT] = b;
       }
@@ -326,7 +326,7 @@ Beaming_pattern::unbeam_invisible_stems ()
     for (vsize i = infos_.size () - 1; i--;)
       if (infos_[i].invisible_)
         {
-          int b = min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT));
+          int b = std::min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT));
           infos_[i].beam_count_drul_[LEFT] = b;
           infos_[i].beam_count_drul_[RIGHT] = b;
         }
@@ -357,7 +357,7 @@ Beaming_pattern::start_moment (int i) const
 Moment
 Beaming_pattern::end_moment (int i) const
 {
-  Duration dur (2 + max (beamlet_count (i, LEFT),
+  Duration dur (2 + std::max (beamlet_count (i, LEFT),
                          beamlet_count (i, RIGHT)),
                 0);
 
@@ -396,7 +396,7 @@ Beaming_pattern::split_pattern (int i)
   new_pattern = new Beaming_pattern ();
   for (vsize j = i + 1; j < infos_.size (); j++)
     {
-      count = max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT));
+      count = std::max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT));
       new_pattern->add_stem (start_moment (j),
                              count,
                              invisibility (j),
diff --git a/lily/book.cc b/lily/book.cc
index c7f5dd0237..b591641554 100644
--- a/lily/book.cc
+++ b/lily/book.cc
@@ -20,7 +20,6 @@
 #include "book.hh"
 
 #include <cstdio>
-using namespace std;
 
 #include "main.hh"
 #include "music.hh"
diff --git a/lily/break-alignment-interface.cc b/lily/break-alignment-interface.cc
index 4b1e06d98c..305f764ad3 100644
--- a/lily/break-alignment-interface.cc
+++ b/lily/break-alignment-interface.cc
@@ -218,7 +218,7 @@ Break_alignment_interface::calc_positioning_done (SCM smob)
                                 - extents[next_idx][LEFT];
           /* should probably junk minimum-space */
           else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
-            offsets[next_idx] = max (extents[idx][RIGHT], distance);
+            offsets[next_idx] = std::max (extents[idx][RIGHT], distance);
         }
       else
         {
diff --git a/lily/break-substitution.cc b/lily/break-substitution.cc
index 7d68f0d9bf..f6db741483 100644
--- a/lily/break-substitution.cc
+++ b/lily/break-substitution.cc
@@ -19,7 +19,6 @@
 
 #include <cstdio>
 #include <cstdlib>
-using namespace std;
 
 #include "item.hh"
 #include "system.hh"
diff --git a/lily/chord-tremolo-engraver.cc b/lily/chord-tremolo-engraver.cc
index 9de2bbffc8..95fdaeef9d 100644
--- a/lily/chord-tremolo-engraver.cc
+++ b/lily/chord-tremolo-engraver.cc
@@ -120,9 +120,9 @@ Chord_tremolo_engraver::acknowledge_stem (Grob_info info)
   if (beam_)
     {
       int tremolo_type = robust_scm2int (repeat_->get_property ("tremolo-type"), 1);
-      int flags = max (0, intlog2 (tremolo_type) - 2);
+      int flags = std::max (0, intlog2 (tremolo_type) - 2);
       int repeat_count = robust_scm2int (repeat_->get_property ("repeat-count"), 1);
-      int gap_count = min (flags, intlog2 (repeat_count) + 1);
+      int gap_count = std::min (flags, intlog2 (repeat_count) + 1);
 
       Grob *s = info.grob ();
       if (previous_stem_)
diff --git a/lily/clef-engraver.cc b/lily/clef-engraver.cc
index 940a18d201..dc239ca1e2 100644
--- a/lily/clef-engraver.cc
+++ b/lily/clef-engraver.cc
@@ -19,7 +19,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "item.hh"
 #include "context.hh"
diff --git a/lily/cluster-engraver.cc b/lily/cluster-engraver.cc
index c934fd0ba3..2e06e1de4b 100644
--- a/lily/cluster-engraver.cc
+++ b/lily/cluster-engraver.cc
@@ -107,8 +107,8 @@ Cluster_spanner_engraver::process_music ()
 
           int p = (pit ? pit->steps () : 0) + c0;
 
-          pmax = max (pmax, p);
-          pmin = min (pmin, p);
+          pmax = std::max (pmax, p);
+          pmin = std::min (pmin, p);
         }
 
       beacon_ = make_item ("ClusterSpannerBeacon", cluster_notes_[0]->self_scm ());
diff --git a/lily/completion-note-heads-engraver.cc b/lily/completion-note-heads-engraver.cc
index f5abe73e43..27d950b690 100644
--- a/lily/completion-note-heads-engraver.cc
+++ b/lily/completion-note-heads-engraver.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "dot-column.hh"
 #include "dots.hh"
@@ -101,7 +100,7 @@ Completion_heads_engraver::listen_note (Stream_event *ev)
   Moment now = now_mom ();
   Moment musiclen = get_event_length (ev, now);
 
-  note_end_mom_ = max (note_end_mom_, (now + musiclen));
+  note_end_mom_ = std::max (note_end_mom_, (now + musiclen));
   do_nothing_until_ = Rational (0, 0);
 }
 
diff --git a/lily/completion-rest-engraver.cc b/lily/completion-rest-engraver.cc
index b7e76c82bc..a60b400efc 100644
--- a/lily/completion-rest-engraver.cc
+++ b/lily/completion-rest-engraver.cc
@@ -19,7 +19,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "dot-column.hh"
 #include "dots.hh"
@@ -97,7 +96,7 @@ Completion_rest_engraver::listen_rest (Stream_event *ev)
   Moment now = now_mom ();
   Moment musiclen = get_event_length (ev, now);
 
-  rest_end_mom_ = max (rest_end_mom_, (now + musiclen));
+  rest_end_mom_ = std::max (rest_end_mom_, (now + musiclen));
   do_nothing_until_ = Rational (0, 0);
 }
 
diff --git a/lily/constrained-breaking.cc b/lily/constrained-breaking.cc
index 463e84bf11..d9054087e1 100644
--- a/lily/constrained-breaking.cc
+++ b/lily/constrained-breaking.cc
@@ -621,7 +621,7 @@ Line_details::spring_length (Line_details const &next_line) const
   // 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 max (0.0, space - refpoint_dist);
+  return std::max (0.0, space - refpoint_dist);
 }
 
 Line_shape::Line_shape (Interval begin, Interval rest)
@@ -633,7 +633,7 @@ Line_shape::Line_shape (Interval begin, Interval rest)
 Line_shape
 Line_shape::piggyback (Line_shape mount, Real padding) const
 {
-  Real elevation = max (begin_[UP] - mount.begin_[DOWN], rest_[UP] - mount.rest_[DOWN]);
+  Real elevation = std::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);
diff --git a/lily/cue-clef-engraver.cc b/lily/cue-clef-engraver.cc
index 383c9a1b1f..9e0372de18 100644
--- a/lily/cue-clef-engraver.cc
+++ b/lily/cue-clef-engraver.cc
@@ -20,7 +20,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "item.hh"
 #include "context.hh"
diff --git a/lily/custos.cc b/lily/custos.cc
index 3ba5db834e..b2289f267d 100644
--- a/lily/custos.cc
+++ b/lily/custos.cc
@@ -26,7 +26,6 @@
 
 #include <cstdio>
 #include <cmath> // rint
-using namespace std;
 
 #include "custos.hh"
 #include "direction.hh"
diff --git a/lily/dot-column.cc b/lily/dot-column.cc
index 84ace8228f..56ef578847 100644
--- a/lily/dot-column.cc
+++ b/lily/dot-column.cc
@@ -22,7 +22,6 @@
 #include <map>
 #include <set>
 
-using namespace std;
 
 #include "axis-group-interface.hh"
 #include "directional-element-interface.hh"
diff --git a/lily/dot-configuration.cc b/lily/dot-configuration.cc
index 25d35eb691..20c44297a0 100644
--- a/lily/dot-configuration.cc
+++ b/lily/dot-configuration.cc
@@ -158,7 +158,7 @@ Dot_configuration::x_offset () const
   Real off = 0.0;
   for (Dot_configuration::const_iterator i (begin ());
        i != end (); i++)
-    off = max (off, problem_->head_skyline_.height ((*i).first));
+    off = std::max (off, problem_->head_skyline_.height ((*i).first));
 
   return off;
 }
diff --git a/lily/drum-note-engraver.cc b/lily/drum-note-engraver.cc
index 40e3aaf936..37cf47a217 100644
--- a/lily/drum-note-engraver.cc
+++ b/lily/drum-note-engraver.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "item.hh"
 #include "duration.hh"
diff --git a/lily/figured-bass-engraver.cc b/lily/figured-bass-engraver.cc
index 5463be534d..a0998ef4c9 100644
--- a/lily/figured-bass-engraver.cc
+++ b/lily/figured-bass-engraver.cc
@@ -195,7 +195,7 @@ Figured_bass_engraver::listen_bass_figure (Stream_event *ev)
 {
   new_event_found_ = true;
   Moment stop = now_mom () + get_event_length (ev, now_mom ());
-  stop_moment_ = max (stop_moment_, stop);
+  stop_moment_ = std::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)
diff --git a/lily/file-name-map.cc b/lily/file-name-map.cc
index d9b9711ba1..39a2349395 100644
--- a/lily/file-name-map.cc
+++ b/lily/file-name-map.cc
@@ -18,7 +18,6 @@
 */
 
 #include <map>
-using namespace std;
 
 #include "file-name-map.hh"
 #include "lily-guile.hh"
diff --git a/lily/font-metric.cc b/lily/font-metric.cc
index 73104615a0..200c1eb877 100644
--- a/lily/font-metric.cc
+++ b/lily/font-metric.cc
@@ -21,7 +21,6 @@
 
 #include <cmath>
 #include <cctype>
-using namespace std;
 
 #include "dimensions.hh"
 #include "modified-font-metric.hh"
diff --git a/lily/fretboard-engraver.cc b/lily/fretboard-engraver.cc
index 5ce6763cb7..7f99713d9e 100644
--- a/lily/fretboard-engraver.cc
+++ b/lily/fretboard-engraver.cc
@@ -19,7 +19,6 @@
 
 #include <cctype>
 #include <cstdio>
-using namespace std;
 
 #include "articulations.hh"
 #include "context.hh"
diff --git a/lily/function-documentation.cc b/lily/function-documentation.cc
index e04188c7b5..cda424e9d1 100644
--- a/lily/function-documentation.cc
+++ b/lily/function-documentation.cc
@@ -19,7 +19,6 @@
 
 #include <cstring>
 #include <map>
-using namespace std;
 
 #include "std-string.hh"
 #include "lily-guile.hh"
diff --git a/lily/general-scheme.cc b/lily/general-scheme.cc
index de5a2cc225..d661c177a5 100644
--- a/lily/general-scheme.cc
+++ b/lily/general-scheme.cc
@@ -24,7 +24,6 @@
 #include <ctype.h>
 #include <cstring>  /* memset */
 #include <glib.h>
-using namespace std;
 
 #include "dimensions.hh"
 #include "file-name.hh"
diff --git a/lily/global-context.cc b/lily/global-context.cc
index 72ccc5be89..cffc4512c8 100644
--- a/lily/global-context.cc
+++ b/lily/global-context.cc
@@ -20,7 +20,6 @@
 #include "global-context.hh"
 
 #include <cstdio>
-using namespace std;
 
 #include "context-def.hh"
 #include "dispatcher.hh"
diff --git a/lily/grob-interface.cc b/lily/grob-interface.cc
index 1dfd0f2c9e..ec7108c15c 100644
--- a/lily/grob-interface.cc
+++ b/lily/grob-interface.cc
@@ -34,7 +34,7 @@ SCM add_interface (char const *cxx_name,
 {
   string suffix ("-interface");
   string lispy_name = camel_case_to_lisp_identifier (cxx_name);
-  vsize end = max (int (0), int (lispy_name.length () - suffix.length ()));
+  vsize end = std::max (int (0), int (lispy_name.length () - suffix.length ()));
   if (lispy_name.substr (end) != suffix)
     lispy_name += suffix;
 
diff --git a/lily/grob-pq-engraver.cc b/lily/grob-pq-engraver.cc
index d3cd356a04..a869f031ee 100644
--- a/lily/grob-pq-engraver.cc
+++ b/lily/grob-pq-engraver.cc
@@ -101,7 +101,7 @@ Grob_pq_engraver::acknowledge_grob (Grob_info gi)
 void
 Grob_pq_engraver::process_acknowledged ()
 {
-  vector_sort (started_now_, less<Grob_pq_entry> ());
+  vector_sort (started_now_, std::less<Grob_pq_entry> ());
   SCM lst = SCM_EOL;
   SCM *tail = &lst;
   for (vsize i = 0; i < started_now_.size (); i++)
diff --git a/lily/hairpin.cc b/lily/hairpin.cc
index 01d8fd93de..b14872573e 100644
--- a/lily/hairpin.cc
+++ b/lily/hairpin.cc
@@ -177,7 +177,7 @@ Hairpin::print (SCM smob)
                 {
                   Spanner *span_elt = dynamic_cast<Spanner *> (chp[i]);
                   if (span_elt->get_bound (RIGHT)->break_status_dir () == LEFT)
-                    broken_bound_padding = max (broken_bound_padding,
+                    broken_bound_padding = std::max (broken_bound_padding,
                                                 robust_scm2double (span_elt->get_property ("broken-bound-padding"), 0.0));
                 }
               x_points[d] -= d * broken_bound_padding;
diff --git a/lily/hara-kiri-group-spanner.cc b/lily/hara-kiri-group-spanner.cc
index a4389a5818..ecfb6a9ac5 100644
--- a/lily/hara-kiri-group-spanner.cc
+++ b/lily/hara-kiri-group-spanner.cc
@@ -123,7 +123,7 @@ Hara_kiri_group_spanner::request_suicide_alone (Grob *me, int start, int end)
           for (int j = iv[LEFT]; j <= iv[RIGHT]; j++)
             ranks.push_back (j);
         }
-      vector_sort (ranks, less<int> ());
+      vector_sort (ranks, std::less<int> ());
       uniq (ranks);
 
       SCM scm_vec = scm_c_make_vector (ranks.size (), SCM_EOL);
diff --git a/lily/includable-lexer.cc b/lily/includable-lexer.cc
index 564b6024cd..3e9c54857d 100644
--- a/lily/includable-lexer.cc
+++ b/lily/includable-lexer.cc
@@ -20,7 +20,6 @@
 #include "includable-lexer.hh"
 
 #include <sstream>
-using namespace std;
 
 #include "config.hh"
 
diff --git a/lily/include/accidental-placement.hh b/lily/include/accidental-placement.hh
index 4c362cbd93..a8f3ddeafa 100644
--- a/lily/include/accidental-placement.hh
+++ b/lily/include/accidental-placement.hh
@@ -29,10 +29,10 @@ public:
   DECLARE_SCHEME_CALLBACK (alignment_callback, (SCM element));
   static void add_accidental (Grob *, Grob *, bool, long);
 
-  static vector<Grob *> get_relevant_accidentals (vector<Grob *> const &elts, Grob *left);
+  static std::vector<Grob *> get_relevant_accidentals (std::vector<Grob *> const &elts, Grob *left);
   static void split_accidentals (Grob *accs,
-                                 vector<Grob *> *break_reminder,
-                                 vector<Grob *> *real_acc);
+                                 std::vector<Grob *> *break_reminder,
+                                 std::vector<Grob *> *real_acc);
 
   DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
 };
diff --git a/lily/include/align-interface.hh b/lily/include/align-interface.hh
index 612c31c0d5..4d798ae1eb 100644
--- a/lily/include/align-interface.hh
+++ b/lily/include/align-interface.hh
@@ -31,9 +31,9 @@ public:
   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 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 &,
+  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 &,
                                                      Axis a, int start, int end);
   static void set_ordered (Grob *);
   static Axis axis (Grob *);
@@ -44,7 +44,7 @@ public:
   static Real get_pure_child_y_translation (Grob *, Grob *child, int start, int end);
 
 protected:
-  static vector<Real> internal_get_minimum_translations (Grob *, vector<Grob *> const &,
+  static std::vector<Real> internal_get_minimum_translations (Grob *, std::vector<Grob *> const &,
                                                          Axis a,
                                                          bool include_fixed_spacing,
                                                          bool pure, int start, int end);
diff --git a/lily/include/all-font-metrics.hh b/lily/include/all-font-metrics.hh
index a2d090a6df..53488cc9f7 100644
--- a/lily/include/all-font-metrics.hh
+++ b/lily/include/all-font-metrics.hh
@@ -44,24 +44,24 @@ class All_font_metrics : public Smob<All_font_metrics>
   int pango_dpi_;
 #endif
 
-  map<string, Index_to_charcode_map > filename_charcode_maps_map_;
+  std::map<std::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 string &filename,
+  Index_to_charcode_map const *get_index_to_charcode_map (const std::string &filename,
                                                           int face_index,
                                                           FT_Face face);
 
-  All_font_metrics (const string &search_path);
+  All_font_metrics (const std::string &search_path);
   ~All_font_metrics ();
 
   Pango_font *find_pango_font (PangoFontDescription const *description,
                                Real scale);
 
-  Font_metric *find_font (const string &name);
-  Open_type_font *find_otf (const string &name);
+  Font_metric *find_font (const std::string &name);
+  Open_type_font *find_otf (const std::string &name);
   SCM font_descriptions () const;
 };
 
diff --git a/lily/include/articulations.hh b/lily/include/articulations.hh
index 543bbf51e0..26446d4056 100644
--- a/lily/include/articulations.hh
+++ b/lily/include/articulations.hh
@@ -23,8 +23,8 @@
 #include "lily-guile.hh"
 #include "stream-event.hh"
 
-SCM articulation_list (vector<Stream_event *> notes,
-                       vector<Stream_event *> articulations,
+SCM articulation_list (std::vector<Stream_event *> notes,
+                       std::vector<Stream_event *> articulations,
                        char const *articulation_name);
 
 #endif /* ARTICULATIONS_HH */
diff --git a/lily/include/audio-column.hh b/lily/include/audio-column.hh
index 059321f7c9..0212a45268 100644
--- a/lily/include/audio-column.hh
+++ b/lily/include/audio-column.hh
@@ -37,7 +37,7 @@ public:
   void add_audio_item (Audio_item *i);
   Moment when () const;
 
-  vector<Audio_item *> audio_items_;
+  std::vector<Audio_item *> audio_items_;
   Moment when_;
   int ticks () const;
 protected:
diff --git a/lily/include/audio-element-info.hh b/lily/include/audio-element-info.hh
index 9b2f18f525..4cb52bb51b 100644
--- a/lily/include/audio-element-info.hh
+++ b/lily/include/audio-element-info.hh
@@ -33,7 +33,7 @@ public:
   Stream_event *event_;
   Translator *origin_trans_;
 
-  vector<Context *> origin_contexts (Translator *) const;
+  std::vector<Context *> origin_contexts (Translator *) const;
 
   Audio_element_info (Audio_element *, Stream_event *);
   Audio_element_info ();
diff --git a/lily/include/audio-item.hh b/lily/include/audio-item.hh
index 8c41d18a52..dbd4c38251 100644
--- a/lily/include/audio-item.hh
+++ b/lily/include/audio-item.hh
@@ -53,7 +53,7 @@ class Audio_span_dynamic : public Audio_element
 {
 public:
   Direction grow_dir_;
-  vector<Audio_dynamic *> dynamics_;
+  std::vector<Audio_dynamic *> dynamics_;
   Real min_volume_;
   Real max_volume_;
 
@@ -74,9 +74,9 @@ public:
 class Audio_instrument : public Audio_item
 {
 public:
-  Audio_instrument (string instrument_string);
+  Audio_instrument (std::string instrument_string);
 
-  string str_;
+  std::string str_;
 };
 
 class Audio_note : public Audio_item
@@ -87,7 +87,7 @@ public:
   // with tieWaitForNote, there might be a skip between the tied notes!
   void tie_to (Audio_note *, Moment skip = 0);
   Audio_note *tie_head ();
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Pitch pitch_;
   Moment length_mom_;
@@ -102,7 +102,7 @@ public:
 class Audio_piano_pedal : public Audio_item
 {
 public:
-  string type_string_;
+  std::string type_string_;
   Direction dir_;
 };
 
@@ -115,10 +115,10 @@ public:
     MARKER, CUE_POINT
   };
 
-  Audio_text (Audio_text::Type type, const string &text_string);
+  Audio_text (Audio_text::Type type, const std::string &text_string);
 
   Type type_;
-  string text_string_;
+  std::string text_string_;
 };
 
 class Audio_tempo : public Audio_item
diff --git a/lily/include/audio-staff.hh b/lily/include/audio-staff.hh
index a4a9d8a0d1..ca5c36fa94 100644
--- a/lily/include/audio-staff.hh
+++ b/lily/include/audio-staff.hh
@@ -33,7 +33,7 @@ struct Audio_staff : public Audio_element
 
   bool percussion_;
   bool merge_unisons_;
-  vector<Audio_item *> audio_items_;
+  std::vector<Audio_item *> audio_items_;
 };
 
 // Subtype to identify a staff that represents the "control track" of a MIDI
diff --git a/lily/include/axis-group-interface.hh b/lily/include/axis-group-interface.hh
index 5e5152d237..fc7e3c19d0 100644
--- a/lily/include/axis-group-interface.hh
+++ b/lily/include/axis-group-interface.hh
@@ -47,10 +47,10 @@ class Axis_group_interface
   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 string&);
-  static Interval relative_group_extent (vector<Grob *> const &list,
+  static SCM internal_calc_pure_relevant_grobs (Grob *, const std::string&);
+  static Interval relative_group_extent (std::vector<Grob *> const &list,
                                          Grob *common, Axis);
-  static Interval relative_maybe_bound_group_extent (vector<Grob *> const &list,
+  static Interval relative_maybe_bound_group_extent (std::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);
@@ -64,7 +64,7 @@ class Axis_group_interface
   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 *, vector<Grob *> *);
+  static void get_children (Grob *, std::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);
diff --git a/lily/include/beam-scoring-problem.hh b/lily/include/beam-scoring-problem.hh
index bbabfde7de..022c42a85a 100644
--- a/lily/include/beam-scoring-problem.hh
+++ b/lily/include/beam-scoring-problem.hh
@@ -48,14 +48,14 @@ struct Beam_configuration
   Interval y;
   Real demerits;
 #if DEBUG_BEAM_SCORING
-  string score_card_;
+  std::string score_card_;
 #endif
 
   int next_scorer_todo;
 
   Beam_configuration ();
   bool done () const;
-  void add (Real demerit, const string &reason);
+  void add (Real demerit, const std::string &reason);
   static Beam_configuration *new_config (Interval start,
                                          Interval offset);
 };
@@ -140,14 +140,14 @@ private:
     affine linear in YL and YR. If YL == YR == 0, then we might have
     stem_y != 0.0, when we're cross staff.
   */
-  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_;
+  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_;
 
   bool is_xstaff_;
   bool is_knee_;
@@ -164,8 +164,8 @@ private:
   // Beam_configurations.
   Drul_array<Interval> quant_range_;
   Real beam_translation_;
-  vector<Beam_collision> collisions_;
-  vector<Beam_segment> segments_;
+  std::vector<Beam_collision> collisions_;
+  std::vector<Beam_segment> segments_;
 
   vsize first_normal_index ();
   vsize last_normal_index ();
@@ -180,7 +180,7 @@ private:
 
   void one_scorer (Beam_configuration *config) const;
   Beam_configuration *force_score (SCM inspect_quants,
-                                   const vector<Beam_configuration *> &configs) const;
+                                   const std::vector<Beam_configuration *> &configs) const;
   Real y_at (Real x, Beam_configuration const *c) const;
 
   // Scoring functions:
@@ -190,7 +190,7 @@ private:
   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 (vector<Beam_configuration *> *scores) const;
+  void generate_quants (std::vector<Beam_configuration *> *scores) const;
   void score_collisions (Beam_configuration *config) const;
 };
 
diff --git a/lily/include/beam.hh b/lily/include/beam.hh
index 6dbdf4b23f..c6913eee2f 100644
--- a/lily/include/beam.hh
+++ b/lily/include/beam.hh
@@ -66,7 +66,7 @@ public:
   static Real get_beam_translation (Grob *me);
   static Real get_beam_thickness (Grob *me);
   static void connect_beams (Grob *me);
-  static vector<Beam_segment> get_beam_segments (Grob *me_grob, Grob **common);
+  static std::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));
@@ -88,7 +88,7 @@ private:
   friend class Beam_scoring_problem;
 
   static Direction get_default_dir (Grob *);
-  static vector<Beam_segment> get_beam_segments (Grob *);
+  static std::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 *);
diff --git a/lily/include/beaming-pattern.hh b/lily/include/beaming-pattern.hh
index 217af19088..4a1d970ef3 100644
--- a/lily/include/beaming-pattern.hh
+++ b/lily/include/beaming-pattern.hh
@@ -76,7 +76,7 @@ public:
   Beaming_pattern *split_pattern (int idx);
 
 private:
-  vector<Beam_rhythmic_element> infos_;
+  std::vector<Beam_rhythmic_element> infos_;
   Direction flag_direction (Beaming_options const &, vsize) const;
   void find_rhythmic_importance (Beaming_options const &);
   void unbeam_invisible_stems ();
diff --git a/lily/include/bezier.hh b/lily/include/bezier.hh
index 959afc5c4e..2222c80125 100644
--- a/lily/include/bezier.hh
+++ b/lily/include/bezier.hh
@@ -39,10 +39,10 @@ public:
   Bezier extract (Real, Real) const;
 
   Real get_other_coordinate (Axis a, Real x) const;
-  vector<Real> get_other_coordinates (Axis a, Real x) const;
-  vector<Real> solve_point (Axis, Real coordinate) const;
+  std::vector<Real> get_other_coordinates (Axis a, Real x) const;
+  std::vector<Real> solve_point (Axis, Real coordinate) const;
   Real minmax (Axis, Real, Real, Direction) const;
-  vector<Real> solve_derivative (Offset) const;
+  std::vector<Real> solve_derivative (Offset) const;
   Interval extent (Axis) const;
   Interval control_point_extent (Axis) const;
 
@@ -55,15 +55,15 @@ public:
 
   /*
     Bezier curves always have 4 control points. Making this into an
-    vector<> gives unnecessary overhead, and makes debugging a royal
+    std::vector<> gives unnecessary overhead, and makes debugging a royal
     pain.  */
 
   Offset control_[4];
 };
 
-void scale (vector<Offset> *array, Real xscale, Real yscale);
-void rotate (vector<Offset> *array, Real phi);
-void translate (vector<Offset> *array, Offset o);
+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);
 
 Bezier slur_shape (Real width, Real height_limit,
                    Real height_proportion);
diff --git a/lily/include/break-align-interface.hh b/lily/include/break-align-interface.hh
index cbb7f00c74..87e9073b5b 100644
--- a/lily/include/break-align-interface.hh
+++ b/lily/include/break-align-interface.hh
@@ -26,7 +26,7 @@
 class Break_alignment_interface
 {
 public:
-  static vector<Grob *> ordered_elements (Grob *me);
+  static std::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));
diff --git a/lily/include/change-iterator.hh b/lily/include/change-iterator.hh
index 1ba16c0907..d7473706dd 100644
--- a/lily/include/change-iterator.hh
+++ b/lily/include/change-iterator.hh
@@ -31,11 +31,11 @@ public:
   DECLARE_CLASSNAME (Change_iterator);
 
   // returns an error message (empty on success)
-  static string change_to (Music_iterator &it,
-                           SCM to_type, const string &to_id);
+  static std::string change_to (Music_iterator &it,
+                           SCM to_type, const std::string &to_id);
 
 private:
-  void error (const string&);
+  void error (const std::string&);
 };
 
 #endif
diff --git a/lily/include/change-sequence-iterator.hh b/lily/include/change-sequence-iterator.hh
index 2c2dfe3eb0..2c1ae65a22 100644
--- a/lily/include/change-sequence-iterator.hh
+++ b/lily/include/change-sequence-iterator.hh
@@ -35,7 +35,7 @@ protected:
 
 private:
   // implement in derived class to effect a context change
-  virtual void change_to (const string &id) = 0;
+  virtual void change_to (const std::string &id) = 0;
 
 private:
   // There is no need to protect this in derived_mark() because it is protected
diff --git a/lily/include/coherent-ligature-engraver.hh b/lily/include/coherent-ligature-engraver.hh
index 19e731815a..0aad39c110 100644
--- a/lily/include/coherent-ligature-engraver.hh
+++ b/lily/include/coherent-ligature-engraver.hh
@@ -29,12 +29,12 @@ public:
 
 protected:
   virtual void build_ligature (Spanner *ligature,
-                               vector<Grob_info> const &primitives) = 0;
+                               std::vector<Grob_info> const &primitives) = 0;
   virtual void typeset_ligature (Spanner *ligature,
-                                 vector<Grob_info> const &primitives);
+                                 std::vector<Grob_info> const &primitives);
   virtual void move_related_items_to_column (Item *, Paper_column *, Real);
 private:
-  void collect_accidentals (Spanner *, vector<Grob_info> const &);
+  void collect_accidentals (Spanner *, std::vector<Grob_info> const &);
 };
 
 #endif // COHERENT_LIGATURE_ENGRAVER_HH
diff --git a/lily/include/column-x-positions.hh b/lily/include/column-x-positions.hh
index f4ef6a02dc..dc35c0dc89 100644
--- a/lily/include/column-x-positions.hh
+++ b/lily/include/column-x-positions.hh
@@ -25,10 +25,10 @@
 
 struct Column_x_positions
 {
-  vector<Grob *> cols_;
-  vector<Grob *> loose_cols_;
+  std::vector<Grob *> cols_;
+  std::vector<Grob *> loose_cols_;
 
-  vector<Real> config_;
+  std::vector<Real> config_;
   Real force_;
   bool satisfies_constraints_;
 
diff --git a/lily/include/constrained-breaking.hh b/lily/include/constrained-breaking.hh
index e35fcc0bbe..bb8dcf0c3c 100644
--- a/lily/include/constrained-breaking.hh
+++ b/lily/include/constrained-breaking.hh
@@ -45,10 +45,10 @@ struct Line_details
   Grob *last_column_;
   Real force_;
   Line_shape shape_;
-  vector<Real> footnote_heights_; /* The footnotes at the bottom of the
+  std::vector<Real> footnote_heights_; /* The footnotes at the bottom of the
                                    page, where each stencil represents
                                    a different footnote. */
-  vector<Real> in_note_heights_; /* The in-notes under a system,
+  std::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
@@ -154,12 +154,12 @@ struct Constrained_break_node
 class Constrained_breaking
 {
 public:
-  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);
+  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);
 
   Constrained_breaking (Paper_score *ps);
-  Constrained_breaking (Paper_score *ps, vector<vsize> const &start_col_posns);
+  Constrained_breaking (Paper_score *ps, std::vector<vsize> const &start_col_posns);
 
   int max_system_count (vsize start, vsize end);
   int min_system_count (vsize start, vsize end);
@@ -186,13 +186,13 @@ private:
 
   /* 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 */
-  vector<Matrix<Constrained_break_node> > state_;
+  std::vector<Matrix<Constrained_break_node> > state_;
 
-  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<vsize> start_;         /* the columns at which we might be asked to start breaking */
+  std::vector<vsize> starting_breakpoints_; /* the corresponding index in breaks_ */
 
-  vector<Grob *> all_;
-  vector<vsize> breaks_;
+  std::vector<Grob *> all_;
+  std::vector<vsize> breaks_;
 
   void initialize ();
   void resize (vsize systems);
diff --git a/lily/include/context-def.hh b/lily/include/context-def.hh
index c49fee1e30..46f9d5560d 100644
--- a/lily/include/context-def.hh
+++ b/lily/include/context-def.hh
@@ -65,13 +65,13 @@ public:
 
   VIRTUAL_COPY_CONSTRUCTOR (Context_def, Context_def);
 
-  vector<Context_def *> path_to_acceptable_context (SCM type_string,
+  std::vector<Context_def *> path_to_acceptable_context (SCM type_string,
                                                     Output_def *,
                                                     SCM) const;
-  vector<Context_def *> internal_path_to_acceptable_context (SCM type_string,
+  std::vector<Context_def *> internal_path_to_acceptable_context (SCM type_string,
                                                              Output_def *,
                                                              SCM,
-                                                             set<const Context_def *> *seen) const;
+                                                             std::set<const Context_def *> *seen) const;
   Context *instantiate (SCM extra_ops);
 
   SCM to_alist () const;
diff --git a/lily/include/context.hh b/lily/include/context.hh
index 28e80fd2db..76317e96b4 100644
--- a/lily/include/context.hh
+++ b/lily/include/context.hh
@@ -63,7 +63,7 @@ protected:
   SCM default_child_;
   SCM aliases_;
   Translator_group *implementation_;
-  string id_string_;
+  std::string id_string_;
 
   /* Events reported in the context is sent to this dispatcher. */
   Dispatcher *event_source_;
@@ -83,7 +83,7 @@ protected:
   void unset_property_from_event (SCM);
 
 public:
-  string id_string () const { return id_string_; }
+  std::string id_string () const { return id_string_; }
   SCM children_contexts () const { return context_list_; }
   SCM default_child_context_name () const;
 
@@ -108,21 +108,21 @@ public:
   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 string&, SCM);
+  Context *create_context (Context_def *, const std::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 ();
-  string context_name () const;
+  std::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 string &context_id = "");
+  virtual Context *get_default_interpreter (const std::string &context_id = "");
 
   bool is_alias (SCM) const;
   void add_alias (SCM);
@@ -131,10 +131,10 @@ public:
   bool is_removable () const;
 
   Context *find_create_context (SCM context_name,
-                                const string &id, SCM ops);
-  Context *create_unique_context (SCM context_name, const string &context_id,
+                                const std::string &id, SCM ops);
+  Context *create_unique_context (SCM context_name, const std::string &context_id,
                                   SCM ops);
-  vector<Context_def *> path_to_acceptable_context (SCM alias) const;
+  std::vector<Context_def *> path_to_acceptable_context (SCM alias) const;
 };
 
 /*
@@ -158,13 +158,13 @@ Context *find_context_above_by_parent_type (Context *where, SCM parent_type);
 // 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 string &id);
+                             SCM type_sym, const std::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 string &id);
+                            SCM type_sym, const std::string &id);
 
 // Search for the top context (i.e. the ancestor with no parent) starting with
 // the given context.
diff --git a/lily/include/dimensions.hh b/lily/include/dimensions.hh
index a0e2f25edd..aa01197611 100644
--- a/lily/include/dimensions.hh
+++ b/lily/include/dimensions.hh
@@ -37,7 +37,7 @@ const Real PT_TO_MM = (1.0 / MM_TO_PT);
 
 #endif
 
-string print_dimen (Real);
+std::string print_dimen (Real);
 const Real point_constant = 1 PT;
 const Real inch_constant = 1 INCH;
 const Real cm_constant = 1 CM;
diff --git a/lily/include/dot-configuration.hh b/lily/include/dot-configuration.hh
index b4e2219e6c..cfc5ec67ca 100644
--- a/lily/include/dot-configuration.hh
+++ b/lily/include/dot-configuration.hh
@@ -42,7 +42,7 @@ struct Dot_position
   }
 };
 
-struct Dot_configuration : public map<int, Dot_position>
+struct Dot_configuration : public std::map<int, Dot_position>
 {
   Dot_formatting_problem const *problem_;
 
diff --git a/lily/include/dot-formatting-problem.hh b/lily/include/dot-formatting-problem.hh
index fcb6d19a22..7c2aca3115 100644
--- a/lily/include/dot-formatting-problem.hh
+++ b/lily/include/dot-formatting-problem.hh
@@ -14,7 +14,7 @@ struct Dot_formatting_problem
 
   void register_configuration (Dot_configuration const &);
   Dot_configuration *best () const;
-  Dot_formatting_problem (vector<Box> const &boxes, Interval base_x);
+  Dot_formatting_problem (std::vector<Box> const &boxes, Interval base_x);
   ~Dot_formatting_problem ();
 };
 
diff --git a/lily/include/duration.hh b/lily/include/duration.hh
index 7a57cf53af..303fecbeff 100644
--- a/lily/include/duration.hh
+++ b/lily/include/duration.hh
@@ -33,7 +33,7 @@ struct Duration : public Simple_smob<Duration>
   Duration ();
   Duration (int, int);
   Duration (Rational, bool scale);
-  string to_string () const;
+  std::string to_string () const;
 
   Duration compressed (Rational) const;
   Rational get_length () const;
diff --git a/lily/include/engraver-group.hh b/lily/include/engraver-group.hh
index aa3cd478bc..e3cb3b1218 100644
--- a/lily/include/engraver-group.hh
+++ b/lily/include/engraver-group.hh
@@ -26,7 +26,7 @@
 class Engraver_group : public Translator_group
 {
 protected:
-  vector<Grob_info> announce_infos_;
+  std::vector<Grob_info> announce_infos_;
   Drul_array<SCM> acknowledge_hash_table_drul_;
   void override (SCM);
   void revert (SCM);
diff --git a/lily/include/file-name-map.hh b/lily/include/file-name-map.hh
index 3fb22d6a2a..c0091a3b1e 100644
--- a/lily/include/file-name-map.hh
+++ b/lily/include/file-name-map.hh
@@ -22,7 +22,7 @@
 
 #include "std-string.hh"
 
-string map_file_name (const string &s);
+std::string map_file_name (const std::string &s);
 
 #endif /* FILE_NAME_MAP_HH */
 
diff --git a/lily/include/font-metric.hh b/lily/include/font-metric.hh
index d74c8157ca..4d4694cb21 100644
--- a/lily/include/font-metric.hh
+++ b/lily/include/font-metric.hh
@@ -42,22 +42,22 @@ private:
 
 public:
   SCM description_;
-  string file_name_;
+  std::string file_name_;
 
-  // Return stencil for given string. output_state may be modified to
+  // Return stencil for given std::string. output_state may be modified to
   // record the font.
   virtual Stencil text_stencil (Output_def *output_state,
-                                const string &text, bool music) const;
+                                const std::string &text, bool music) const;
 
-  virtual string font_name () const;
+  virtual std::string font_name () const;
   virtual size_t count () const;
-  virtual Offset attachment_point (const string&) const;
+  virtual Offset attachment_point (const std::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 (string) const=0;
+  virtual size_t name_to_index (std::string) const=0;
   virtual size_t index_to_charcode (size_t) const;
   virtual Real design_size () const;
-  virtual Stencil find_by_name (string) const;
+  virtual Stencil find_by_name (std::string) const;
   virtual SCM sub_fonts () const;
   virtual SCM font_file_name () const;
 
diff --git a/lily/include/freetype.hh b/lily/include/freetype.hh
index e4009ba072..43907d87d0 100644
--- a/lily/include/freetype.hh
+++ b/lily/include/freetype.hh
@@ -30,7 +30,7 @@
 void init_freetype ();
 extern FT_Library freetype2_library;
 
-string freetype_error_string (FT_Error code);
+std::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);
diff --git a/lily/include/global-context.hh b/lily/include/global-context.hh
index 75b52c95ae..1779280acc 100644
--- a/lily/include/global-context.hh
+++ b/lily/include/global-context.hh
@@ -46,7 +46,7 @@ public:
   virtual SCM get_output ();
   virtual Output_def *get_output_def () const;
   virtual Moment now_mom () const;
-  virtual Context *get_default_interpreter (const string &context_id = "");
+  virtual Context *get_default_interpreter (const std::string &context_id = "");
 
   Moment previous_moment () const;
 protected:
diff --git a/lily/include/gregorian-ligature-engraver.hh b/lily/include/gregorian-ligature-engraver.hh
index 5aea42662b..5727910666 100644
--- a/lily/include/gregorian-ligature-engraver.hh
+++ b/lily/include/gregorian-ligature-engraver.hh
@@ -34,9 +34,9 @@ protected:
 
   virtual void listen_pes_or_flexa (Stream_event *ev);
   virtual void build_ligature (Spanner *ligature,
-                               vector<Grob_info> const &primitives);
+                               std::vector<Grob_info> const &primitives);
   virtual void transform_heads (Spanner *ligature,
-                                vector<Grob_info> const &primitives) = 0;
+                                std::vector<Grob_info> const &primitives) = 0;
   void stop_translation_timestep ();
 };
 
diff --git a/lily/include/gregorian-ligature.hh b/lily/include/gregorian-ligature.hh
index 0089434163..251766062a 100644
--- a/lily/include/gregorian-ligature.hh
+++ b/lily/include/gregorian-ligature.hh
@@ -27,7 +27,7 @@ class Grob;
 class Gregorian_ligature
 {
 public:
-  static string prefixes_to_str (Grob *);
+  static std::string prefixes_to_str (Grob *);
 };
 
 /*
diff --git a/lily/include/grob-array.hh b/lily/include/grob-array.hh
index e3963f019d..ccbf8c82a8 100644
--- a/lily/include/grob-array.hh
+++ b/lily/include/grob-array.hh
@@ -31,7 +31,7 @@ public:
   SCM mark_smob () const;
   static const char type_p_name_[];
 private:
-  vector<Grob *> grobs_;
+  std::vector<Grob *> grobs_;
   bool ordered_;
 
 
@@ -47,14 +47,14 @@ public:
   void remove_duplicates ();
   void clear ();
   void add (Grob *x) { grobs_.push_back (x); }
-  void set_array (vector<Grob *> const &src);
-  vector<Grob *> &array_reference ();
-  vector<Grob *> const &array () const;
+  void set_array (std::vector<Grob *> const &src);
+  std::vector<Grob *> &array_reference ();
+  std::vector<Grob *> const &array () const;
   static SCM make_array ();
 };
 
 
-vector<Grob *> const &ly_scm2link_array (SCM x);
+std::vector<Grob *> const &ly_scm2link_array (SCM x);
 SCM grob_list_to_grob_array (SCM lst);
 SCM grob_array_to_list (Grob_array *array);
 
diff --git a/lily/include/grob-info.hh b/lily/include/grob-info.hh
index 1df88ce749..1faeb5a2da 100644
--- a/lily/include/grob-info.hh
+++ b/lily/include/grob-info.hh
@@ -42,7 +42,7 @@ public:
   Context *context () const;
   Stream_event *event_cause () const;
   Stream_event *ultimate_event_cause () const;
-  vector<Context *> origin_contexts (Translator *) const;
+  std::vector<Context *> origin_contexts (Translator *) const;
   Grob_info (Translator *, Grob *);
   Grob_info ();
 
diff --git a/lily/include/grob.hh b/lily/include/grob.hh
index db51e02e73..5dda5112b2 100644
--- a/lily/include/grob.hh
+++ b/lily/include/grob.hh
@@ -102,7 +102,7 @@ public:
   bool is_live () const;
 
   /* naming. */
-  string name () const;
+  std::string name () const;
 
   /* Properties */
   SCM get_property_alist_chain (SCM) const;
@@ -118,8 +118,8 @@ public:
   void internal_set_property (SCM sym, SCM val);
 
   /* messages */
-  void warning (const string&) const;
-  void programming_error (const string&) const;
+  void warning (const std::string&) const;
+  void programming_error (const std::string&) const;
 
   /* class hierarchy */
   virtual System *get_system () const;
@@ -181,12 +181,12 @@ inline bool has_interface(Grob *g)
 }
 
 /* unification */
-void uniquify (vector <Grob *> &);
+void uniquify (std::vector <Grob *> &);
 
 /* refpoints */
 Grob *common_refpoint_of_list (SCM elt_list, 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);
+Grob *common_refpoint_of_array (std::vector<Grob *> const &, Grob *, Axis a);
+Grob *common_refpoint_of_array (std::set<Grob *> const &, Grob *, Axis a);
 System *get_root_system (Grob *me);
 
 /* extents */
diff --git a/lily/include/horizontal-bracket.hh b/lily/include/horizontal-bracket.hh
index 3a1692fc11..0b30949c25 100644
--- a/lily/include/horizontal-bracket.hh
+++ b/lily/include/horizontal-bracket.hh
@@ -29,7 +29,7 @@ struct Horizontal_bracket
   DECLARE_SCHEME_CALLBACK (print, (SCM));
   static Stencil make_bracket (Grob *, Real, Axis, Direction);
   static Stencil make_enclosing_bracket (Grob *me, Grob *refpoint,
-                                         vector<Grob *> grobs,
+                                         std::vector<Grob *> grobs,
                                          Axis a, Direction dir);
 };
 
diff --git a/lily/include/includable-lexer.hh b/lily/include/includable-lexer.hh
index bfc3d81718..a4c3c0545d 100644
--- a/lily/include/includable-lexer.hh
+++ b/lily/include/includable-lexer.hh
@@ -36,26 +36,26 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 */
 class Includable_lexer : public yyFlexLexer
 {
-  vector<YY_BUFFER_STATE> state_stack_;
+  std::vector<YY_BUFFER_STATE> state_stack_;
 
 protected:
   bool close_input ();
-  vector<Source_file *> include_stack_;
-  vector<int> char_count_stack_;
+  std::vector<Source_file *> include_stack_;
+  std::vector<int> char_count_stack_;
 
 public:
 
   Includable_lexer ();
   ~Includable_lexer ();
-  string main_input_name_;
+  std::string main_input_name_;
 
   /// store dependencies for Makefile stuff.
-  vector<string> file_name_strings_;
+  std::vector<std::string> file_name_strings_;
 
   Source_file *get_source_file () const;
-  virtual void new_input (const string &s, Sources *);
+  virtual void new_input (const std::string &s, Sources *);
 
-  void new_input (const string &name, string data, Sources *);
+  void new_input (const std::string &name, std::string data, Sources *);
 
   char const *here_str0 () const;
 };
diff --git a/lily/include/input.hh b/lily/include/input.hh
index b77db2d66f..dbe3a2b525 100644
--- a/lily/include/input.hh
+++ b/lily/include/input.hh
@@ -41,21 +41,21 @@ public:
   char const *end () const;
 
   void set (Source_file *, char const *, char 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 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 set_spot (Input const &);
   void step_forward ();
   void set_location (Input const &, Input const &);
 
   Input spot () const;
 
-  string location_string () const;
-  string line_number_string () const;
-  string file_string ()const;
+  std::string location_string () const;
+  std::string line_number_string () const;
+  std::string file_string ()const;
 
   int line_number ()const;
   int column_number ()const;
@@ -67,8 +67,8 @@ public:
   Input (Input const &i);
   Input ();
 protected:
-  string message_location () const;
-  string message_string (const string &msg) const;
+  std::string message_location () const;
+  std::string message_string (const std::string &msg) const;
 };
 
 extern Input dummy_input_global;
diff --git a/lily/include/interval-minefield.hh b/lily/include/interval-minefield.hh
index fc748c17b6..8977707e6b 100644
--- a/lily/include/interval-minefield.hh
+++ b/lily/include/interval-minefield.hh
@@ -34,7 +34,7 @@ public:
   void solve ();
 
 private:
-  vector<Interval> forbidden_intervals_;
+  std::vector<Interval> forbidden_intervals_;
   Interval feasible_placements_;
   Real bulk_;
 };
diff --git a/lily/include/keyword.hh b/lily/include/keyword.hh
index 0f36fe812b..119345ea59 100644
--- a/lily/include/keyword.hh
+++ b/lily/include/keyword.hh
@@ -34,7 +34,7 @@ struct Keyword_ent
 */
 struct Keyword_table
 {
-  vector<Keyword_ent> table_;
+  std::vector<Keyword_ent> table_;
 
   Keyword_table (Keyword_ent *);
   vsize lookup (char const *s) const;
diff --git a/lily/include/least-squares.hh b/lily/include/least-squares.hh
index 5a8c39bacc..cee025d3cb 100644
--- a/lily/include/least-squares.hh
+++ b/lily/include/least-squares.hh
@@ -25,7 +25,7 @@
 /**
    Least squares minimisation in 2 variables.
 */
-void minimise_least_squares (Real *coef, Real *offset, vector<Offset> const &);
+void minimise_least_squares (Real *coef, Real *offset, std::vector<Offset> const &);
 
 #endif // LEASTSQUARE_HH
 
diff --git a/lily/include/ligature-engraver.hh b/lily/include/ligature-engraver.hh
index 6f53331a4e..0af8d1466a 100644
--- a/lily/include/ligature-engraver.hh
+++ b/lily/include/ligature-engraver.hh
@@ -36,7 +36,7 @@ protected:
   void process_music ();
   virtual Spanner *create_ligature_spanner () = 0;
   virtual void typeset_ligature (Spanner *ligature,
-                                 vector<Grob_info> const &primitives) = 0;
+                                 std::vector<Grob_info> const &primitives) = 0;
   virtual Spanner *current_ligature ();
   SCM brew_ligature_primitive_proc;
 
@@ -48,10 +48,10 @@ private:
   Drul_array<Stream_event *> events_drul_;
 
   Spanner *ligature_;
-  vector<Grob_info> primitives_;
+  std::vector<Grob_info> primitives_;
 
   Spanner *finished_ligature_;
-  vector<Grob_info> finished_primitives_;
+  std::vector<Grob_info> finished_primitives_;
 
   Stream_event *prev_start_event_;
 
diff --git a/lily/include/lily-guile-macros.hh b/lily/include/lily-guile-macros.hh
index 869a52af32..d1728d8fd2 100644
--- a/lily/include/lily-guile-macros.hh
+++ b/lily/include/lily-guile-macros.hh
@@ -25,7 +25,7 @@
 #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 string
+// strings known to be in ASCII entirely, including any std::string
 // constants in the C code.
 #define scm_from_ascii_string scm_from_latin1_string
 #define scm_from_ascii_stringn scm_from_latin1_stringn
@@ -77,7 +77,7 @@ scm_or_str2symbol (SCM s)
 }
 
 /* Using this trick we cache the value of scm_from_locale_symbol ("fooo") where
-   "fooo" is a constant string. This is done at the cost of one static
+   "fooo" is a constant std::string. This is done at the cost of one static
    variable per ly_symbol2scm() use, and one boolean evaluation for
    every call.
  */
@@ -107,10 +107,10 @@ inline SCM ly_symbol2scm (char const *x) { return scm_from_utf8_symbol ((x)); }
   static SCM NAME ARGS;                         \
   static SCM NAME ## _proc
 
-string mangle_cxx_identifier (string);
+std::string mangle_cxx_identifier (std::string);
 
-void ly_add_type_predicate (void *ptr, const string &name);
-string predicate_to_typename (void *ptr);
+void ly_add_type_predicate (void *ptr, const std::string &name);
+std::string predicate_to_typename (void *ptr);
 
 /*
   Make TYPE::FUNC available as a Scheme function.
@@ -120,8 +120,8 @@ string predicate_to_typename (void *ptr);
   void                                                                  \
   TYPE ## _ ## FUNC ## _init_functions ()                               \
   {                                                                     \
-    string cxx = string (#TYPE) + "::" + string (#FUNC); \
-    string id = mangle_cxx_identifier (cxx); \
+    std::string cxx = std::string (#TYPE) + "::" + std::string (#FUNC); \
+    std::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); \
@@ -139,8 +139,8 @@ string predicate_to_typename (void *ptr);
 #define MAKE_SCHEME_CALLBACK(TYPE, FUNC, ARGCOUNT)                      \
   MAKE_SCHEME_CALLBACK_WITH_OPTARGS(TYPE,FUNC,ARGCOUNT, 0, "");
 
-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);
+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);
 
 #define ADD_SCM_INIT_FUNC(name, func)           \
   class name ## _scm_initter                    \
diff --git a/lily/include/lily-guile.hh b/lily/include/lily-guile.hh
index 34578511b8..a014e018a6 100644
--- a/lily/include/lily-guile.hh
+++ b/lily/include/lily-guile.hh
@@ -43,16 +43,16 @@
     A ly_B2A (B b);  */
 
 SCM ly_last (SCM list);
-string ly_scm_write_string (SCM s);
+std::string ly_scm_write_string (SCM s);
 SCM ly_deep_copy (SCM);
 SCM ly_truncate_list (int k, SCM lst);
 
-string gulp_file_to_string (const string &fn, bool must_exist, int size);
+std::string gulp_file_to_string (const std::string &fn, bool must_exist, int size);
 
-SCM ly_string2scm (string const &s);
-string ly_scm2string (SCM s);
-string ly_symbol2string (SCM);
-string robust_symbol2string (SCM, const string&);
+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&);
 Rational ly_scm2rational (SCM);
 SCM ly_rational2scm (Rational);
 SCM ly_offset2scm (Offset);
@@ -75,14 +75,14 @@ Drul_array<Real> robust_scm2drul (SCM, Drul_array<Real>);
 Drul_array<bool> robust_scm2booldrul (SCM, Drul_array<bool>);
 Interval robust_scm2interval (SCM, Drul_array<Real>);
 Offset robust_scm2offset (SCM, Offset);
-string robust_scm2string (SCM, const string&);
+std::string robust_scm2string (SCM, const std::string&);
 Rational robust_scm2rational (SCM, Rational);
-vector<Real> ly_scm2floatvector (SCM);
-SCM ly_floatvector2scm (vector<Real> v);
+std::vector<Real> ly_scm2floatvector (SCM);
+SCM ly_floatvector2scm (std::vector<Real> v);
 
 SCM ly_quote_scm (SCM s);
 bool type_check_assignment (SCM val, SCM sym, SCM type_symbol);
-string print_scm_val (SCM val);
+std::string print_scm_val (SCM val);
 SCM ly_number2string (SCM s);
 
 SCM parse_symbol_list (char const *);
@@ -137,7 +137,7 @@ extern "C" {
   void ly_display_scm (SCM s);
 }
 
-void read_lily_scm_file (string);
+void read_lily_scm_file (std::string);
 void ly_c_init_guile ();
 
 bool is_direction (SCM s);
@@ -202,7 +202,7 @@ inline bool ly_is_pair (SCM x) { return SCM_I_CONSP (x); }
 
 template<class T>
 SCM
-ly_cxx_vector_to_list (vector<T> const &src)
+ly_cxx_vector_to_list (std::vector<T> const &src)
 {
   SCM l = SCM_EOL;
   for (vsize i = src.size (); i--;)
@@ -211,8 +211,8 @@ ly_cxx_vector_to_list (vector<T> const &src)
   return l;
 }
 
-SCM ly_offsets2scm (vector<Offset> os);
-vector<Offset> ly_scm2offsets (SCM s);
+SCM ly_offsets2scm (std::vector<Offset> os);
+std::vector<Offset> ly_scm2offsets (SCM s);
 
 /* For backward compatability with Guile 1.8 */
 #if !HAVE_GUILE_HASH_FUNC
diff --git a/lily/include/lily-lexer.hh b/lily/include/lily-lexer.hh
index 0e001ec187..588da0d8f2 100644
--- a/lily/include/lily-lexer.hh
+++ b/lily/include/lily-lexer.hh
@@ -39,10 +39,10 @@ public:
   static const char type_p_name_[];
   virtual ~Lily_lexer ();
 private:
-  int lookup_keyword (const string&);
-  int scan_bare_word (const string&);
-  int scan_escaped_word (const string&);
-  int scan_shorthand (const string&);
+  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 scan_scm_id (SCM);
   int identifier_type (SCM);
   char escaped_char (char) const;
@@ -93,12 +93,12 @@ public:
 
   void start_main_input ();
 
-  virtual void new_input (const string &s, Sources *);
-  virtual void new_input (const string &s, string d, Sources *);
+  virtual void new_input (const std::string &s, Sources *);
+  virtual void new_input (const std::string &s, std::string d, Sources *);
 
   bool top_input () { return include_stack_.size () < 2; }
   SCM keyword_list () const;
-  SCM lookup_identifier (const string &s);
+  SCM lookup_identifier (const std::string &s);
   SCM lookup_identifier_symbol (SCM s);
   void push_extra_token (Input const &where,
                          int token_type, SCM scm = SCM_UNSPECIFIED);
diff --git a/lily/include/lily-parser.hh b/lily/include/lily-parser.hh
index b08df7c7a4..0a8656fd15 100644
--- a/lily/include/lily-parser.hh
+++ b/lily/include/lily-parser.hh
@@ -42,7 +42,7 @@ public:
   Sources *sources_;
   Duration default_duration_;
   int default_tremolo_type_;
-  string output_basename_;
+  std::string output_basename_;
   SCM closures_;
 
   int fatal_error_;
@@ -57,14 +57,14 @@ public:
 
   void clear ();
   void do_init_file ();
-  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&);
+  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&);
   // The following is called as yyerror
-  static void parser_error (Input const *i, Lily_parser *parser, SCM *, const string &s);
+  static void parser_error (Input const *i, Lily_parser *parser, SCM *, const std::string &s);
   void set_yydebug (bool);
 
   SCM make_scope () const;
diff --git a/lily/include/lily-version.hh b/lily/include/lily-version.hh
index edb46c6c58..842e35cc57 100644
--- a/lily/include/lily-version.hh
+++ b/lily/include/lily-version.hh
@@ -22,9 +22,9 @@
 
 #include "std-string.hh"
 
-string version_string ();
-string gnu_lilypond_string ();
-string gnu_lilypond_version_string ();
+std::string version_string ();
+std::string gnu_lilypond_string ();
+std::string gnu_lilypond_version_string ();
 
 #endif // LILY_VERSION_HH
 
diff --git a/lily/include/lilypond-version.hh b/lily/include/lilypond-version.hh
index 818414abdf..1d25de986e 100644
--- a/lily/include/lilypond-version.hh
+++ b/lily/include/lilypond-version.hh
@@ -26,16 +26,16 @@
 struct Lilypond_version
 {
   Lilypond_version (int major, int minor, int patch);
-  Lilypond_version (const string &str);
+  Lilypond_version (const std::string &str);
 
-  string to_string () const;
+  std::string to_string () const;
   operator bool () const;
   static int compare (const Lilypond_version &, const Lilypond_version &);
 
   int major_;
   int minor_;
   int patch_;
-  string extra_patch_string_;
+  std::string extra_patch_string_;
 };
 
 INSTANTIATE_COMPARE (const Lilypond_version &, Lilypond_version::compare);
diff --git a/lily/include/lookup.hh b/lily/include/lookup.hh
index 3c9c19d7de..11687c0fdb 100644
--- a/lily/include/lookup.hh
+++ b/lily/include/lookup.hh
@@ -29,7 +29,7 @@ struct Lookup
   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 (vector<Offset> const &points, Real blotdiameter);
+  static Stencil round_filled_polygon (std::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);
@@ -42,7 +42,7 @@ struct Lookup
   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, vector<Offset> const &points);
+  static Stencil points_to_line_stencil (Real thick, std::vector<Offset> const &points);
 };
 
 #endif // LOOKUP_HH
diff --git a/lily/include/main.hh b/lily/include/main.hh
index 1e6e2caf51..5d72793c9f 100644
--- a/lily/include/main.hh
+++ b/lily/include/main.hh
@@ -29,32 +29,32 @@ void do_scores ();
 void clear_scores ();
 void add_score (Score *s);
 void call_constructors ();
-vector<string> get_inclusion_names ();
-void set_inclusion_names (vector<string>);
+std::vector<std::string> get_inclusion_names ();
+void set_inclusion_names (std::vector<std::string>);
 
-extern string init_name_global;
+extern std::string init_name_global;
 
 /* options */
-extern vector<string> dump_header_fieldnames_global;
-extern vector<string> start_environment_global;
-extern string output_backend_global;
-extern string output_name_global;
+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 bool bigpdfs;
 extern bool be_safe_global;
 extern bool do_internal_type_checking_global;
-extern string lilypond_datadir;
+extern std::string lilypond_datadir;
 extern bool use_object_keys;
 extern bool strict_infinity_checking;
-extern string init_scheme_code_global;
-extern string init_scheme_variables_global;
+extern std::string init_scheme_code_global;
+extern std::string init_scheme_variables_global;
 
 /*
   todo: collect in Output_option struct?
 */
-extern string output_format_global;
+extern std::string output_format_global;
 
 /* misc */
-extern vector<string> failed_files;
+extern std::vector<std::string> failed_files;
 extern int exit_status_global;
 extern File_path global_path;
 extern const char *LILYPOND_DATADIR;
diff --git a/lily/include/midi-chunk.hh b/lily/include/midi-chunk.hh
index 0786a4871d..bf01cd7568 100644
--- a/lily/include/midi-chunk.hh
+++ b/lily/include/midi-chunk.hh
@@ -34,7 +34,7 @@ public:
 
   int delta_ticks_;
   Midi_item *midi_;
-  string to_string () const;
+  std::string to_string () const;
 };
 
 /**
@@ -43,15 +43,15 @@ public:
 class Midi_chunk
 {
 public:
-  void set (const string &header_string, const string &data_string, const string &footer_string);
-  virtual string to_string () const;
-  virtual string data_string () const;
+  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;
   DECLARE_CLASSNAME (Midi_chunk);
   virtual ~Midi_chunk ();
 private:
-  string data_string_;
-  string footer_string_;
-  string header_string_;
+  std::string data_string_;
+  std::string footer_string_;
+  std::string header_string_;
 };
 
 class Midi_header : public Midi_chunk
@@ -69,13 +69,13 @@ public:
   int port_;
   DECLARE_CLASSNAME (Midi_track);
 
-  vector<Midi_event *> events_;
+  std::vector<Midi_event *> events_;
 
   Midi_track (int number, bool port);
   ~Midi_track ();
 
   void add (int, Midi_item *midi);
-  virtual string data_string () const;
+  virtual std::string data_string () const;
 };
 
 #endif /* MIDI_CHUNK_HH */
diff --git a/lily/include/midi-item.hh b/lily/include/midi-item.hh
index b593ce1527..5d9e100ca8 100644
--- a/lily/include/midi-item.hh
+++ b/lily/include/midi-item.hh
@@ -23,7 +23,7 @@
 #include "audio-item.hh"
 #include "std-vector.hh"
 
-string int2midi_varint_string (int i);
+std::string int2midi_varint_string (int i);
 
 /**
    Any piece of midi information.
@@ -40,7 +40,7 @@ public:
 
   static Midi_item *get_midi (Audio_item *a);
 
-  virtual string to_string () const = 0;
+  virtual std::string to_string () const = 0;
 };
 
 class Midi_channel_item : public Midi_item
@@ -61,7 +61,7 @@ public:
   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 string to_string () const;
+  virtual std::string to_string () const;
   Audio_control_function_value_change::Control control_;
   Real value_;
 };
@@ -71,7 +71,7 @@ class Midi_duration : public Midi_item
 public:
   Midi_duration (Real seconds_f);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
   Real seconds_;
 };
 
@@ -84,7 +84,7 @@ public:
   Midi_instrument (Audio_instrument *);
 
   DECLARE_CLASSNAME (Midi_instrument);
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_instrument *audio_;
 };
@@ -95,7 +95,7 @@ public:
   Midi_key (Audio_key *);
   DECLARE_CLASSNAME (Midi_key);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_key *audio_;
 };
@@ -106,7 +106,7 @@ public:
   Midi_time_signature (Audio_time_signature *);
   DECLARE_CLASSNAME (Midi_time_signature);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_time_signature *audio_;
   int clocks_per_1_;
@@ -120,7 +120,7 @@ public:
 
   int get_semitone_pitch () const;
   int get_fine_tuning () const;
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_note *audio_;
 
@@ -134,7 +134,7 @@ public:
   Midi_note_off (Midi_note *);
   DECLARE_CLASSNAME (Midi_note_off);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Midi_note *on_;
   Byte aftertouch_byte_;
@@ -152,7 +152,7 @@ public:
 
   Midi_text (Audio_text *);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_text *audio_;
 };
@@ -163,7 +163,7 @@ public:
   Midi_dynamic (Audio_dynamic *);
   DECLARE_CLASSNAME (Midi_dynamic);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_dynamic *audio_;
 };
@@ -174,7 +174,7 @@ public:
   Midi_piano_pedal (Audio_piano_pedal *);
   DECLARE_CLASSNAME (Midi_piano_pedal);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_piano_pedal *audio_;
 };
@@ -185,7 +185,7 @@ public:
   Midi_tempo (Audio_tempo *);
   DECLARE_CLASSNAME (Midi_tempo);
 
-  virtual string to_string () const;
+  virtual std::string to_string () const;
 
   Audio_tempo *audio_;
 };
diff --git a/lily/include/midi-stream.hh b/lily/include/midi-stream.hh
index a14ac80e20..544aa884ba 100644
--- a/lily/include/midi-stream.hh
+++ b/lily/include/midi-stream.hh
@@ -21,7 +21,6 @@
 #define MIDI_STREAM_HH
 
 #include <cstdio>
-using namespace std;
 
 #include <string.h>
 #include "std-string.hh"
@@ -29,15 +28,15 @@ using namespace std;
 
 struct Midi_stream
 {
-  Midi_stream (const string &file_name_string);
+  Midi_stream (const std::string &file_name_string);
   ~Midi_stream ();
 
-  void write (const string&);
+  void write (const std::string&);
   void write (Midi_chunk const &);
   void open ();
 
   FILE *out_file_;
-  string file_name_string_;
+  std::string file_name_string_;
 };
 
 #endif // MIDI_STREAM_HH
diff --git a/lily/include/midi-walker.hh b/lily/include/midi-walker.hh
index f23b7407e8..3267a2d047 100644
--- a/lily/include/midi-walker.hh
+++ b/lily/include/midi-walker.hh
@@ -56,11 +56,11 @@ private:
   bool percussion_;
   bool merge_unisons_;
   vsize index_;
-  vector<Audio_item *> items_;
+  std::vector<Audio_item *> items_;
   PQueue<Midi_note_event> stop_note_queue;
   int last_tick_;
 
-  vector<Midi_item *> midi_events_;
+  std::vector<Midi_item *> midi_events_;
 };
 
 #endif // MIDI_WALKER_HH
diff --git a/lily/include/misc.hh b/lily/include/misc.hh
index 7226aceef8..206e74e3ea 100644
--- a/lily/include/misc.hh
+++ b/lily/include/misc.hh
@@ -21,7 +21,6 @@
 #define MISC_HH
 
 #include <cstdlib>
-using namespace std;
 
 #include "std-vector.hh"
 #include "interval.hh"
@@ -63,7 +62,7 @@ Real directed_round (Real f, Direction d);
 
 Real peak_around (Real epsilon, Real threshold, Real x);
 Real convex_amplifier (Real standard_x, Real increase_factor, Real x);
-string camel_case_to_lisp_identifier (const string &in);
+std::string camel_case_to_lisp_identifier (const std::string &in);
 
 #endif
 
diff --git a/lily/include/modified-font-metric.hh b/lily/include/modified-font-metric.hh
index c63c532fbd..1716502267 100644
--- a/lily/include/modified-font-metric.hh
+++ b/lily/include/modified-font-metric.hh
@@ -26,14 +26,14 @@
 struct Modified_font_metric : public Font_metric
 {
 public:
-  Stencil text_stencil (Output_def *output_state, const string&, bool) const;
+  Stencil text_stencil (Output_def *output_state, const std::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 string&) const;
-  size_t name_to_index (string) const;
+  Offset attachment_point (const std::string&) const;
+  size_t name_to_index (std::string) const;
   size_t index_to_charcode (size_t) const;
   Font_metric *original_font () const;
 
@@ -43,7 +43,7 @@ protected:
 
   Modified_font_metric (Font_metric *fm, Real magnification);
   SCM sub_fonts () const;
-  string font_name () const;
+  std::string font_name () const;
   Real design_size () const;
   void derived_mark () const;
   Box get_indexed_char_dimensions (size_t) const;
diff --git a/lily/include/moment.hh b/lily/include/moment.hh
index d84a992b40..9f825970af 100644
--- a/lily/include/moment.hh
+++ b/lily/include/moment.hh
@@ -59,7 +59,7 @@ public:
   /*
     Deliver a copy of THIS as a smobified SCM
   */
-  string to_string () const;
+  std::string to_string () const;
   static int compare (Moment const &, Moment const &);
   SCM as_scheme () const;
 };
diff --git a/lily/include/music-iterator.hh b/lily/include/music-iterator.hh
index 810d230aac..d5c69d4390 100644
--- a/lily/include/music-iterator.hh
+++ b/lily/include/music-iterator.hh
@@ -114,7 +114,7 @@ bool is_child_context (Context *me, Context *child);
 
 #define IMPLEMENT_CTOR_CALLBACK(Class)                                  \
   LY_DEFINE_MEMBER_FUNCTION (Class, constructor, \
-                             mangle_cxx_identifier (string (#Class) + "::constructor").c_str(), \
+                             mangle_cxx_identifier (std::string (#Class) + "::constructor").c_str(), \
                              0, 0, 0,                                   \
                              (),                                        \
                              "")                                        \
diff --git a/lily/include/note-collision.hh b/lily/include/note-collision.hh
index ad2ed5345d..62b29e8318 100644
--- a/lily/include/note-collision.hh
+++ b/lily/include/note-collision.hh
@@ -37,11 +37,11 @@
 class Note_collision_interface
 {
 public:
-  static SCM automatic_shift (Grob *, Drul_array<vector<Grob *> >);
+  static SCM automatic_shift (Grob *, Drul_array<std::vector<Grob *> >);
   static SCM forced_shift (Grob *);
 
-  static vector<int> note_head_positions (Grob *me);
-  static Drul_array<vector<Grob *> > get_clash_groups (Grob *me);
+  static std::vector<int> note_head_positions (Grob *me);
+  static Drul_array<std::vector<Grob *> > get_clash_groups (Grob *me);
   DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM smob));
   static void add_column (Grob *me, Grob *ncol);
 };
diff --git a/lily/include/note-head.hh b/lily/include/note-head.hh
index 1e167d58b2..d57d3e41e9 100644
--- a/lily/include/note-head.hh
+++ b/lily/include/note-head.hh
@@ -34,7 +34,7 @@ public:
   static Real stem_attachment_coordinate (Grob *, Axis a);
   static int get_balltype (Grob *);
 
-  static Offset get_stem_attachment (Font_metric *, const string&);
+  static Offset get_stem_attachment (Font_metric *, const std::string&);
 };
 #endif // NOTEHEAD_HH
 
diff --git a/lily/include/open-type-font.hh b/lily/include/open-type-font.hh
index f08d4fa71c..49b257586c 100644
--- a/lily/include/open-type-font.hh
+++ b/lily/include/open-type-font.hh
@@ -48,22 +48,22 @@ public:
   SCM glyph_list () const;
   SCM get_glyph_outline (size_t signed_idx) const;
   Box get_glyph_outline_bbox (size_t signed_idx) const;
-  string get_otf_table (const string &tag) const;
-  static SCM make_otf (const string&);
-  string font_name () const;
+  std::string get_otf_table (const std::string &tag) const;
+  static SCM make_otf (const std::string&);
+  std::string font_name () const;
   ~Open_type_font ();
-  Offset attachment_point (const string&) const;
+  Offset attachment_point (const std::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 (string) const;
+  size_t name_to_index (std::string) const;
   size_t index_to_charcode (size_t) const;
   void derived_mark () const;
   SCM sub_fonts () const;
   Real design_size () const;
 };
 
-string get_otf_table (FT_Face face, const string &tag);
-FT_Face open_ft_face (const string&, FT_Long idx);
+std::string get_otf_table (FT_Face face, const std::string &tag);
+FT_Face open_ft_face (const std::string&, FT_Long idx);
 
 #endif /* OPEN_TYPE_FONT_HH */
diff --git a/lily/include/output-def.hh b/lily/include/output-def.hh
index 5de672e67a..e41cf75846 100644
--- a/lily/include/output-def.hh
+++ b/lily/include/output-def.hh
@@ -66,7 +66,7 @@ public:
   /*
     variables.
    */
-  SCM c_variable (const string &id) const;
+  SCM c_variable (const std::string &id) const;
   SCM lookup_variable (SCM sym) const;
   void set_variable (SCM sym, SCM val);
   void normalize ();
diff --git a/lily/include/page-breaking.hh b/lily/include/page-breaking.hh
index 9a38485c28..cab51e001c 100644
--- a/lily/include/page-breaking.hh
+++ b/lily/include/page-breaking.hh
@@ -101,7 +101,7 @@ class Page_breaking
 public:
   typedef bool (*Break_predicate) (Grob *);
   typedef bool (*Prob_break_predicate) (Prob *);
-  typedef vector<vsize> Line_division;
+  typedef std::vector<vsize> Line_division;
 
   /*
     TODO: naming.
@@ -142,7 +142,7 @@ protected:
 
   vsize next_system (Break_position const &break_pos) const;
 
-  SCM make_pages (vector<vsize> lines_per_page, SCM lines);
+  SCM make_pages (std::vector<vsize> lines_per_page, SCM lines);
 
   vsize min_system_count (vsize start, vsize end);
   vsize max_system_count (vsize start, vsize end);
@@ -179,11 +179,11 @@ protected:
 
   vsize last_break_position () const;
 
-  vector<System_spec> system_specs_;
+  std::vector<System_spec> system_specs_;
 private:
-  vector<Break_position> breaks_;
-  vector<Break_position> chunks_;
-  vector<Constrained_breaking> line_breaking_;
+  std::vector<Break_position> breaks_;
+  std::vector<Break_position> chunks_;
+  std::vector<Constrained_breaking> line_breaking_;
   bool ragged_;
   bool ragged_last_;
   int systems_per_page_;
@@ -197,8 +197,8 @@ private:
   Real footnote_footer_padding_;
   int orphan_penalty_;
 
-  vector<Line_division> current_configurations_;
-  vector<Break_position> current_chunks_;
+  std::vector<Line_division> current_configurations_;
+  std::vector<Break_position> current_chunks_;
   vsize current_start_breakpoint_;
   vsize current_end_breakpoint_;
 
@@ -206,15 +206,15 @@ private:
   void compute_line_heights ();
   void clear_line_details_cache ();
   vsize cached_configuration_index_;
-  vector<Line_details> cached_line_details_;
-  vector<Line_details> uncompressed_line_details_;
+  std::vector<Line_details> cached_line_details_;
+  std::vector<Line_details> uncompressed_line_details_;
 
   Real paper_height_;
-  mutable vector<Real> page_height_cache_;
-  mutable vector<Real> last_page_height_cache_;
+  mutable std::vector<Real> page_height_cache_;
+  mutable std::vector<Real> last_page_height_cache_;
 
-  vector<Break_position> chunk_list (vsize start, vsize end);
-  Line_division system_count_bounds (vector<Break_position> const &chunks, bool min);
+  std::vector<Break_position> chunk_list (vsize start, vsize end);
+  Line_division system_count_bounds (std::vector<Break_position> const &chunks, bool min);
   void line_breaker_args (vsize i,
                           Break_position const &start,
                           Break_position const &end,
@@ -226,8 +226,8 @@ private:
                            Line_division const &max,
                            Line_division *cur);
 
-  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);
+  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);
   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 ();
diff --git a/lily/include/page-layout-problem.hh b/lily/include/page-layout-problem.hh
index a98d264354..f2b5d6a961 100644
--- a/lily/include/page-layout-problem.hh
+++ b/lily/include/page-layout-problem.hh
@@ -37,7 +37,7 @@ public:
   static bool read_spacing_spec (SCM spec, Real *dest, SCM sym);
   static bool is_spaceable (Grob *g);
   static SCM get_details (Grob *g);
-  static vector<Grob *> get_footnote_grobs (SCM lines);
+  static std::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);
@@ -52,24 +52,24 @@ protected:
 
   void solve_rod_spring_problem (bool ragged, Real fixed_force);
   SCM find_system_offsets ();
-  void distribute_loose_lines (vector<Grob *> const &, vector<Real> const &, Real, Real);
+  void distribute_loose_lines (std::vector<Grob *> const &, std::vector<Real> const &, Real, Real);
 
-  static void build_system_skyline (vector<Grob *> const &, vector<Real> const &, Skyline *up, Skyline *down);
-  static vector<Grob *> filter_dead_elements (vector<Grob *> const &);
+  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 &);
 
   // This is a union (in spirit).
   // Either staves must be empty or prob must be null.
   typedef struct Element
   {
     Prob *prob;
-    vector<Grob *> staves;
-    vector<Real> min_offsets;
+    std::vector<Grob *> staves;
+    std::vector<Real> min_offsets;
     // Store the appropriate '*-*-spacing 'padding, and skyline-distance,
     //  considering indentation, from the previous system.
     Real min_distance;
     Real padding;
 
-    Element (vector<Grob *> const &a, vector<Real> const &o, Real m, Real p)
+    Element (std::vector<Grob *> const &a, std::vector<Real> const &o, Real m, Real p)
     {
       staves = a;
       min_offsets = o;
@@ -93,9 +93,9 @@ protected:
   static void alter_spring_from_spacing_spec (SCM spec, Spring *spring);
   static void mark_as_spaceable (Grob *);
 
-  vector<Spring> springs_;
-  vector<Element> elements_;
-  vector<Real> solution_;
+  std::vector<Spring> springs_;
+  std::vector<Element> elements_;
+  std::vector<Real> solution_;
   Real force_;
   Skyline bottom_skyline_;
   Real bottom_loose_baseline_;
diff --git a/lily/include/page-spacing-result.hh b/lily/include/page-spacing-result.hh
index ccba917b07..31c157141f 100644
--- a/lily/include/page-spacing-result.hh
+++ b/lily/include/page-spacing-result.hh
@@ -36,8 +36,8 @@ typedef enum
 
 struct Page_spacing_result
 {
-  vector<vsize> systems_per_page_;
-  vector<Real> force_;
+  std::vector<vsize> systems_per_page_;
+  std::vector<Real> force_;
   Real penalty_;
   Real demerits_;
   int system_count_status_;
diff --git a/lily/include/page-spacing.hh b/lily/include/page-spacing.hh
index 4775baf674..60b95530ba 100644
--- a/lily/include/page-spacing.hh
+++ b/lily/include/page-spacing.hh
@@ -50,7 +50,7 @@ const Real TERRIBLE_SPACING_PENALTY = 1e8;
 class Page_spacer
 {
 public:
-  Page_spacer (vector<Line_details> const &lines, vsize first_page_num, Page_breaking const *);
+  Page_spacer (std::vector<Line_details> const &lines, vsize first_page_num, Page_breaking const *);
   Page_spacing_result solve (vsize page_count);
   Page_spacing_result solve ();
 
@@ -77,14 +77,14 @@ private:
 
   Page_breaking const *breaker_;
   vsize first_page_num_;
-  vector<Line_details> lines_;
+  std::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_;
-  vector<Page_spacing_node> simple_state_;
+  std::vector<Page_spacing_node> simple_state_;
   vsize max_page_count_;
 
   bool ragged_;
diff --git a/lily/include/page-turn-page-breaking.hh b/lily/include/page-turn-page-breaking.hh
index 93fdaceada..061ef8a0bf 100644
--- a/lily/include/page-turn-page-breaking.hh
+++ b/lily/include/page-turn-page-breaking.hh
@@ -47,7 +47,7 @@ protected:
     vsize break_pos_; /* index into breaks_ */
 
     Line_division div_;
-    vector<vsize> system_count_; /* systems per page */
+    std::vector<vsize> system_count_; /* systems per page */
 
     Break_node ()
     {
@@ -59,7 +59,7 @@ protected:
     }
   };
 
-  vector<Break_node> state_;
+  std::vector<Break_node> state_;
 
   vsize total_page_count (Break_node const &b);
   Break_node put_systems_on_pages (vsize start,
@@ -67,8 +67,8 @@ protected:
                                    vsize configuration,
                                    vsize page_number);
 
-  SCM make_lines (vector<Break_node> *breaks);
-  SCM make_pages (vector<Break_node> const &breaks, SCM systems);
+  SCM make_lines (std::vector<Break_node> *breaks);
+  SCM make_pages (std::vector<Break_node> const &breaks, SCM systems);
 
   void calc_subproblem (vsize i);
   void print_break_node (Break_node const &b);
diff --git a/lily/include/pango-font.hh b/lily/include/pango-font.hh
index ff5e6302f0..58f5a884f5 100644
--- a/lily/include/pango-font.hh
+++ b/lily/include/pango-font.hh
@@ -46,11 +46,11 @@ public:
               Real);
   ~Pango_font ();
 
-  string description_string () const;
+  std::string description_string () const;
   SCM font_file_name () const;
-  void register_font_file (const string &filename, const string &ps_name, int face_index);
+  void register_font_file (const std::string &filename, const std::string &ps_name, int face_index);
 
-  size_t name_to_index (string) const;
+  size_t name_to_index (std::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;
@@ -59,7 +59,7 @@ public:
   Stencil pango_item_string_stencil (PangoGlyphItem const *) const;
 
   virtual Stencil text_stencil (Output_def *output_state,
-                                const string &text, bool music) const;
+                                const std::string &text, bool music) const;
   virtual void derived_mark () const;
 };
 
diff --git a/lily/include/paper-column-engraver.hh b/lily/include/paper-column-engraver.hh
index 1279ff17c9..9274988e05 100644
--- a/lily/include/paper-column-engraver.hh
+++ b/lily/include/paper-column-engraver.hh
@@ -50,12 +50,12 @@ protected:
   DECLARE_ACKNOWLEDGER (staff_spacing);
 
   System *system_;
-  vector<Stream_event *> break_events_;
-  vector<Stream_event *> label_events_;
+  std::vector<Stream_event *> break_events_;
+  std::vector<Stream_event *> label_events_;
   int breaks_;                  // used for stat printing
   Paper_column *command_column_;
   Paper_column *musical_column_;
-  vector<Item *> items_;
+  std::vector<Item *> items_;
   bool first_;
   bool made_columns_;
   Moment last_moment_;
diff --git a/lily/include/paper-outputter.hh b/lily/include/paper-outputter.hh
index cd1a5e2c92..33a5f0ec40 100644
--- a/lily/include/paper-outputter.hh
+++ b/lily/include/paper-outputter.hh
@@ -37,11 +37,11 @@ public:
   virtual ~Paper_outputter ();
 private:
   SCM output_module_;
-  string file_name_;
+  std::string file_name_;
   SCM file_;
 
 public:
-  Paper_outputter (SCM port, const string &format);
+  Paper_outputter (SCM port, const std::string &format);
 
   void close ();
   SCM dump_string (SCM);
diff --git a/lily/include/paper-score.hh b/lily/include/paper-score.hh
index 3d4d5840e1..3a73bad210 100644
--- a/lily/include/paper-score.hh
+++ b/lily/include/paper-score.hh
@@ -31,9 +31,9 @@ class Paper_score : public Music_output
   SCM systems_;
   SCM paper_systems_;
 
-  mutable vector<Grob *> cols_;
-  mutable vector<vsize> break_indices_;
-  mutable vector<vsize> break_ranks_;
+  mutable std::vector<Grob *> cols_;
+  mutable std::vector<vsize> break_indices_;
+  mutable std::vector<vsize> break_ranks_;
 public:
   Paper_score (Output_def *);
 
@@ -43,10 +43,10 @@ public:
   System *root_system () const;
 
   void typeset_system (System *);
-  vector<Column_x_positions> calc_breaking ();
-  vector<vsize> get_break_indices () const;
-  vector<vsize> get_break_ranks () const;
-  vector<Grob *> get_columns () const;
+  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;
   SCM get_paper_systems ();
 protected:
   void find_break_indices () const;
diff --git a/lily/include/performance.hh b/lily/include/performance.hh
index f9c53ff2e8..d70ff03385 100644
--- a/lily/include/performance.hh
+++ b/lily/include/performance.hh
@@ -39,14 +39,14 @@ public:
   void add_element (Audio_element *p);
   virtual void process ();
   void remap_grace_durations ();
-  void output (Midi_stream &midi_stream, const string &performance_name) const;
+  void output (Midi_stream &midi_stream, const std::string &performance_name) const;
   void output_header_track (Midi_stream &midi_stream) const;
 
   void print () const;
-  void write_output (string filename, const string &performance_name) const;
+  void write_output (std::string filename, const std::string &performance_name) const;
 
-  vector<Audio_staff *> audio_staffs_;
-  vector<Audio_element *> audio_elements_;
+  std::vector<Audio_staff *> audio_staffs_;
+  std::vector<Audio_element *> audio_elements_;
   Output_def *midi_;
   bool ports_;
   SCM header_;
diff --git a/lily/include/performer-group.hh b/lily/include/performer-group.hh
index 350af84de2..bc65491079 100644
--- a/lily/include/performer-group.hh
+++ b/lily/include/performer-group.hh
@@ -35,7 +35,7 @@ public:
   virtual void announce_element (Audio_element_info);
 
 protected:
-  vector<Audio_element_info> announce_infos_;
+  std::vector<Audio_element_info> announce_infos_;
   virtual void acknowledge_audio_elements ();
 };
 
diff --git a/lily/include/pitch.hh b/lily/include/pitch.hh
index daade82e81..8ba72b3701 100644
--- a/lily/include/pitch.hh
+++ b/lily/include/pitch.hh
@@ -72,7 +72,7 @@ public:
   int rounded_semitone_pitch () const;
   int rounded_quartertone_pitch () const;
   Pitch negated () const;
-  string to_string () const;
+  std::string to_string () const;
 
   DECLARE_SCHEME_CALLBACK (less_p, (SCM a, SCM b));
 };
diff --git a/lily/include/pointer-group-interface.hh b/lily/include/pointer-group-interface.hh
index 26ff640610..c457250181 100644
--- a/lily/include/pointer-group-interface.hh
+++ b/lily/include/pointer-group-interface.hh
@@ -36,8 +36,8 @@ public:
   static Grob *find_grob (Grob *, SCM, bool (*pred) (Grob *));
 };
 
-vector<Grob *> const &internal_extract_grob_array (Grob const *elt, SCM symbol);
-vector<Item *> internal_extract_item_array (Grob const *elt, SCM symbol);
+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);
 
 #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))
@@ -47,9 +47,9 @@ vector<Item *> internal_extract_item_array (Grob const *elt, SCM symbol);
   representation of grob sets again.
 */
 #define extract_grob_set(grob, prop, set)                               \
-  vector<Grob*> const &set (internal_extract_grob_array (grob, ly_symbol2scm (prop)))
+  std::vector<Grob*> const &set (internal_extract_grob_array (grob, ly_symbol2scm (prop)))
 #define extract_item_set(grob, prop, set)                               \
-  vector<Item*> set (internal_extract_item_array (grob, ly_symbol2scm (prop)))
+  std::vector<Item*> set (internal_extract_item_array (grob, ly_symbol2scm (prop)))
 
 #endif /* POINTER_GROUP_INTERFACE_HH */
 
diff --git a/lily/include/prob.hh b/lily/include/prob.hh
index 7a06e47737..bcdb125098 100644
--- a/lily/include/prob.hh
+++ b/lily/include/prob.hh
@@ -55,7 +55,7 @@ protected:
 public:
   Prob (SCM, SCM);
   Prob (Prob const &);
-  virtual string name () const;
+  virtual std::string name () const;
   SCM type () const { return type_; }
   SCM get_property_alist (bool _mutable) const;
   SCM internal_get_property (SCM sym) const;
diff --git a/lily/include/program-option.hh b/lily/include/program-option.hh
index acf1a93b5c..c5e8e1ca69 100644
--- a/lily/include/program-option.hh
+++ b/lily/include/program-option.hh
@@ -27,6 +27,6 @@ SCM ly_get_option (SCM);
 SCM ly_set_option (SCM, SCM);
 
 bool get_program_option (const char *);
-string get_output_backend_name ();
+std::string get_output_backend_name ();
 
 #endif /* SCM_OPTION_HH */
diff --git a/lily/include/relocate.hh b/lily/include/relocate.hh
index c531d97cfb..6f93d10491 100644
--- a/lily/include/relocate.hh
+++ b/lily/include/relocate.hh
@@ -22,11 +22,11 @@
 
 #include "std-string.hh"
 
-void read_relocation_dir (const string &dirname);
-void read_relocation_file (const string &filename);
-string expand_environment_variables (const string &orig);
+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);
 
-int sane_putenv (char const *key, const string &value, bool overwrite);
+int sane_putenv (char const *key, const std::string &value, bool overwrite);
 void setup_paths (char const *argv0);
 extern bool relocate_binary;
 
diff --git a/lily/include/rest.hh b/lily/include/rest.hh
index 644aa1450c..9235f746ce 100644
--- a/lily/include/rest.hh
+++ b/lily/include/rest.hh
@@ -29,7 +29,7 @@ class Rest
 public:
   DECLARE_SCHEME_CALLBACK (y_offset_callback, (SCM));
   DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
-  static string glyph_name (Grob *, int durlog, const string &style, bool, Real);
+  static std::string glyph_name (Grob *, int durlog, const std::string &style, bool, Real);
   static Real staff_position_internal (Grob *, int /* duration_log */,
                                        int /* dir */);
   static SCM brew_internal_stencil (Grob *, bool);
diff --git a/lily/include/scale.hh b/lily/include/scale.hh
index 19cd175c79..11e9837c2b 100644
--- a/lily/include/scale.hh
+++ b/lily/include/scale.hh
@@ -27,7 +27,7 @@
 struct Scale : public Smob<Scale>
 {
   virtual ~Scale ();
-  Scale (vector<Rational> const &);
+  Scale (std::vector<Rational> const &);
   Scale (Scale const &);
 
   Rational tones_at_step (int step, int octave) const;
@@ -37,7 +37,7 @@ struct Scale : public Smob<Scale>
 
 
 private:
-  vector<Rational> step_tones_;
+  std::vector<Rational> step_tones_;
 };
 
 extern Scale *default_global_scale;
diff --git a/lily/include/score-engraver.hh b/lily/include/score-engraver.hh
index 9b7927ddab..86bbad2500 100644
--- a/lily/include/score-engraver.hh
+++ b/lily/include/score-engraver.hh
@@ -26,7 +26,7 @@ class Score_engraver : public Engraver_group
 {
   System *system_;
 
-  vector<Grob *> elems_;
+  std::vector<Grob *> elems_;
   Paper_score *pscore_;
 
   void typeset_all ();
diff --git a/lily/include/score.hh b/lily/include/score.hh
index b3ece8960a..d1659a0622 100644
--- a/lily/include/score.hh
+++ b/lily/include/score.hh
@@ -40,7 +40,7 @@ private:
 public:
   Input *origin () const;
 
-  vector<Output_def *> defs_;
+  std::vector<Output_def *> defs_;
   bool error_found_;
 
   Score ();
diff --git a/lily/include/script-column.hh b/lily/include/script-column.hh
index fe4816eae1..a5942a9698 100644
--- a/lily/include/script-column.hh
+++ b/lily/include/script-column.hh
@@ -30,7 +30,7 @@ public:
   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 (vector<Grob *> grobs);
+  static void order_grobs (std::vector<Grob *> grobs);
 
 };
 
diff --git a/lily/include/separation-item.hh b/lily/include/separation-item.hh
index 81ea523fe2..bb365b2ff6 100644
--- a/lily/include/separation-item.hh
+++ b/lily/include/separation-item.hh
@@ -30,7 +30,7 @@ struct Separation_item
   DECLARE_SCHEME_CALLBACK (calc_skylines, (SCM));
   DECLARE_SCHEME_CALLBACK (print, (SCM));
 
-  static vector<Box> boxes (Grob *me, Grob *left);
+  static std::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);
diff --git a/lily/include/simple-spacer.hh b/lily/include/simple-spacer.hh
index d036dd191d..ca709a6133 100644
--- a/lily/include/simple-spacer.hh
+++ b/lily/include/simple-spacer.hh
@@ -36,7 +36,7 @@ public:
   Real range_ideal_len (int l, int r) const;
   Real range_stiffness (int l, int r, bool stretch) const;
   Real configuration_length (Real) const;
-  vector<Real> spring_positions () const;
+  std::vector<Real> spring_positions () const;
 
   void set_force (Real force);
   Real force () const;
@@ -49,7 +49,7 @@ private:
   Real compress_line ();
   Real rod_force (int l, int r, Real dist);
 
-  vector<Spring> springs_;
+  std::vector<Spring> springs_;
   Real line_len_;
   Real force_;
   bool ragged_;
@@ -57,12 +57,12 @@ private:
 };
 
 /* returns a vector of dimensions breaks.size () * breaks.size () */
-vector<Real> get_line_forces (vector<Grob *> const &columns,
+std::vector<Real> get_line_forces (std::vector<Grob *> const &columns,
                               Real line_len,
                               Real indent,
                               bool ragged);
 
-Column_x_positions get_line_configuration (vector<Grob *> const &columns,
+Column_x_positions get_line_configuration (std::vector<Grob *> const &columns,
                                            Real line_len,
                                            Real indent,
                                            bool ragged);
diff --git a/lily/include/skyline-pair.hh b/lily/include/skyline-pair.hh
index 6d7cea0ac2..a174204cd2 100644
--- a/lily/include/skyline-pair.hh
+++ b/lily/include/skyline-pair.hh
@@ -31,9 +31,9 @@ private:
 
 public:
   Skyline_pair ();
-  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 (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 (Box const &, Axis a);
 
   Real left () const;
diff --git a/lily/include/skyline.hh b/lily/include/skyline.hh
index 21693420c8..c8a8a14234 100644
--- a/lily/include/skyline.hh
+++ b/lily/include/skyline.hh
@@ -53,12 +53,12 @@ class Skyline : public Simple_smob<Skyline>
 public:
   static const char type_p_name_[];
 private:
-  list<Building> buildings_;
+  std::list<Building> buildings_;
   Direction sky_;
 
-  void internal_merge_skyline (list<Building> *, list<Building> *,
-                               list<Building> *result) const;
-  list<Building> internal_build_skyline (list<Building> *) const;
+  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;
   Real internal_distance (Skyline const &, Real horizon_padding, Real *touch_point) const;
   Real internal_distance (Skyline const &, Real *touch_point) const;
   void normalize ();
@@ -67,12 +67,12 @@ private:
 public:
   Skyline ();
   Skyline (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 (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 (Box const &b, Axis a, Direction sky);
 
-  vector<Offset> to_points (Axis) const;
+  std::vector<Offset> to_points (Axis) const;
   void merge (Skyline const &);
   void insert (Box const &, Axis);
   void print () const;
diff --git a/lily/include/slur-configuration.hh b/lily/include/slur-configuration.hh
index be30352676..c0ae07fd57 100644
--- a/lily/include/slur-configuration.hh
+++ b/lily/include/slur-configuration.hh
@@ -27,7 +27,7 @@
 class Slur_configuration
 {
   Real score_;
-  string score_card_;
+  std::string score_card_;
 
 public:
   Drul_array<Offset> attachment_;
@@ -50,11 +50,11 @@ public:
   Slur_configuration ();
 
   Real score () const { return score_; }
-  string card () const { return score_card_; }
-  void add_score (Real, const string&);
+  std::string card () const { return score_card_; }
+  void add_score (Real, const std::string&);
 
   void generate_curve (Slur_score_state const &state, Real r0, Real h_inf,
-                       vector<Offset> const &);
+                       std::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);
diff --git a/lily/include/slur-proto-engraver.hh b/lily/include/slur-proto-engraver.hh
index 5bae1647f1..b3e7c879f5 100644
--- a/lily/include/slur-proto-engraver.hh
+++ b/lily/include/slur-proto-engraver.hh
@@ -33,11 +33,11 @@ protected:
       event_name_ (event_name) {}
 
   // protected so that subclasses can see them
-  vector<Stream_event *> start_events_;
-  vector<Stream_event *> stop_events_;
-  vector<Grob *> slurs_;
-  vector<Grob *> end_slurs_;
-  vector<Grob_info> objects_to_acknowledge_;
+  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_;
   const char* double_property_name_;
   const char* grob_name_;
   const char* object_name_;
@@ -57,8 +57,8 @@ protected:
   void stop_translation_timestep ();
   void process_music ();
 
-  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 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 try_to_end (Stream_event *ev);
 
   virtual void set_melisma (bool);
diff --git a/lily/include/slur-scoring.hh b/lily/include/slur-scoring.hh
index 1ae187477b..d516993d55 100644
--- a/lily/include/slur-scoring.hh
+++ b/lily/include/slur-scoring.hh
@@ -90,15 +90,15 @@ struct Slur_score_state
   bool has_same_beam_;
 
   Real musical_dy_;
-  vector<Grob *> columns_;
-  vector<Encompass_info> encompass_infos_;
-  vector<Extra_collision_info> extra_encompass_infos_;
+  std::vector<Grob *> columns_;
+  std::vector<Encompass_info> encompass_infos_;
+  std::vector<Extra_collision_info> extra_encompass_infos_;
 
   Direction dir_;
   Slur_score_parameters parameters_;
   Drul_array<Bound_info> extremes_;
   Drul_array<Offset> base_attachments_;
-  vector<Slur_configuration *> configurations_;
+  std::vector<Slur_configuration *> configurations_;
   Real staff_space_;
   Real line_thickness_;
   Real thickness_;
@@ -111,14 +111,14 @@ struct Slur_score_state
   void fill (Grob *);
   Direction slur_direction () const;
 
-  vector<Offset> generate_avoid_offsets () const;
+  std::vector<Offset> generate_avoid_offsets () const;
   Drul_array<Bound_info> get_bound_info () const;
   void generate_curves () const;
-  vector<Slur_configuration *> enumerate_attachments (Drul_array<Real> end_ys) const;
+  std::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;
-  vector<Extra_collision_info> get_extra_encompass_infos () const;
+  std::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;
diff --git a/lily/include/slur.hh b/lily/include/slur.hh
index ae85ac24d3..7656ff26e1 100644
--- a/lily/include/slur.hh
+++ b/lily/include/slur.hh
@@ -30,7 +30,7 @@ public:
   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 &, vector<Grob *> &, vector<Grob *> &);
+  static void auxiliary_acknowledge_extra_object (Grob_info const &, std::vector<Grob *> &, std::vector<Grob *> &);
   DECLARE_SCHEME_CALLBACK (print, (SCM));
   DECLARE_SCHEME_CALLBACK (calc_control_points, (SCM));
   DECLARE_SCHEME_CALLBACK (calc_direction, (SCM));
diff --git a/lily/include/smobs.hh b/lily/include/smobs.hh
index 9ccaa61345..14ee09101c 100644
--- a/lily/include/smobs.hh
+++ b/lily/include/smobs.hh
@@ -120,7 +120,7 @@
     debugging purposes.  If the class does not define this function,
     the output will be #<Classname> when printing.
 
-  - a static const type_p_name_[] string set to something like
+  - a static const type_p_name_[] std::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.
 
@@ -150,7 +150,7 @@ class Smob_base
   static scm_t_bits smob_tag_;
   static Scm_init scm_init_;
   static void init (void);
-  static string smob_name_;
+  static std::string smob_name_;
 protected:
   static Super *unchecked_unsmob (SCM s)
   {
@@ -186,9 +186,9 @@ private:
   static void smob_proc_init (scm_t_bits) { };
 
   // type_p_name_ can be overriden in the Super class with a static
-  // const char [] string.  This requires both a declaration in the
+  // const char [] std::string.  This requires both a declaration in the
   // class as well as a single instantiation outside.  Using a
-  // template specialization for supplying a different string name
+  // template specialization for supplying a different std::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
@@ -330,7 +330,7 @@ public:
 extern bool parsed_objects_should_be_dead;
 class parsed_dead
 {
-  static vector<parsed_dead *> elements;
+  static std::vector<parsed_dead *> elements;
   SCM data;
   SCM readout_one ()
   {
diff --git a/lily/include/smobs.tcc b/lily/include/smobs.tcc
index b8dfc1f67f..dd815e59db 100644
--- a/lily/include/smobs.tcc
+++ b/lily/include/smobs.tcc
@@ -111,7 +111,7 @@ template <class Super>
 Scm_init Smob_base<Super>::scm_init_ (init);
 
 template <class Super>
-string Smob_base<Super>::smob_name_;
+std::string Smob_base<Super>::smob_name_;
 
 template <class Super>
 void Smob_base<Super>::init ()
@@ -142,7 +142,7 @@ void Smob_base<Super>::init ()
     {
       SCM subr = scm_c_define_gsubr (Super::type_p_name_, 1, 0, 0,
                                      (scm_t_subr) smob_p);
-      string fundoc = string("Is @var{x} a @code{") + smob_name_
+      std::string fundoc = std::string("Is @var{x} a @code{") + smob_name_
         + "} object?";
       ly_add_function_documentation (subr, Super::type_p_name_, "(SCM x)",
                                      fundoc);
diff --git a/lily/include/source-file.hh b/lily/include/source-file.hh
index 6686389289..46a5947cee 100644
--- a/lily/include/source-file.hh
+++ b/lily/include/source-file.hh
@@ -25,7 +25,6 @@
 #include "smobs.hh"
 
 #include <iostream>
-using namespace std;
 
 /**
    class for reading and mapping a file.
@@ -43,9 +42,9 @@ public:
   static const char type_p_name_[];
   virtual ~Source_file ();
 private:
-  vector<char const *> newline_locations_;
-  istream *istream_;
-  vector<char> characters_;
+  std::vector<char const *> newline_locations_;
+  std::istream *istream_;
+  std::vector<char> characters_;
   SCM str_port_;
 
   void load_stdin ();
@@ -53,30 +52,30 @@ private:
   void init ();
 
 public:
-  Source_file (const string &fn);
-  Source_file (const string&, const string&);
+  Source_file (const std::string &fn);
+  Source_file (const std::string&, const std::string&);
 
   char const *c_str () const;
-  virtual string quote_input (char const *pos_str0) const;
-  istream *get_istream ();
+  virtual std::string quote_input (char const *pos_str0) const;
+  std::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);
-  string name_string () const;
-  string file_line_column_string (char const *str0) const;
+  std::string name_string () const;
+  std::string file_line_column_string (char const *str0) const;
 
   Slice line_slice (char const *pos_str0) const;
-  string line_string (char const *pos_str0) const;
+  std::string line_string (char const *pos_str0) const;
   void get_counts (char const *pos_str0, int *, int *, int *, int *) const;
 
   SCM get_port () const;
-  string name_;
+  std::string name_;
 
 protected:
   int line_offset_;
 };
 
-vector<char> gulp_file (const string &fn, int desired);
+std::vector<char> gulp_file (const std::string &fn, int desired);
 
 #endif /* SOURCE_FILE_HH */
diff --git a/lily/include/sources.hh b/lily/include/sources.hh
index 2db87cee97..a4efd7886e 100644
--- a/lily/include/sources.hh
+++ b/lily/include/sources.hh
@@ -26,13 +26,13 @@
 class Sources
 {
   Sources (Sources const &);  // Do not define!  Not copyable!
-  vector<Source_file *> sourcefiles_;
+  std::vector<Source_file *> sourcefiles_;
 
 public:
   Sources ();
   ~Sources ();
 
-  Source_file *get_file (string file_name, string const &currentpath);
+  Source_file *get_file (std::string file_name, std::string const &currentpath);
   void add (Source_file *sourcefile);
   void set_path (File_path *);
 
diff --git a/lily/include/spacing-interface.hh b/lily/include/spacing-interface.hh
index ddfe2efb1c..03fb72bc72 100644
--- a/lily/include/spacing-interface.hh
+++ b/lily/include/spacing-interface.hh
@@ -25,8 +25,8 @@
 struct Spacing_interface
 {
   static Real minimum_distance (Grob *me, Grob *right_col);
-  static vector<Item *> right_note_columns (Grob *me);
-  static vector<Item *> left_note_columns (Grob *me);
+  static std::vector<Item *> right_note_columns (Grob *me);
+  static std::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);
diff --git a/lily/include/spacing-spanner.hh b/lily/include/spacing-spanner.hh
index fcfba90417..d24b6008ec 100644
--- a/lily/include/spacing-spanner.hh
+++ b/lily/include/spacing-spanner.hh
@@ -35,16 +35,16 @@ private:
                                      Paper_column *nextr,
                                      Spacing_options const *options);
   static Real default_bar_spacing (Grob *, Grob *, Grob *, Moment);
-  static Rational effective_shortest_duration (Grob *me, vector<Grob *> const &all);
+  static Rational effective_shortest_duration (Grob *me, std::vector<Grob *> const &all);
   static void breakable_column_spacing (Grob *, Item *l, Item *r, 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 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 musical_column_spacing (Grob *, Item *, Item *, Spacing_options const *);
   static bool fills_measure (Grob *, Item *, Item *);
 public:
-  static vector<Grob *> get_columns (Grob *me);
+  static std::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 *);
 
diff --git a/lily/include/spanner.hh b/lily/include/spanner.hh
index 79032dfb30..72b295232d 100644
--- a/lily/include/spanner.hh
+++ b/lily/include/spanner.hh
@@ -52,7 +52,7 @@ public:
   DECLARE_SCHEME_CALLBACK (bounds_width, (SCM));
   DECLARE_SCHEME_CALLBACK (kill_zero_spanned_time, (SCM));
 
-  vector<Spanner *> broken_intos_;
+  std::vector<Spanner *> broken_intos_;
 
   vsize get_break_index () const;
   Spanner *broken_neighbor (Direction d) const;
diff --git a/lily/include/spring.hh b/lily/include/spring.hh
index fd01ca048c..9c6c418279 100644
--- a/lily/include/spring.hh
+++ b/lily/include/spring.hh
@@ -65,6 +65,6 @@ public:
   bool operator > (Spring const &) const;
 };
 
-Spring merge_springs (vector<Spring> const &springs);
+Spring merge_springs (std::vector<Spring> const &springs);
 
 #endif /* SPRING_HH */
diff --git a/lily/include/staff-symbol.hh b/lily/include/staff-symbol.hh
index 9454ebe7f4..c86fb4ae31 100644
--- a/lily/include/staff-symbol.hh
+++ b/lily/include/staff-symbol.hh
@@ -33,8 +33,8 @@ public:
   static Real get_line_thickness (Grob *);
   static Real get_ledger_line_thickness (Grob *);
 
-  static vector<Real> line_positions (Grob *);
-  static vector<Real> ledger_positions (Grob *me, int pos);
+  static std::vector<Real> line_positions (Grob *);
+  static std::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 *);
diff --git a/lily/include/stem.hh b/lily/include/stem.hh
index 7c4612552a..ab325d427a 100644
--- a/lily/include/stem.hh
+++ b/lily/include/stem.hh
@@ -28,7 +28,7 @@
 class Stem
 {
 public:
-  static vector<int> note_head_positions (Grob *, bool filter = false);
+  static std::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);
diff --git a/lily/include/stencil.hh b/lily/include/stencil.hh
index 6ccb9252bb..543aafcc92 100644
--- a/lily/include/stencil.hh
+++ b/lily/include/stencil.hh
@@ -20,7 +20,6 @@
 #define STENCIL_HH
 
 #include <cstdlib>              // size_t
-using namespace std;
 
 #include "lily-proto.hh"
 #include "box.hh"
diff --git a/lily/include/system.hh b/lily/include/system.hh
index 4e402ffeca..387cbfd71e 100644
--- a/lily/include/system.hh
+++ b/lily/include/system.hh
@@ -44,10 +44,10 @@ public:
   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;
-  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);
+  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);
   vsize num_footnotes ();
   void do_break_substitution_and_fixup_refpoints ();
   void post_processing ();
@@ -73,10 +73,10 @@ public:
   int element_count () const;
   int spanner_count () const;
 
-  void break_into_pieces (vector<Column_x_positions> const &);
+  void break_into_pieces (std::vector<Column_x_positions> const &);
 
-  vector<Item *> broken_col_range (Item const *, Item const *) const;
-  vector<Grob *> used_columns () const;
+  std::vector<Item *> broken_col_range (Item const *, Item const *) const;
+  std::vector<Grob *> used_columns () const;
   Paper_column *column (vsize i) const;
 
   void add_column (Paper_column *);
diff --git a/lily/include/tie-configuration.hh b/lily/include/tie-configuration.hh
index aaf0746a4a..93f575ca52 100644
--- a/lily/include/tie-configuration.hh
+++ b/lily/include/tie-configuration.hh
@@ -28,7 +28,7 @@
 class Tie_configuration
 {
 #if DEBUG_SLUR_SCORING
-  string score_card_;
+  std::string score_card_;
 #endif
   Real score_;
   bool scored_;
@@ -36,7 +36,7 @@ class Tie_configuration
 
 public:
   Real score () const { return score_; }
-  string card () const { return score_card_; }
+  std::string card () const { return score_card_; }
 
   int position_;
   Direction dir_;
@@ -46,7 +46,7 @@ public:
   /* computed. */
   Interval attachment_x_;
 
-  void add_score (Real, const string&);
+  void add_score (Real, const std::string&);
   Tie_configuration ();
   void center_tie_vertically (Tie_details const &);
   Bezier get_transformed_bezier (Tie_details const &) const;
@@ -62,24 +62,24 @@ public:
 
 INSTANTIATE_COMPARE (Tie_configuration, Tie_configuration::compare);
 
-class Ties_configuration : public vector<Tie_configuration>
+class Ties_configuration : public std::vector<Tie_configuration>
 {
   Real score_;
-  string score_card_;
+  std::string score_card_;
   bool scored_;
-  vector<string> tie_score_cards_;
+  std::vector<std::string> tie_score_cards_;
 
   friend class Tie_formatting_problem;
 public:
   Ties_configuration ();
-  void add_score (Real amount, const string &description);
-  void add_tie_score (Real amount, int i, const string &description);
+  void add_score (Real amount, const std::string &description);
+  void add_tie_score (Real amount, int i, const std::string &description);
   Real score () const;
   void reset_score ();
-  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;
+  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;
 };
 
 #endif /* TIE_CONFIGURATION_HH */
diff --git a/lily/include/tie-formatting-problem.hh b/lily/include/tie-formatting-problem.hh
index 2d3ce617b4..14376a9ef0 100644
--- a/lily/include/tie-formatting-problem.hh
+++ b/lily/include/tie-formatting-problem.hh
@@ -30,20 +30,20 @@
 #include <map>
 #include <set>
 
-typedef map< Tuple<int, 4>, Tie_configuration *> Tie_configuration_map;
+typedef std::map< Tuple<int, 4>, Tie_configuration *> Tie_configuration_map;
 
 struct Tie_configuration_variation
 {
-  vector<pair<int, Tie_configuration *> > index_suggestion_pairs_;
+  std::vector<std::pair<int, Tie_configuration *> > index_suggestion_pairs_;
   void add_suggestion (int index, Tie_configuration *suggestion)
   {
-    index_suggestion_pairs_.push_back (make_pair (index, suggestion));
+    index_suggestion_pairs_.push_back (std::make_pair (index, suggestion));
   }
 };
 
-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;
+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;
 
 class Tie_formatting_problem
 {
@@ -52,9 +52,9 @@ class Tie_formatting_problem
   Column_extent_map head_extents_;
   Position_extent_map head_positions_;
 
-  set<int> dot_positions_;
+  std::set<int> dot_positions_;
   Interval dot_x_;
-  vector<Tie_specification> specifications_;
+  std::vector<Tie_specification> specifications_;
   bool use_horizontal_spacing_;
 
   Tie_configuration_map possibilities_;
@@ -65,9 +65,9 @@ class Tie_formatting_problem
   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;
 
-  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;
+  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;
 
   void score_configuration (Tie_configuration *) const;
   Real score_aptitude (Tie_configuration *, Tie_specification const &,
@@ -80,7 +80,7 @@ class Tie_formatting_problem
   Slice head_positions_slice (int) const;
   Ties_configuration generate_base_chord_configuration ();
   Ties_configuration find_best_variation (Ties_configuration const &base,
-                                          vector<Tie_configuration_variation> const &vars);
+                                          std::vector<Tie_configuration_variation> const &vars);
 
 public:
   Tie_details details_;
@@ -97,11 +97,11 @@ public:
   Ties_configuration generate_optimal_configuration ();
   Ties_configuration generate_ties_configuration (Ties_configuration const &);
 
-  void from_ties (vector<Grob *> const &ties);
+  void from_ties (std::vector<Grob *> const &ties);
   void from_tie (Grob *tie);
-  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 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 set_manual_tie_configuration (SCM);
   Interval get_attachment (Real, Drul_array<int>) const;
   Grob *common_x_refpoint () const;
diff --git a/lily/include/translator-dispatch-list.hh b/lily/include/translator-dispatch-list.hh
index 6c365d088e..29f7ff16c7 100644
--- a/lily/include/translator-dispatch-list.hh
+++ b/lily/include/translator-dispatch-list.hh
@@ -33,7 +33,7 @@ struct Engraver_dispatch_entry
 
 class Engraver_dispatch_list : public Simple_smob<Engraver_dispatch_list>
 {
-  vector<Engraver_dispatch_entry> dispatch_entries_;
+  std::vector<Engraver_dispatch_entry> dispatch_entries_;
 public:
   void apply (Grob_info);
   SCM static create (SCM trans_list,
diff --git a/lily/include/translator-group.hh b/lily/include/translator-group.hh
index d90c2929de..a2c6f8de2d 100644
--- a/lily/include/translator-group.hh
+++ b/lily/include/translator-group.hh
@@ -56,7 +56,7 @@ public:
   virtual ~Translator_group ();
 private:
   void precompute_method_bindings ();
-  vector<Translator_method_binding>
+  std::vector<Translator_method_binding>
   precomputed_method_bindings_[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
 
   Translator_group_void_method
diff --git a/lily/include/translator.hh b/lily/include/translator.hh
index 8154409efc..78a4691742 100644
--- a/lily/include/translator.hh
+++ b/lily/include/translator.hh
@@ -33,7 +33,7 @@
   NAME ();                                                              \
   VIRTUAL_COPY_CONSTRUCTOR (Translator, NAME);                          \
   static SCM static_description_;                                       \
-  static Drul_array<vector<Acknowledge_information> > acknowledge_static_array_drul_; \
+  static Drul_array<std::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;                          \
diff --git a/lily/include/translator.icc b/lily/include/translator.icc
index 7fc128fe72..827908901d 100644
--- a/lily/include/translator.icc
+++ b/lily/include/translator.icc
@@ -52,7 +52,7 @@
   /* end define */
 
 #define DEFINE_ACKNOWLEDGERS(classname) \
-  Drul_array< vector<Acknowledge_information> > classname::acknowledge_static_array_drul_;      \
+  Drul_array< std::vector<Acknowledge_information> > classname::acknowledge_static_array_drul_;      \
   Translator::Grob_info_callback                                        \
   classname::static_get_acknowledger (SCM sym)                          \
   {                                                                     \
@@ -107,11 +107,11 @@
 
 void add_acknowledger (Translator::Grob_info_callback ptr,
                        char const *func_name,
-                       vector<Acknowledge_information> *ack_array);
+                       std::vector<Acknowledge_information> *ack_array);
 
 Translator::Grob_info_callback
 generic_get_acknowledger (SCM sym,
-                          vector<Acknowledge_information> const *ack_array);
+                          std::vector<Acknowledge_information> const *ack_array);
 
 #define ADD_ACKNOWLEDGER(CLASS, NAME)                                   \
   void CLASS ## NAME ## _ack_adder ()                                   \
diff --git a/lily/include/tuplet-bracket.hh b/lily/include/tuplet-bracket.hh
index 1e41154fbf..c34a78c0a4 100644
--- a/lily/include/tuplet-bracket.hh
+++ b/lily/include/tuplet-bracket.hh
@@ -40,7 +40,7 @@ public:
   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, vector<Grob *> const &cols,
+  static Grob *parallel_beam (Grob *me, std::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,
diff --git a/lily/include/tuplet-number.hh b/lily/include/tuplet-number.hh
index 24ba77a377..82bb9a9110 100644
--- a/lily/include/tuplet-number.hh
+++ b/lily/include/tuplet-number.hh
@@ -33,7 +33,7 @@ struct Tuplet_number
 
   static Real calc_offset (Spanner *me, Axis a); // not used
 
-  static Grob *select_reference_stem (Grob *me, vector<Grob *> const &cols);
+  static Grob *select_reference_stem (Grob *me, std::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);
 };
diff --git a/lily/input.cc b/lily/input.cc
index 74b7a61b32..19f6ac019e 100644
--- a/lily/input.cc
+++ b/lily/input.cc
@@ -20,7 +20,6 @@
 #include "input.hh"
 
 #include <cstdio>
-using namespace std;
 
 #include "international.hh"
 #include "lily-imports.hh"
diff --git a/lily/keyword.cc b/lily/keyword.cc
index b5f7947ada..4eb7c83594 100644
--- a/lily/keyword.cc
+++ b/lily/keyword.cc
@@ -6,7 +6,6 @@
 
 #include <cstring>
 #include <cstdlib>
-using namespace std;
 
 /* for qsort */
 bool tab_less (Keyword_ent const &p1, Keyword_ent const &p2)
diff --git a/lily/ledger-line-spanner.cc b/lily/ledger-line-spanner.cc
index 7463f676e9..4849cdfee5 100644
--- a/lily/ledger-line-spanner.cc
+++ b/lily/ledger-line-spanner.cc
@@ -18,7 +18,6 @@
 */
 
 #include <map>
-using namespace std;
 
 #include "note-head.hh"
 #include "staff-symbol-referencer.hh"
@@ -132,7 +131,7 @@ Ledger_line_spanner::set_spacing_rods (SCM smob)
         continue;
 
       current_extents[vdir].unite (head_extent);
-      current_head_width = max (current_head_width, head_extent.length ());
+      current_head_width = std::max (current_head_width, head_extent.length ());
     }
 
   if (previous_column && current_column)
@@ -217,7 +216,7 @@ Ledger_line_spanner::print (SCM smob)
           reqs[rank][vdir].ledger_extent_.unite (ledger_extent);
           reqs[rank][vdir].head_extent_.unite (head_extent);
           reqs[rank][vdir].position_
-            = vdir * max (vdir * reqs[rank][vdir].position_, vdir * pos);
+            = vdir * std::max (vdir * reqs[rank][vdir].position_, vdir * pos);
         }
     }
 
@@ -252,7 +251,7 @@ Ledger_line_spanner::print (SCM smob)
                                                   - sign (i->second[d].position_)));
                   Real limit = (center + (both ? which * gap / 2 : 0));
                   lr.ledger_extent_.at (-which)
-                    = which * max (which * lr.ledger_extent_[-which], which * limit);
+                    = which * std::max (which * lr.ledger_extent_[-which], which * limit);
                 }
             }
         }
@@ -297,7 +296,7 @@ Ledger_line_spanner::print (SCM smob)
                                                               head_size[LEFT]),
                                             0.0);
 
-                    Real left_shorten = max (-ledger_size[LEFT] + d, 0.0);
+                    Real left_shorten = std::max (-ledger_size[LEFT] + d, 0.0);
 
                     x_extent[LEFT] += left_shorten;
                     /*
diff --git a/lily/lexer.ll b/lily/lexer.ll
index 870c466d16..82c1e9ac8b 100644
--- a/lily/lexer.ll
+++ b/lily/lexer.ll
@@ -51,7 +51,6 @@
 #define LEXER_CC
 
 #include <iostream>
-using namespace std;
 
 #include "context-def.hh"
 #include "duration.hh"
diff --git a/lily/lily-guile.cc b/lily/lily-guile.cc
index 5a54e864dd..3c033d70f5 100644
--- a/lily/lily-guile.cc
+++ b/lily/lily-guile.cc
@@ -25,7 +25,6 @@
 #include <cstring> /* strdup, strchr */
 #include <cctype>
 
-using namespace std;
 
 #include "dimensions.hh"
 #include "direction.hh"
diff --git a/lily/lily-lexer.cc b/lily/lily-lexer.cc
index c58885a895..7cfec596c8 100644
--- a/lily/lily-lexer.cc
+++ b/lily/lily-lexer.cc
@@ -21,7 +21,6 @@
 
 #include <cctype>
 #include <sstream>
-using namespace std;
 
 #include "context.hh" // for nested_property_alist
 #include "international.hh"
diff --git a/lily/line-interface.cc b/lily/line-interface.cc
index 0aeec91540..c12019ce01 100644
--- a/lily/line-interface.cc
+++ b/lily/line-interface.cc
@@ -124,9 +124,9 @@ Stencil
 Line_interface::make_dashed_line (Real thick, Offset from, Offset to,
                                   Real dash_period, Real dash_fraction)
 {
-  dash_fraction = min (max (dash_fraction, 0.0), 1.0);
+  dash_fraction = std::min (std::max (dash_fraction, 0.0), 1.0);
   Real on = dash_fraction * dash_period + thick;
-  Real off = max (0.0, dash_period - on);
+  Real off = std::max (0.0, dash_period - on);
 
   SCM at = scm_list_n (ly_symbol2scm ("dashed-line"),
                        scm_from_double (thick),
@@ -220,7 +220,7 @@ Line_interface::line (Grob *me, Offset from, Offset to)
           ? 0.0
           : robust_scm2double (me->get_property ("dash-fraction"), 0.4);
 
-      fraction = min (max (fraction, 0.0), 1.0);
+      fraction = std::min (std::max (fraction, 0.0), 1.0);
       Real period = Staff_symbol_referencer::staff_space (me)
                     * robust_scm2double (me->get_property ("dash-period"), 1.0);
 
@@ -230,7 +230,7 @@ Line_interface::line (Grob *me, Offset from, Offset to)
       Real len = (to - from).length ();
 
       int n = (int) rint ((len - period * fraction) / period);
-      n = max (0, n);
+      n = std::max (0, n);
       if (n > 0)
         {
           /*
diff --git a/lily/lookup.cc b/lily/lookup.cc
index 4e338caec9..dbf2a2ef89 100644
--- a/lily/lookup.cc
+++ b/lily/lookup.cc
@@ -23,7 +23,6 @@
 
 #include <cmath>
 #include <cctype>
-using namespace std;
 
 #include "line-interface.hh"
 #include "warn.hh"
@@ -170,9 +169,9 @@ Stencil
 Lookup::round_filled_box (Box b, Real blotdiameter)
 {
   Real width = b.x ().delta ();
-  blotdiameter = min (blotdiameter, width);
+  blotdiameter = std::min (blotdiameter, width);
   Real height = b.y ().delta ();
-  blotdiameter = min (blotdiameter, height);
+  blotdiameter = std::min (blotdiameter, height);
 
   if (blotdiameter < 0.0)
     {
@@ -589,7 +588,7 @@ Lookup::triangle (Interval iv, Real thick, Real protrude)
 {
   Box b;
   b[X_AXIS] = Interval (0, iv.length ());
-  b[Y_AXIS] = Interval (min (0., protrude), max (0.0, protrude));
+  b[Y_AXIS] = Interval (std::min (0., protrude), std::max (0.0, protrude));
 
   vector<Offset> points;
   points.push_back (Offset (iv[LEFT], 0));
diff --git a/lily/lyric-combine-music-iterator.cc b/lily/lyric-combine-music-iterator.cc
index 6e8c617ef4..38d9333684 100644
--- a/lily/lyric-combine-music-iterator.cc
+++ b/lily/lyric-combine-music-iterator.cc
@@ -103,7 +103,7 @@ Lyric_combine_music_iterator::set_busy (SCM se)
   if ((e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
       && music_context_)
 
-    busy_moment_ = max (music_context_->now_mom (),
+    busy_moment_ = std::max (music_context_->now_mom (),
                         busy_moment_);
 
 }
diff --git a/lily/lyric-extender.cc b/lily/lyric-extender.cc
index 8afe2c5569..bb841e4140 100644
--- a/lily/lyric-extender.cc
+++ b/lily/lyric-extender.cc
@@ -70,21 +70,21 @@ Lyric_extender::print (SCM smob)
   Real right_point
     = left_point + (robust_scm2double (minlen, 0));
 
-  right_point = min (right_point, me->get_system ()->get_bound (RIGHT)->relative_coordinate (common, X_AXIS));
+  right_point = std::min (right_point, me->get_system ()->get_bound (RIGHT)->relative_coordinate (common, X_AXIS));
 
   if (heads.size ())
-    right_point = max (right_point, heads.back ()->extent (common, X_AXIS)[RIGHT]);
+    right_point = std::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 = min (right_point, (robust_relative_extent (right_text, common, X_AXIS)[LEFT] - paddings[RIGHT]));
+    right_point = std::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 = max (right_point, (robust_relative_extent (me->get_bound (RIGHT), common, X_AXIS)[LEFT] - paddings[RIGHT]));
+    right_point = std::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;
diff --git a/lily/lyric-hyphen.cc b/lily/lyric-hyphen.cc
index 029391f92f..236e7e315a 100644
--- a/lily/lyric-hyphen.cc
+++ b/lily/lyric-hyphen.cc
@@ -81,7 +81,7 @@ Lyric_hyphen::print (SCM smob)
       && !bounds[RIGHT]->break_status_dir ())
     {
       Real minimum_length = robust_scm2double (me->get_property ("minimum-length"), .3);
-      dash_length = max ((l - 2 * padding), minimum_length);
+      dash_length = std::max ((l - 2 * padding), minimum_length);
     }
 
   Real space_left = l - dash_length - (n - 1) * dash_period;
@@ -94,7 +94,7 @@ Lyric_hyphen::print (SCM smob)
       && !bounds[RIGHT]->break_status_dir ())
     return SCM_EOL;
 
-  space_left = max (space_left, 0.0);
+  space_left = std::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));
diff --git a/lily/main.cc b/lily/main.cc
index 001dc3a882..1283bcfcc6 100644
--- a/lily/main.cc
+++ b/lily/main.cc
@@ -25,7 +25,6 @@
 #include <cstring>
 #include <cerrno>
 #include <cstdio>
-using namespace std;
 
 #include <unistd.h>
 #include <sys/types.h>
diff --git a/lily/mark-engraver.cc b/lily/mark-engraver.cc
index 7db0a781cc..51add1233e 100644
--- a/lily/mark-engraver.cc
+++ b/lily/mark-engraver.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "engraver.hh"
 
diff --git a/lily/metronome-engraver.cc b/lily/metronome-engraver.cc
index e1de3e23e0..f5bc107981 100644
--- a/lily/metronome-engraver.cc
+++ b/lily/metronome-engraver.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cctype>
-using namespace std;
 
 #include "engraver.hh"
 
diff --git a/lily/midi-item.cc b/lily/midi-item.cc
index a602edc6fe..542e2b0df2 100644
--- a/lily/midi-item.cc
+++ b/lily/midi-item.cc
@@ -195,7 +195,7 @@ Midi_time_signature::to_string () const
 Midi_note::Midi_note (Audio_note *a)
   : Midi_channel_item (a),
     audio_ (a),
-    dynamic_byte_ (min (max (Byte ((a->dynamic_ && a->dynamic_->volume_ >= 0
+    dynamic_byte_ (std::min (std::max (Byte ((a->dynamic_ && a->dynamic_->volume_ >= 0
                                     ? a->dynamic_->volume_ * 0x7f : 0x5a)
                                    + a->extra_velocity_),
                              Byte (0)), Byte (0x7f)))
diff --git a/lily/midi-stream.cc b/lily/midi-stream.cc
index 07e9e45e10..69db19590f 100644
--- a/lily/midi-stream.cc
+++ b/lily/midi-stream.cc
@@ -20,7 +20,6 @@
 #include "midi-stream.hh"
 
 #include <cerrno>
-using namespace std;
 
 #include "international.hh"
 #include "main.hh"
diff --git a/lily/misc.cc b/lily/misc.cc
index 7bb417bd62..77fbb21374 100644
--- a/lily/misc.cc
+++ b/lily/misc.cc
@@ -67,7 +67,7 @@ peak_around (Real epsilon, Real threshold, Real x)
 {
   if (x < 0)
     return 1.0;
-  return max (- epsilon * (x - threshold) / ((x + epsilon) * threshold), 0.0);
+  return std::max (- epsilon * (x - threshold) / ((x + epsilon) * threshold), 0.0);
 }
 
 /*
diff --git a/lily/modified-font-metric.cc b/lily/modified-font-metric.cc
index 2256eb9d18..b746fdaa68 100644
--- a/lily/modified-font-metric.cc
+++ b/lily/modified-font-metric.cc
@@ -17,7 +17,6 @@
   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"
diff --git a/lily/multi-measure-rest.cc b/lily/multi-measure-rest.cc
index 7f2a720d6f..056989a60e 100644
--- a/lily/multi-measure-rest.cc
+++ b/lily/multi-measure-rest.cc
@@ -80,7 +80,7 @@ Multi_measure_rest::percent (SCM smob)
     we gotta stay clear of sp_iv, so move a bit to the right if
     needed.
   */
-  x_off += max (sp_iv[LEFT] - rx, 0.0);
+  x_off += std::max (sp_iv[LEFT] - rx, 0.0);
 
   /*
     center between stuff.
@@ -107,7 +107,7 @@ Multi_measure_rest::print (SCM smob)
     we gotta stay clear of sp_iv, so move a bit to the right if
     needed.
   */
-  Real x_off = max (sp_iv[LEFT] - rx, 0.0);
+  Real x_off = std::max (sp_iv[LEFT] - rx, 0.0);
 
   Stencil mol;
   mol.add_stencil (symbol_stencil (me, space));
@@ -251,9 +251,9 @@ Multi_measure_rest::big_rest (Grob *me, Real width)
   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, max (0.0, (width - 2 * ythick))), Interval (-y, y));
+  Box b (Interval (0.0, std::max (0.0, (width - 2 * ythick))), Interval (-y, y));
 
-  Real blot = width ? (.8 * min (y, ythick)) : 0.0;
+  Real blot = width ? (.8 * std::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);
@@ -392,7 +392,7 @@ Multi_measure_rest::calculate_spacing_rods (Grob *me, Real length)
       rod.item_drul_[LEFT] = li;
       rod.item_drul_[RIGHT] = ri;
 
-      rod.distance_ = max (Paper_column::minimum_distance (li, ri) + length,
+      rod.distance_ = std::max (Paper_column::minimum_distance (li, ri) + length,
                            minlen);
       rod.add_to_cols ();
     }
diff --git a/lily/music-iterator.cc b/lily/music-iterator.cc
index b89e92c28e..f1ef8d6488 100644
--- a/lily/music-iterator.cc
+++ b/lily/music-iterator.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cstdio>
-using namespace std;
 
 #include "warn.hh"
 #include "music.hh"
diff --git a/lily/music-sequence.cc b/lily/music-sequence.cc
index d280953714..33a035d8a3 100644
--- a/lily/music-sequence.cc
+++ b/lily/music-sequence.cc
@@ -66,7 +66,7 @@ Music_sequence::maximum_length (SCM l)
       else
         {
           Moment l = m->get_length ();
-          dur = max (dur, l);
+          dur = std::max (dur, l);
         }
     }
 
@@ -153,7 +153,7 @@ Music_sequence::minimum_start (SCM l)
   Moment m;
 
   for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
-    m = min (m, unsmob<Music> (scm_car (s))->start_mom ());
+    m = std::min (m, unsmob<Music> (scm_car (s))->start_mom ());
   return m;
 }
 
diff --git a/lily/new-fingering-engraver.cc b/lily/new-fingering-engraver.cc
index e0b0d09809..f75ccd69dc 100644
--- a/lily/new-fingering-engraver.cc
+++ b/lily/new-fingering-engraver.cc
@@ -230,7 +230,7 @@ New_fingering_engraver::position_scripts (SCM orientations,
         }
     }
 
-  vector_sort (*scripts, less<Finger_tuple> ());
+  vector_sort (*scripts, std::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));
diff --git a/lily/note-collision.cc b/lily/note-collision.cc
index 4d1303b739..18e8e00dba 100644
--- a/lily/note-collision.cc
+++ b/lily/note-collision.cc
@@ -524,11 +524,11 @@ Note_collision_interface::automatic_shift (Grob *me,
 
               // check if we cross the opposite-stemmed voices
               if (d * extents[d][i][-d] < d * extent_union[-d][d])
-                offset = max (offset, 0.5);
+                offset = std::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 = max (offset, 1.0);
+                offset = std::max (offset, 1.0);
             }
           offsets[d].push_back (d * offset);
         }
@@ -595,7 +595,7 @@ Note_collision_interface::note_head_positions (Grob *me)
         out.insert (out.end (), nhp.begin (), nhp.end ());
       }
 
-  vector_sort (out, less<int> ());
+  vector_sort (out, std::less<int> ());
   return out;
 }
 
diff --git a/lily/note-column.cc b/lily/note-column.cc
index 1d79fee652..87396b5a13 100644
--- a/lily/note-column.cc
+++ b/lily/note-column.cc
@@ -20,7 +20,6 @@
 #include "note-column.hh"
 
 #include <cmath>                // ceil
-using namespace std;
 
 #include "accidental-placement.hh"
 #include "axis-group-interface.hh"
diff --git a/lily/note-head.cc b/lily/note-head.cc
index dda8e040b9..af516bef2b 100644
--- a/lily/note-head.cc
+++ b/lily/note-head.cc
@@ -23,7 +23,6 @@
 #include <cctype>
 #include <algorithm>            //  min, max
 
-using namespace std;
 
 #include "directional-element-interface.hh"
 #include "font-interface.hh"
@@ -40,7 +39,7 @@ internal_print (Grob *me, string *font_char)
 {
   string style = robust_symbol2string (me->get_property ("style"), "default");
 
-  string suffix = ::to_string (min (robust_scm2int (me->get_property ("duration-log"), 2), 2));
+  string suffix = ::to_string (std::min (robust_scm2int (me->get_property ("duration-log"), 2), 2));
   if (style != "default")
     suffix = robust_scm2string (me->get_property ("glyph-name"), "");
 
@@ -146,8 +145,8 @@ Note_head::include_ledger_line_height (SCM smob)
       // 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 (min (0.0, lines[UP] - my_ext[DOWN] + 1),
-                   max (0.0, lines[DOWN] - my_ext[UP] - 1));
+      Interval iv (std::min (0.0, lines[UP] - my_ext[DOWN] + 1),
+                   std::max (0.0, lines[DOWN] - my_ext[UP] - 1));
       return ly_interval2scm (iv);
     }
 
diff --git a/lily/note-heads-engraver.cc b/lily/note-heads-engraver.cc
index 20036d021f..9c12fc78b2 100644
--- a/lily/note-heads-engraver.cc
+++ b/lily/note-heads-engraver.cc
@@ -20,7 +20,6 @@
 #include "engraver.hh"
 
 #include <cctype>
-using namespace std;
 
 #include "duration.hh"
 #include "item.hh"
diff --git a/lily/note-spacing.cc b/lily/note-spacing.cc
index eab3651520..63a3587475 100644
--- a/lily/note-spacing.cc
+++ b/lily/note-spacing.cc
@@ -78,7 +78,7 @@ Note_spacing::get_spacing (Grob *me, Item *right_col,
   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 = max (0.0, distance);
+  Real min_dist = std::max (0.0, distance);
   base.set_min_distance (min_dist);
 
   /* If we have a NonMusical column on the right, we measure the ideal distance
@@ -99,13 +99,13 @@ Note_spacing::get_spacing (Grob *me, Item *right_col,
              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 = max (ideal, min_desired_space);
+          ideal = std::max (ideal, min_desired_space);
         }
     }
 
   stem_dir_correction (me, right_col, increment, &ideal);
 
-  base.set_distance (max (0.0, ideal));
+  base.set_distance (std::max (0.0, ideal));
   return base;
 }
 
@@ -147,7 +147,7 @@ different_directions_correction (Grob *note_spacing,
       /*
         Ugh. 7 is hardcoded.
       */
-      ret = min (ret / 7, 1.0)
+      ret = std::min (ret / 7, 1.0)
             * left_stem_dir
             * robust_scm2double (note_spacing->get_property ("stem-spacing-correction"), 0);
     }
diff --git a/lily/one-line-page-breaking.cc b/lily/one-line-page-breaking.cc
index 9110cdad96..a96b37fc00 100644
--- a/lily/one-line-page-breaking.cc
+++ b/lily/one-line-page-breaking.cc
@@ -60,7 +60,7 @@ One_line_page_breaking::solve ()
           vector<Grob *> cols = ps->root_system ()->used_columns ();
 
           // No indent, "infinite" line width, ragged.
-          Column_x_positions pos = get_line_configuration (cols, numeric_limits<Real>::max (), 0, true);
+          Column_x_positions pos = get_line_configuration (cols, std::numeric_limits<Real>::max (), 0, true);
           vector<Column_x_positions> positions;
           positions.push_back (pos);
 
@@ -73,7 +73,7 @@ One_line_page_breaking::solve ()
           SCM systems = scm_list_1 (system->self_scm ());
           SCM pages = make_pages (lines_per_page, systems);
 
-          max_width = max (max_width, system->extent (system, X_AXIS).length ());
+          max_width = std::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_)
diff --git a/lily/open-type-font.cc b/lily/open-type-font.cc
index 8a7bdf7221..b200b1188d 100644
--- a/lily/open-type-font.cc
+++ b/lily/open-type-font.cc
@@ -22,7 +22,6 @@
 
 #include <cstdio>
 
-using namespace std;
 
 #include FT_TRUETYPE_TABLES_H
 
diff --git a/lily/ottava-bracket.cc b/lily/ottava-bracket.cc
index 63a9d3ebca..9116f19f04 100644
--- a/lily/ottava-bracket.cc
+++ b/lily/ottava-bracket.cc
@@ -129,7 +129,7 @@ Ottava_bracket::print (SCM smob)
                    ? 0.0 : text.extent (X_AXIS)[RIGHT] + 0.3;
 
   span_points[LEFT]
-    = min (span_points[LEFT],
+    = std::min (span_points[LEFT],
            (span_points[RIGHT] - text_size
             - robust_scm2double (me->get_property ("minimum-length"), -1.0)));
 
diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc
index 20ae15271a..94a76f9a19 100644
--- a/lily/page-breaking.cc
+++ b/lily/page-breaking.cc
@@ -251,9 +251,9 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break, Prob_bre
   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_ = 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));
+  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));
   orphan_penalty_ = robust_scm2int (pb->paper_->c_variable ("orphan-penalty"), 100000);
 
   Stencil footnote_separator = Page_layout_problem::get_footnote_separator_stencil (pb->paper_);
@@ -927,7 +927,7 @@ Page_breaking::set_current_breakpoints (vsize start,
 
           dems_and_indices.push_back (pair<Real, vsize> (dem, i));
         }
-      vector_sort (dems_and_indices, less<pair<Real, vsize> > ());
+      vector_sort (dems_and_indices, std::less<pair<Real, vsize> > ());
 
       vector<Line_division> best_5_configurations;
       for (vsize i = 0; i < 5; i++)
@@ -1031,9 +1031,9 @@ Page_breaking::line_divisions_rec (vsize system_count,
       others_min += min_sys[i];
       others_max += max_sys[i];
     }
-  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);
+  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);
 
   if (real_min > real_max || real_min < 0)
     {
@@ -1073,7 +1073,7 @@ Page_breaking::compute_line_heights ()
       Real a = shape.begin_[UP];
       Real b = shape.rest_[UP];
       bool title = cur.title_;
-      Real refpoint_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b);
+      Real refpoint_hanging = std::max (prev_hanging_begin + a, prev_hanging_rest + b);
 
       if (i > 0)
         {
@@ -1086,14 +1086,14 @@ Page_breaking::compute_line_heights ()
           Real min_dist = title
                           ? prev.title_min_distance_
                           : prev.min_distance_;
-          refpoint_hanging = max (refpoint_hanging + padding,
+          refpoint_hanging = std::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 = max (hanging_begin, hanging_rest);
+      Real hanging = std::max (hanging_begin, hanging_rest);
       cur.tallness_ = hanging - prev_hanging;
       prev_hanging = hanging;
       prev_hanging_begin = hanging_begin;
@@ -1449,7 +1449,7 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result
     {
       Real f = res.force_[i];
 
-      page_demerits += min (f * f, BAD_SPACING_PENALTY);
+      page_demerits += std::min (f * f, BAD_SPACING_PENALTY);
     }
 
   /* for a while we tried averaging page and line forces across pages instead
@@ -1483,7 +1483,7 @@ Page_breaking::space_systems_on_1_page (vector<Line_details> const &lines, Real
     }
 
   ret.systems_per_page_.push_back (lines.size ());
-  ret.force_.push_back (ragged ? min (space.force_, 0.0) : space.force_);
+  ret.force_.push_back (ragged ? std::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);
 
@@ -1657,8 +1657,8 @@ Page_breaking::min_whitespace_at_top_of_page (Line_details const &line) const
                                           ly_symbol2scm ("padding"));
 
   // FIXME: take into account the height of the header
-  Real translate = max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
-  return max (0.0, max (padding, min_distance - translate));
+  Real translate = std::max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
+  return std::max (0.0, std::max (padding, min_distance - translate));
 }
 
 Real
@@ -1676,8 +1676,8 @@ Page_breaking::min_whitespace_at_bottom_of_page (Line_details const &line) const
                                           ly_symbol2scm ("padding"));
 
   // FIXME: take into account the height of the footer
-  Real translate = min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);
-  return max (0.0, max (padding, min_distance + translate));
+  Real translate = std::min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);
+  return std::max (0.0, std::max (padding, min_distance + translate));
 }
 
 int
diff --git a/lily/page-layout-problem.cc b/lily/page-layout-problem.cc
index b0ef9ab36d..ebe147d59e 100644
--- a/lily/page-layout-problem.cc
+++ b/lily/page-layout-problem.cc
@@ -189,7 +189,7 @@ Page_layout_problem::add_footnotes_to_lines (SCM lines, int counter, Paper_book
       numbers = scm_cons (stencil, numbers);
 
       if (!st->extent (X_AXIS).is_empty ())
-        max_length = max (max_length, st->extent (X_AXIS)[RIGHT]);
+        max_length = std::max (max_length, st->extent (X_AXIS)[RIGHT]);
 
       counter++;
     }
@@ -665,7 +665,7 @@ Page_layout_problem::append_prob (Prob *prob, Spring const &spring, Real padding
 
   if (sky)
     {
-      minimum_distance = max ((*sky)[UP].distance (bottom_skyline_),
+      minimum_distance = std::max ((*sky)[UP].distance (bottom_skyline_),
                               bottom_loose_baseline_);
       bottom_skyline_ = (*sky)[DOWN];
     }
@@ -1126,7 +1126,7 @@ Page_layout_problem::get_fixed_spacing (Grob *before, Grob *after, int spaceable
         {
           SCM forced = robust_list_ref (spaceable_index - 1, manual_dists);
           if (scm_is_number (forced))
-            ret = max (ret, scm_to_double (forced));
+            ret = std::max (ret, scm_to_double (forced));
         }
     }
 
diff --git a/lily/page-spacing.cc b/lily/page-spacing.cc
index ce9aabedac..f9cb9540d1 100644
--- a/lily/page-spacing.cc
+++ b/lily/page-spacing.cc
@@ -37,7 +37,7 @@ Page_spacing::calc_force ()
     force_ = -infinity_f;
   else
     force_ = (height - rod_height_ - last_line_.bottom_padding_ - spring_len_)
-             / max (0.1, inverse_spring_k_);
+             / std::max (0.1, inverse_spring_k_);
 }
 
 void
@@ -356,7 +356,7 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
           // 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 = min (demerits, BAD_SPACING_PENALTY);
+          demerits = std::min (demerits, BAD_SPACING_PENALTY);
           demerits += (prev ? prev->demerits_ : 0);
 
           Real penalty = breaker_->line_count_penalty (line_count);
diff --git a/lily/page-turn-engraver.cc b/lily/page-turn-engraver.cc
index 82b33aadfb..874ebe7e7e 100644
--- a/lily/page-turn-engraver.cc
+++ b/lily/page-turn-engraver.cc
@@ -64,7 +64,7 @@ public:
         return ret;
       }
 
-    Real new_pen = max (penalty_, penalty.penalty_);
+    Real new_pen = std::max (penalty_, penalty.penalty_);
 
     if (duration_[LEFT] < penalty.duration_[LEFT])
       ret.push_back (Page_turn_event (duration_[LEFT], penalty.duration_[LEFT], permission_, penalty_));
@@ -121,8 +121,8 @@ Page_turn_engraver::Page_turn_engraver ()
 Grob *
 Page_turn_engraver::breakable_column (Page_turn_event const &brk)
 {
-  vsize start = lower_bound (breakable_moments_, brk.duration_[LEFT], less<Rational> ());
-  vsize end = upper_bound (breakable_moments_, brk.duration_[RIGHT], less<Rational> ());
+  vsize start = lower_bound (breakable_moments_, brk.duration_[LEFT], std::less<Rational> ());
+  vsize end = upper_bound (breakable_moments_, brk.duration_[RIGHT], std::less<Rational> ());
 
   if (start == breakable_moments_.size ())
     return NULL;
@@ -323,7 +323,7 @@ Page_turn_engraver::finalize ()
       if (pc)
         {
           SCM perm = max_permission (pc->get_property ("page-turn-permission"), brk.permission_);
-          Real pen = min (robust_scm2double (pc->get_property ("page-turn-penalty"), infinity_f), brk.penalty_);
+          Real pen = std::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));
         }
diff --git a/lily/page-turn-page-breaking.cc b/lily/page-turn-page-breaking.cc
index 85a090f6ea..daa060c939 100644
--- a/lily/page-turn-page-breaking.cc
+++ b/lily/page-turn-page-breaking.cc
@@ -173,7 +173,7 @@ Page_turn_page_breaking::calc_subproblem (vsize ending_breakpoint)
 
       /* heuristic: we've just added a breakpoint, we'll need at least as
          many systems as before */
-      min_sys_count = max (min_sys_count, prev_best_system_count);
+      min_sys_count = std::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);
diff --git a/lily/paper-column.cc b/lily/paper-column.cc
index c5f6cc5b95..692a28f9d9 100644
--- a/lily/paper-column.cc
+++ b/lily/paper-column.cc
@@ -179,7 +179,7 @@ Paper_column::minimum_distance (Grob *left, Grob *right)
 
   skys[RIGHT].merge (Separation_item::conditional_skyline (right, left));
 
-  return max (0.0, skys[LEFT].distance (skys[RIGHT]));
+  return std::max (0.0, skys[LEFT].distance (skys[RIGHT]));
 }
 
 Interval
diff --git a/lily/paper-outputter.cc b/lily/paper-outputter.cc
index 87f14570e2..943c3561f4 100644
--- a/lily/paper-outputter.cc
+++ b/lily/paper-outputter.cc
@@ -23,7 +23,6 @@
 #include <cmath>
 #include <ctime>
 
-using namespace std;
 
 #include "dimensions.hh"
 #include "file-name.hh"
diff --git a/lily/parse-scm.cc b/lily/parse-scm.cc
index 576591dc97..72ddff3632 100644
--- a/lily/parse-scm.cc
+++ b/lily/parse-scm.cc
@@ -20,7 +20,6 @@
 #include "parse-scm.hh"
 
 #include <cstdio>
-using namespace std;
 
 #include "lily-parser.hh"
 #include "lily-lexer.hh"
diff --git a/lily/parser.yy b/lily/parser.yy
index cadcd89869..a166aee8e5 100644
--- a/lily/parser.yy
+++ b/lily/parser.yy
@@ -116,7 +116,6 @@ FIXME:
 #include <cctype>
 #include <cstdlib>
 #include <cstdio>
-using namespace std;
 
 #include "book.hh"
 #include "context-def.hh"
diff --git a/lily/part-combine-iterator.cc b/lily/part-combine-iterator.cc
index f742d75a73..d7d159bed0 100644
--- a/lily/part-combine-iterator.cc
+++ b/lily/part-combine-iterator.cc
@@ -99,7 +99,7 @@ Part_combine_iterator::pending_moment () const
 
   for (size_t i = 0; i < NUM_PARTS; i++)
     if (iterators_[i]->ok ())
-      p = min (p, iterators_[i]->pending_moment ());
+      p = std::min (p, iterators_[i]->pending_moment ());
 
   return p;
 }
diff --git a/lily/pdf-scheme.cc b/lily/pdf-scheme.cc
index da2ce2cef3..79cc21a5d5 100644
--- a/lily/pdf-scheme.cc
+++ b/lily/pdf-scheme.cc
@@ -18,7 +18,6 @@
 */
 
 #include <glib.h>
-using namespace std;
 
 #include "international.hh"
 #include "warn.hh"
diff --git a/lily/performance.cc b/lily/performance.cc
index 3024ea69af..af083021ce 100644
--- a/lily/performance.cc
+++ b/lily/performance.cc
@@ -20,7 +20,6 @@
 #include "performance.hh"
 
 #include <ctime>
-using namespace std;
 
 #include "audio-column.hh"
 #include "audio-item.hh"
@@ -82,7 +81,7 @@ Performance::output (Midi_stream &midi_stream,
   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 = min (start_mom, item->audio_column_->when ());
+      start_mom = std::min (start_mom, item->audio_column_->when ());
 
   for (vsize i = 0; i < audio_staffs_.size (); i++)
     {
diff --git a/lily/pfb.cc b/lily/pfb.cc
index c971024548..f62cea6d2a 100644
--- a/lily/pfb.cc
+++ b/lily/pfb.cc
@@ -20,7 +20,6 @@
 #include <cstdlib>
 #include <cstdio>
 #include <cstring>
-using namespace std;
 
 #include "program-option.hh"
 #include "source-file.hh"
diff --git a/lily/program-option-scheme.cc b/lily/program-option-scheme.cc
index b7003c085c..405e5d17c2 100644
--- a/lily/program-option-scheme.cc
+++ b/lily/program-option-scheme.cc
@@ -21,7 +21,6 @@
 
 #include <cstdio>
 #include <cstring>
-using namespace std;
 
 #include "profile.hh"
 #include "international.hh"
@@ -172,7 +171,7 @@ get_help_string ()
     }
 
   string help ("Options supported by `ly:set-option':\n\n");
-  vector_sort (opts, less<string> ());
+  vector_sort (opts, std::less<string> ());
   for (vsize i = 0; i < opts.size (); i++)
     help += opts[i];
   return help;
diff --git a/lily/quote-iterator.cc b/lily/quote-iterator.cc
index c433625011..f222e5a8e4 100644
--- a/lily/quote-iterator.cc
+++ b/lily/quote-iterator.cc
@@ -178,14 +178,14 @@ Quote_iterator::pending_moment () const
   Moment m (infty);
 
   if (Music_wrapper_iterator::ok ())
-    m = min (m, Music_wrapper_iterator::pending_moment ());
+    m = std::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 = min (m, vector_moment (event_idx_) - start_moment_);
+    m = std::min (m, vector_moment (event_idx_) - start_moment_);
 
   return m;
 }
diff --git a/lily/rest-collision.cc b/lily/rest-collision.cc
index 8425e6eee2..1abd13646c 100644
--- a/lily/rest-collision.cc
+++ b/lily/rest-collision.cc
@@ -20,7 +20,6 @@
 #include "rest-collision.hh"
 
 #include <cmath>                // ceil.
-using namespace std;
 
 #include "directional-element-interface.hh"
 #include "duration.hh"
@@ -256,7 +255,7 @@ Rest_collision::calc_positioning_done (SCM smob)
                 notedim.unite (notes[i]->extent (common, Y_AXIS));
             }
 
-          Real y = dir * max (0.0,
+          Real y = dir * std::max (0.0,
                               -dir * restdim[-dir] + dir * notedim[dir] + minimum_dist);
 
           // move discretely by half spaces.
diff --git a/lily/scm-hash.cc b/lily/scm-hash.cc
index 08419d83dd..b56c400556 100644
--- a/lily/scm-hash.cc
+++ b/lily/scm-hash.cc
@@ -21,7 +21,6 @@
 
 #include <cstdio>
 #include <algorithm>
-using namespace std;
 
 
 /*
diff --git a/lily/score.cc b/lily/score.cc
index da48e8f103..102a549cc4 100644
--- a/lily/score.cc
+++ b/lily/score.cc
@@ -21,7 +21,6 @@
 
 #include <cstdio>
 
-using namespace std;
 
 #include "book.hh"
 #include "cpu-timer.hh"
diff --git a/lily/separation-item.cc b/lily/separation-item.cc
index 632f6bcccf..20fc2c564a 100644
--- a/lily/separation-item.cc
+++ b/lily/separation-item.cc
@@ -64,7 +64,7 @@ Separation_item::set_distance (Item *l, Item *r, Real padding)
       rod.add_to_cols ();
     }
 
-  return max (dist, 0.0);
+  return std::max (dist, 0.0);
 }
 
 bool
diff --git a/lily/side-position-interface.cc b/lily/side-position-interface.cc
index efb182092f..2e4591153a 100644
--- a/lily/side-position-interface.cc
+++ b/lily/side-position-interface.cc
@@ -24,7 +24,6 @@
 #include <set>
 #include <map>
 
-using namespace std;
 
 #include "accidental-interface.hh"
 #include "accidental-placement.hh"
@@ -348,7 +347,7 @@ Side_position_interface::aligned_side (Grob *me, Axis a, bool pure, int start, i
     total_off = minimum_space * dir;
 
   if (current_off)
-    total_off = dir * max (dir * total_off,
+    total_off = dir * std::max (dir * total_off,
                            dir * (*current_off));
 
   /* FIXME: 1000 should relate to paper size.  */
@@ -407,7 +406,7 @@ Side_position_interface::aligned_side (Grob *me, Axis a, bool pure, int start, i
           Real diff = (dir * staff_extent[dir] + staff_padding
                        - dir * total_off
                        + dir * (staff_position - parent_position));
-          total_off += dir * max (diff, 0.0);
+          total_off += dir * std::max (diff, 0.0);
         }
     }
   return scm_from_double (total_off);
diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc
index 5b8183d96a..5244d33c9e 100644
--- a/lily/simple-spacer.cc
+++ b/lily/simple-spacer.cc
@@ -127,9 +127,9 @@ Simple_spacer::add_rod (int l, int r, Real dist)
 
       return;
     }
-  force_ = max (force_, block_force);
+  force_ = std::max (force_, block_force);
   for (int i = l; i < r; i++)
-    springs_[i].set_blocking_force (max (block_force, springs_[i].blocking_force ()));
+    springs_[i].set_blocking_force (std::max (block_force, springs_[i].blocking_force ()));
 }
 
 Real
@@ -225,7 +225,7 @@ Simple_spacer::compress_line ()
   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 (), greater<Spring> ());
+  sort (sorted_springs.begin (), sorted_springs.end (), std::greater<Spring> ());
 
   /* inv_hooke is the total flexibility of currently-active springs */
   double inv_hooke = 0;
@@ -269,7 +269,7 @@ Simple_spacer::compress_line ()
 void
 Simple_spacer::add_spring (Spring const &sp)
 {
-  force_ = max (force_, sp.blocking_force ());
+  force_ = std::max (force_, sp.blocking_force ());
   springs_.push_back (sp);
 }
 
@@ -291,7 +291,7 @@ Simple_spacer::force_penalty (bool ragged) const
      but according to the amount of whitespace that is present after the end
      of the line. */
   if (ragged)
-    return max (0.0, line_len_ - configuration_length (0.0));
+    return std::max (0.0, line_len_ - configuration_length (0.0));
 
   /* Use a convex compression penalty. */
   Real f = force_;
diff --git a/lily/simultaneous-music-iterator.cc b/lily/simultaneous-music-iterator.cc
index e892776b61..abcc6aaee3 100644
--- a/lily/simultaneous-music-iterator.cc
+++ b/lily/simultaneous-music-iterator.cc
@@ -135,7 +135,7 @@ Simultaneous_music_iterator::pending_moment () const
   for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
     {
       Music_iterator *it = unsmob<Music_iterator> (scm_car (s));
-      next = min (next, it->pending_moment ());
+      next = std::min (next, it->pending_moment ());
     }
 
   return next;
diff --git a/lily/skyline-pair.cc b/lily/skyline-pair.cc
index 67fef4c51a..5dc217d342 100644
--- a/lily/skyline-pair.cc
+++ b/lily/skyline-pair.cc
@@ -87,13 +87,13 @@ Skyline_pair::print () const
 Real
 Skyline_pair::left () const
 {
-  return min (skylines_[UP].left (), skylines_[DOWN].left ());
+  return std::min (skylines_[UP].left (), skylines_[DOWN].left ());
 }
 
 Real
 Skyline_pair::right () const
 {
-  return max (skylines_[UP].right (), skylines_[DOWN].right ());
+  return std::max (skylines_[UP].right (), skylines_[DOWN].right ());
 }
 
 void
diff --git a/lily/skyline.cc b/lily/skyline.cc
index 5ce66cb999..88e699a6eb 100644
--- a/lily/skyline.cc
+++ b/lily/skyline.cc
@@ -131,7 +131,7 @@ Building::precompute (Real start, Real start_height, Real end_height, Real end)
     // too steep to be stored in slope-intercept form, given round-off error
     {
       slope_ = 0.0;
-      y_intercept_ = max (start_height, end_height);
+      y_intercept_ = std::max (start_height, end_height);
     }
   else
     y_intercept_ = start_height - slope_ * start;
@@ -251,7 +251,7 @@ Skyline::internal_merge_skyline (list<Building> *sb, list<Building> *sc,
             }
           /* 'c' continues further, so move it into 'b' for the next pass. */
           b = c;
-          swap (sb, sc);
+          std::swap (sb, sc);
         }
       else /* b.end_ > c.end_ so finish with c */
         {
@@ -456,7 +456,7 @@ Skyline::Skyline (vector<Drul_array<Offset> > const &segments, Axis horizon_axis
       Offset left = seg[LEFT];
       Offset right = seg[RIGHT];
       if (left[horizon_axis] > right[horizon_axis])
-        swap (left, right);
+        std::swap (left, right);
 
       Real x1 = left[horizon_axis];
       Real x2 = right[horizon_axis];
@@ -671,10 +671,10 @@ Skyline::internal_distance (Skyline const &other, Real *touch_point) const
   Real touch = -infinity_f;
   while (i != buildings_.end () && j != other.buildings_.end ())
     {
-      Real end = min (i->end_, j->end_);
+      Real end = std::min (i->end_, j->end_);
       Real start_dist = i->height (start) + j->height (start);
       Real end_dist = i->height (end) + j->height (end);
-      dist = max (dist, max (start_dist, end_dist));
+      dist = std::max (dist, std::max (start_dist, end_dist));
 
       if (end_dist == dist)
         touch = end;
@@ -716,8 +716,8 @@ Skyline::max_height () const
   list<Building>::const_iterator i;
   for (i = buildings_.begin (); i != buildings_.end (); ++i)
     {
-      ret = max (ret, i->height (i->start_));
-      ret = max (ret, i->height (i->end_));
+      ret = std::max (ret, i->height (i->start_));
+      ret = std::max (ret, i->height (i->end_));
     }
 
   return sky_ * ret;
diff --git a/lily/slur-configuration.cc b/lily/slur-configuration.cc
index aac2a97a0e..4bd0c71139 100644
--- a/lily/slur-configuration.cc
+++ b/lily/slur-configuration.cc
@@ -122,7 +122,7 @@ fit_factor (Offset dz_unit, Offset dz_perp, Real close_to_edge_length,
 
       Real y = curve.get_other_coordinate (X_AXIS, p[X_AXIS]);
       if (y)
-        fit_factor = max (fit_factor, (p[Y_AXIS] / y));
+        fit_factor = std::max (fit_factor, (p[Y_AXIS] / y));
     }
   return fit_factor;
 }
@@ -154,7 +154,7 @@ Slur_configuration::generate_curve (Slur_score_state const &state,
   (control3 - control0).  */
 
   Real max_indent = len / 3.1;
-  indent = min (indent, max_indent);
+  indent = std::min (indent, max_indent);
 
   Real a1 = sqr (len) / 3.0;
   Real a2 = 0.75 * sqr (indent + len / 3.0);
@@ -184,7 +184,7 @@ Slur_configuration::generate_curve (Slur_score_state const &state,
   Real ff = fit_factor (dz_unit, dz_perp, state.parameters_.close_to_edge_length_,
                         curve, state.dir_, avoid);
 
-  height = max (height, min (height * ff, max_h));
+  height = std::max (height, std::min (height * ff, max_h));
 
   curve.control_[0] = attachment_[LEFT];
   curve.control_[1] = attachment_[LEFT] + dz_perp * height * state.dir_
@@ -258,7 +258,7 @@ Slur_configuration::score_encompass (Slur_score_state const &state)
               Real hd = (head_dy)
                         ? (1 / fabs (head_dy) - 1 / state.parameters_.free_head_distance_)
                         : state.parameters_.head_encompass_penalty_;
-              hd = min (max (hd, 0.0), state.parameters_.head_encompass_penalty_);
+              hd = std::min (std::max (hd, 0.0), state.parameters_.head_encompass_penalty_);
 
               demerit += hd;
             }
@@ -273,7 +273,7 @@ Slur_configuration::score_encompass (Slur_score_state const &state)
             {
 
               Real closest
-                = state.dir_ * max (state.dir_ * state.encompass_infos_[j].get_point (state.dir_), state.dir_ * line_y);
+                = state.dir_ * std::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);
@@ -299,7 +299,7 @@ Slur_configuration::score_encompass (Slur_score_state const &state)
 
       for (vsize j = 0; j < n; j++)
         {
-          min_dist = min (min_dist, convex_head_distances[j]);
+          min_dist = std::min (min_dist, convex_head_distances[j]);
           avg_distance += convex_head_distances[j];
         }
 
@@ -322,9 +322,9 @@ Slur_configuration::score_encompass (Slur_score_state const &state)
       Real variance_penalty = state.parameters_.head_slur_distance_max_ratio_;
       if (min_dist > 0.0)
         variance_penalty
-          = min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty);
+          = std::min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty);
 
-      variance_penalty = max (variance_penalty, 0.0);
+      variance_penalty = std::max (variance_penalty, 0.0);
       variance_penalty *= state.parameters_.head_slur_distance_factor_;
 
       add_score (variance_penalty, "variance");
@@ -427,7 +427,7 @@ Slur_configuration::score_extra_encompass (Slur_score_state const &state)
       else
         programming_error ("unknown avoidance type");
 
-      dist = max (dist, 0.0);
+      dist = std::max (dist, 0.0);
 
       Real penalty = info.penalty_ * peak_around (0.1 * state.parameters_.extra_encompass_free_distance_,
                                                   state.parameters_.extra_encompass_free_distance_,
@@ -473,7 +473,7 @@ Slur_configuration::score_slopes (Slur_score_state const &state)
   Real slur_dy = slur_dz[Y_AXIS];
   Real demerit = 0.0;
 
-  demerit += max ((fabs (slur_dy / slur_dz[X_AXIS])
+  demerit += std::max ((fabs (slur_dy / slur_dz[X_AXIS])
                    - state.parameters_.max_slope_), 0.0)
              * state.parameters_.max_slope_factor_;
 
@@ -484,9 +484,9 @@ Slur_configuration::score_slopes (Slur_score_state const &state)
 
   if (!state.is_broken_)
     demerit += state.parameters_.steeper_slope_factor_
-               * (max (fabs (slur_dy) - max_dy, 0.0));
+               * (std::max (fabs (slur_dy) - max_dy, 0.0));
 
-  demerit += max ((fabs (slur_dy / slur_dz[X_AXIS])
+  demerit += std::max ((fabs (slur_dy / slur_dz[X_AXIS])
                    - state.parameters_.max_slope_), 0.0)
              * state.parameters_.max_slope_factor_;
 
diff --git a/lily/slur-scoring.cc b/lily/slur-scoring.cc
index 58ad4873d9..fe7a273cd0 100644
--- a/lily/slur-scoring.cc
+++ b/lily/slur-scoring.cc
@@ -468,7 +468,7 @@ Slur_score_state::get_y_attachment_range () const
             slur_->warning ("slur trying to encompass an empty note column.");
           else
             end_ys[d] = dir_
-                        * max (max (dir_ * (base_attachments_[d][Y_AXIS]
+                        * std::max (std::max (dir_ * (base_attachments_[d][Y_AXIS]
                                             + parameters_.region_size_ * dir_),
                                     dir_ * (dir_ + nc_extent[dir_])),
                                dir_ * base_attachments_[-d][Y_AXIS]);
@@ -622,7 +622,7 @@ Slur_score_state::generate_avoid_offsets () const
         continue;
 
       Encompass_info inf (get_encompass_info (encompasses[i]));
-      Real y = dir_ * (max (dir_ * inf.head_, dir_ * inf.stem_));
+      Real y = dir_ * (std::max (dir_ * inf.head_, dir_ * inf.stem_));
 
       avoid.push_back (Offset (inf.x_, y + dir_ * parameters_.free_head_distance_));
     }
diff --git a/lily/slur.cc b/lily/slur.cc
index 0e077ffbb1..ea3b4cf922 100644
--- a/lily/slur.cc
+++ b/lily/slur.cc
@@ -365,7 +365,7 @@ Slur::outside_slur_callback (SCM grob, SCM offset_scm)
         }
     }
 
-  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;
+  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;
 
   return scm_from_double (offset + avoidance_offset);
 }
diff --git a/lily/source-file.cc b/lily/source-file.cc
index a3c08d29ba..98d4a0f878 100644
--- a/lily/source-file.cc
+++ b/lily/source-file.cc
@@ -34,7 +34,6 @@
 #else
 #include <strstream>
 #endif
-using namespace std;
 
 #include "file-name-map.hh"
 #include "international.hh"
@@ -82,7 +81,7 @@ gulp_file (const string &filename, int desired_size)
   int read_count = real_size;
 
   if (desired_size > 0)
-    read_count = min (read_count, desired_size);
+    read_count = std::min (read_count, desired_size);
 
   rewind (f);
 
@@ -175,8 +174,8 @@ Source_file::get_istream ()
       else
         {
           istream_ = new istringstream ("");
-          istream_->setstate (ios::eofbit);
-          //      istream_->set (ios::eofbit);
+          istream_->setstate (std::ios::eofbit);
+          //      istream_->set (std::ios::eofbit);
         }
     }
   return istream_;
@@ -330,7 +329,7 @@ Source_file::get_line (char const *pos_str0) const
   /* this will find the '\n' character at the end of our line */
   vsize lo = lower_bound (newline_locations_,
                           pos_str0,
-                          less<char const *> ());
+                          std::less<char const *> ());
 
   /* the return value will be indexed from 1 */
   return lo + 1 + line_offset_;
diff --git a/lily/spacing-basic.cc b/lily/spacing-basic.cc
index ff245aa30f..4ed797d673 100644
--- a/lily/spacing-basic.cc
+++ b/lily/spacing-basic.cc
@@ -40,7 +40,7 @@
 Spring
 Spacing_spanner::standard_breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *options)
 {
-  Real min_dist = max (0.0, Paper_column::minimum_distance (l, r));
+  Real min_dist = std::max (0.0, Paper_column::minimum_distance (l, r));
 
   if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
     {
@@ -136,13 +136,13 @@ Spacing_spanner::note_spacing (Grob * /* me */,
 
   if (Moment *measure_len = get_measure_length (lc))
     {
-      delta_t = min (delta_t, *measure_len);
+      delta_t = std::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 = min (shortest_playing_len, *measure_len);
+      shortest_playing_len = std::min (shortest_playing_len, *measure_len);
     }
 
   Spring ret;
@@ -157,7 +157,7 @@ Spacing_spanner::note_spacing (Grob * /* me */,
       ret = Spring (fraction * len, fraction * min);
 
       // Stretch proportional to the space between canonical bare noteheads
-      ret.set_inverse_stretch_strength (fraction * max (0.1, (len - min)));
+      ret.set_inverse_stretch_strength (fraction * std::max (0.1, (len - min)));
     }
   else if (delta_t.grace_part_)
     {
diff --git a/lily/spacing-determine-loose-columns.cc b/lily/spacing-determine-loose-columns.cc
index 12859cb191..00e6e125dd 100644
--- a/lily/spacing-determine-loose-columns.cc
+++ b/lily/spacing-determine-loose-columns.cc
@@ -161,13 +161,13 @@ Spacing_spanner::set_distances_for_loose_col (Grob *me, Grob *c,
               Spring base = note_spacing (me, lc, rc, options);
               Spring spring = Note_spacing::get_spacing (sp, rc, base, options->increment_);
 
-              dists[d] = max (dists[d], spring.min_distance ());
+              dists[d] = std::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] = max (dists[d], spring.min_distance ());
+              dists[d] = std::max (dists[d], spring.min_distance ());
             }
           else
             programming_error ("Subversive spacing wish");
diff --git a/lily/spacing-engraver.cc b/lily/spacing-engraver.cc
index 244a55b376..7efa1e649c 100644
--- a/lily/spacing-engraver.cc
+++ b/lily/spacing-engraver.cc
@@ -222,7 +222,7 @@ Spacing_engraver::stop_translation_timestep ()
       if (ev)
         {
           Moment m = get_event_length (ev);
-          shortest_playing = min (shortest_playing, m);
+          shortest_playing = std::min (shortest_playing, m);
         }
     }
   Moment starter;
@@ -233,13 +233,13 @@ Spacing_engraver::stop_translation_timestep ()
       Moment m = get_event_length (now_durations_[i].info_.event_cause ());
       if (m.to_bool ())
         {
-          starter = min (starter, m);
+          starter = std::min (starter, m);
           playing_durations_.insert (now_durations_[i]);
         }
     }
   now_durations_.clear ();
 
-  shortest_playing = min (shortest_playing, starter);
+  shortest_playing = std::min (shortest_playing, starter);
 
   assert (starter.to_bool ());
   SCM sh = shortest_playing.smobbed_copy ();
diff --git a/lily/spacing-interface.cc b/lily/spacing-interface.cc
index bcad9d741c..8f9875ff97 100644
--- a/lily/spacing-interface.cc
+++ b/lily/spacing-interface.cc
@@ -98,7 +98,7 @@ Spacing_interface::minimum_distance (Grob *me, Grob *right)
 {
   Drul_array<Skyline> skylines = Spacing_interface::skylines (me, right);
 
-  return max (0.0, skylines[LEFT].distance (skylines[RIGHT]));
+  return std::max (0.0, skylines[LEFT].distance (skylines[RIGHT]));
 }
 
 /*
diff --git a/lily/spacing-loose-columns.cc b/lily/spacing-loose-columns.cc
index 462a793b06..32ffe22032 100644
--- a/lily/spacing-loose-columns.cc
+++ b/lily/spacing-loose-columns.cc
@@ -175,8 +175,8 @@ set_loose_columns (System *which, Column_x_positions const *posns)
             }
 
           Real loose_col_horizontal_length = loose_col->extent (loose_col, X_AXIS).length ();
-          base_note_space = max (base_note_space, loose_col_horizontal_length);
-          tight_note_space = max (tight_note_space, loose_col_horizontal_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);
 
           clique_spacing.push_back (base_note_space);
           clique_tight_spacing.push_back (tight_note_space);
@@ -195,7 +195,7 @@ set_loose_columns (System *which, Column_x_positions const *posns)
           sum_tight_spacing += clique_tight_spacing[j];
           sum_spacing += clique_spacing[j];
         }
-      Real scale_factor = max (0.0, min (1.0, (permissible_distance - left_padding - sum_tight_spacing) / (sum_spacing - sum_tight_spacing)));
+      Real scale_factor = std::max (0.0, std::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]);
diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc
index 7ee6e3ef95..12f18e865f 100644
--- a/lily/spacing-spanner.cc
+++ b/lily/spacing-spanner.cc
@@ -119,7 +119,7 @@ Spacing_spanner::calc_common_shortest_duration (SCM grob)
           SCM st = cols[i]->get_property ("shortest-starter-duration");
           Moment this_shortest = *unsmob<Moment> (st);
           assert (this_shortest.to_bool ());
-          shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
+          shortest_in_measure = std::min (shortest_in_measure, this_shortest.main_part_);
         }
       else if (!shortest_in_measure.is_infinity ()
                && Paper_column::is_breakable (cols[i]))
@@ -167,7 +167,7 @@ Spacing_spanner::calc_common_shortest_duration (SCM grob)
     d = m->main_part_;
 
   if (max_idx != VPOS)
-    d = min (d, durations[max_idx]);
+    d = std::min (d, durations[max_idx]);
 
   return Moment (d).smobbed_copy ();
 }
@@ -246,7 +246,7 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
 
       /* min rather than max because stickout will be negative if the right-hand column
          sticks out a lot to the left */
-      Real stickout = min (skys ? (*skys)[LEFT].max_height () : 0.0,
+      Real stickout = std::min (skys ? (*skys)[LEFT].max_height () : 0.0,
                            Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
 
       Real prev_distances = 0.0;
@@ -263,7 +263,7 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
           Item *lb = l->find_prebroken_piece (RIGHT);
 
           Real dist = Separation_item::set_distance (l, r, padding);
-          distances[i] = max (distances[i], dist - prev_distances);
+          distances[i] = std::max (distances[i], dist - prev_distances);
 
           if (lb)
             {
@@ -272,7 +272,7 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
               // 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] = max (overhangs[j],
+                overhangs[j] = std::max (overhangs[j],
                                     lb->extent (lb, X_AXIS)[RIGHT]
                                     + distances[i] - dist);
             }
@@ -283,7 +283,7 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
 
           prev_distances += distances[j];
         }
-      overhangs[i] = max (overhangs[i],
+      overhangs[i] = std::max (overhangs[i],
                           overhangs[i - 1] - distances[i]);
     }
 }
@@ -420,7 +420,7 @@ Spacing_spanner::musical_column_spacing (Grob *me,
       if (Paper_column::is_extraneous_column_from_ligature (left_col))
         spring.set_distance (spring.min_distance ());
       else
-        spring.set_distance (max (left_col->extent (left_col, X_AXIS)[RIGHT],
+        spring.set_distance (std::max (left_col->extent (left_col, X_AXIS)[RIGHT],
                                   spring.min_distance ()));
 
       spring.set_inverse_stretch_strength (1.0);
diff --git a/lily/spring.cc b/lily/spring.cc
index 105ae73d1d..5dfc3c804c 100644
--- a/lily/spring.cc
+++ b/lily/spring.cc
@@ -86,8 +86,8 @@ Spring::update_blocking_force ()
 void
 Spring::operator *= (Real r)
 {
-  distance_ = max (min_distance_, distance_ * r);
-  inverse_compress_strength_ = max (0.0, distance_ - min_distance_);
+  distance_ = std::max (min_distance_, distance_ * r);
+  inverse_compress_strength_ = std::max (0.0, distance_ - min_distance_);
   inverse_stretch_strength_ *= r;
   update_blocking_force ();
 }
@@ -113,13 +113,13 @@ merge_springs (vector<Spring> const &springs)
       avg_distance += springs[i].distance ();
       avg_stretch += springs[i].inverse_stretch_strength ();
       avg_compress += 1 / springs[i].inverse_compress_strength ();
-      min_distance = max (springs[i].min_distance (), min_distance);
+      min_distance = std::max (springs[i].min_distance (), min_distance);
     }
 
   avg_stretch /= Real (springs.size ());
   avg_compress /= Real (springs.size ());
   avg_distance /= Real (springs.size ());
-  avg_distance = max (min_distance + 0.3, avg_distance);
+  avg_distance = std::max (min_distance + 0.3, avg_distance);
 
   Spring ret = Spring (avg_distance, min_distance);
   ret.set_inverse_stretch_strength (avg_stretch);
@@ -155,7 +155,7 @@ Spring::set_min_distance (Real d)
 void
 Spring::ensure_min_distance (Real d)
 {
-  set_min_distance (max (d, min_distance_));
+  set_min_distance (std::max (d, min_distance_));
 }
 
 void
@@ -217,7 +217,7 @@ Spring::set_default_stretch_strength ()
 Real
 Spring::length (Real f) const
 {
-  Real force = max (f, blocking_force_);
+  Real force = std::max (f, blocking_force_);
   Real inv_k = force < 0.0 ? inverse_compress_strength_ : inverse_stretch_strength_;
 
   if (isinf (force))
@@ -229,6 +229,6 @@ Spring::length (Real f) const
   // 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 max (min_distance_, distance_ + force * inv_k);
+  return std::max (min_distance_, distance_ + force * inv_k);
 }
 
diff --git a/lily/staff-spacing.cc b/lily/staff-spacing.cc
index d693feaee1..52dedd5d77 100644
--- a/lily/staff-spacing.cc
+++ b/lily/staff-spacing.cc
@@ -20,7 +20,6 @@
 #include "staff-spacing.hh"
 
 #include <cstdio>
-using namespace std;
 
 #include "international.hh"
 #include "paper-column.hh"
@@ -62,7 +61,7 @@ Staff_spacing::optical_correction (Grob *me, Grob *g, Interval bar_height)
 
           stem_posns.intersect (bar_height);
 
-          ret = min (abs (stem_posns.length () / 7.0), 1.0);
+          ret = std::min (abs (stem_posns.length () / 7.0), 1.0);
           ret *= robust_scm2double (me->get_property ("stem-spacing-correction"), 1);
         }
     }
@@ -106,7 +105,7 @@ Staff_spacing::next_notes_correction (Grob *me,
   Real max_optical = 0.0;
 
   for (vsize i = 0; i < note_columns.size (); i++)
-    max_optical = max (max_optical, optical_correction (me, note_columns[i], bar_size));
+    max_optical = std::max (max_optical, optical_correction (me, note_columns[i], bar_size));
 
   return max_optical;
 }
@@ -181,10 +180,10 @@ Staff_spacing::get_spacing (Grob *me, Grob *right_col, Real situational_space)
       ideal = fixed + distance / 2;
     }
   else if (scm_is_eq (type, ly_symbol2scm ("minimum-space")))
-    ideal = last_ext[LEFT] + max (last_ext.length (), distance);
+    ideal = last_ext[LEFT] + std::max (last_ext.length (), distance);
   else if (scm_is_eq (type, ly_symbol2scm ("minimum-fixed-space")))
     {
-      fixed = last_ext[LEFT] + max (last_ext.length (), distance);
+      fixed = last_ext[LEFT] + std::max (last_ext.length (), distance);
       ideal = fixed;
     }
 
@@ -201,13 +200,13 @@ Staff_spacing::get_spacing (Grob *me, Grob *right_col, Real situational_space)
   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 = max (0.0, 0.3 + min_dist - fixed);
+  Real min_dist_correction = std::max (0.0, 0.3 + min_dist - fixed);
   fixed += min_dist_correction;
-  ideal = max (ideal, fixed);
+  ideal = std::max (ideal, fixed);
 
   Spring ret (ideal, min_dist);
-  ret.set_inverse_stretch_strength (max (0.0, stretchability));
-  ret.set_inverse_compress_strength (max (0.0, ideal - fixed));
+  ret.set_inverse_stretch_strength (std::max (0.0, stretchability));
+  ret.set_inverse_compress_strength (std::max (0.0, ideal - fixed));
   return ret;
 }
 
diff --git a/lily/stem-tremolo.cc b/lily/stem-tremolo.cc
index f88b41c450..1c44a67924 100644
--- a/lily/stem-tremolo.cc
+++ b/lily/stem-tremolo.cc
@@ -180,7 +180,7 @@ Stem_tremolo::pure_height (SCM smob, SCM, SCM)
   int beam_count = Stem::beam_multiplicity (stem).length () + 1;
   Real beam_translation = get_beam_translation (me);
 
-  ph = ph - dir * max (beam_count, 1) * beam_translation;
+  ph = ph - dir * std::max (beam_count, 1) * beam_translation;
   ph = ph - ph.center ();
 
   return ly_interval2scm (ph);
@@ -304,14 +304,14 @@ Stem_tremolo::y_offset (Grob *me, bool pure)
       Stem_info si = Stem::get_stem_info (stem);
       ph[-dir] = si.shortest_y_;
 
-      return (ph - dir * max (beam_count, 1) * beam_translation)[dir] - dir * 0.5 * me->pure_y_extent (me, 0, INT_MAX).length ();
+      return (ph - dir * std::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 * max (beam_count, 1) * beam_translation
+      - dir * std::max (beam_count, 1) * beam_translation
       - Stem::beam_end_corrective (stem);
 
   if (!beam && Stem::duration_log (stem) >= 3)
diff --git a/lily/stem.cc b/lily/stem.cc
index a8105c9402..9d32e0b625 100644
--- a/lily/stem.cc
+++ b/lily/stem.cc
@@ -41,7 +41,6 @@
 #include "spanner.hh"
 
 #include <cmath>                // rint
-using namespace std;
 
 #include "beam.hh"
 #include "directional-element-interface.hh"
@@ -95,7 +94,7 @@ Stem::get_beaming (Grob *me, Direction d)
   SCM lst = index_get_cell (pair, d);
 
   int len = scm_ilength (lst);
-  return max (len, 0);
+  return std::max (len, 0);
 }
 
 Interval
@@ -155,7 +154,7 @@ Stem::set_stem_positions (Grob *me, Real se)
 
           height[-d] = (height[d] - d
                         * (0.5 * beam_thickness
-                           + beam_translation * max (0, (beam_count - 1))
+                           + beam_translation * std::max (0, (beam_count - 1))
                            + stemlet_length));
         }
       else if (!stemlet && beam)
@@ -260,7 +259,7 @@ Stem::note_head_positions (Grob *me, bool filter)
       ps.push_back (p);
     }
 
-  vector_sort (ps, less<int> ());
+  vector_sort (ps, std::less<int> ());
   return ps;
 }
 
@@ -345,8 +344,8 @@ Stem::internal_pure_height (Grob *me, bool calc_beam)
       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 = min (min_pos, coords[i]);
-          max_pos = max (max_pos, coords[i]);
+          min_pos = std::min (min_pos, coords[i]);
+          max_pos = std::max (max_pos, coords[i]);
         }
       for (vsize i = 0; i < heights.size (); i++)
         {
@@ -431,7 +430,7 @@ Stem::internal_calc_stem_end_position (Grob *me, bool calc_beam)
     {
       SCM sshorten = ly_assoc_get (ly_symbol2scm ("stem-shorten"), details, SCM_EOL);
       SCM scm_shorten = scm_is_pair (sshorten)
-                        ? robust_list_ref (max (duration_log (me) - 2, 0), sshorten) : SCM_EOL;
+                        ? robust_list_ref (std::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.
@@ -443,14 +442,14 @@ Stem::internal_calc_stem_end_position (Grob *me, bool calc_beam)
           (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 = min (max (0.25, (shorten_property / 6)), 0.5);
+      Real shortening_step = std::min (std::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 = (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);
+      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);
 
       length -= shorten;
     }
@@ -484,7 +483,7 @@ Stem::internal_calc_stem_end_position (Grob *me, bool calc_beam)
           if (dir == UP)
             minlen += beam_trans;
         }
-      length = max (length, minlen + 1.0);
+      length = std::max (length, minlen + 1.0);
     }
 
   Real stem_end = dir ? hp[dir] + dir * length : 0;
@@ -744,7 +743,7 @@ Stem::internal_height (Grob *me, bool calc_beam)
 
   Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
 
-  Interval stem_y = Interval (min (y1, y2), max (y2, y1)) * half_space;
+  Interval stem_y = Interval (std::min (y1, y2), std::max (y2, y1)) * half_space;
 
   return stem_y;
 }
@@ -885,7 +884,7 @@ Stem::print (SCM smob)
 
   Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
 
-  Interval stem_y = Interval (min (y1, y2), max (y2, y1)) * half_space;
+  Interval stem_y = Interval (std::min (y1, y2), std::max (y2, y1)) * half_space;
 
   stem_y[dir] -= beam_end_corrective (me);
 
@@ -1049,7 +1048,7 @@ Stem::calc_stem_info (SCM smob)
                               /* stem only extends to center of beam */
                               - 0.5 * beam_thickness;
 
-  ideal_length = max (ideal_length, ideal_minimum_length);
+  ideal_length = std::max (ideal_length, ideal_minimum_length);
 
   /* Convert to Y position, calculate for dir == UP */
   Real note_start
@@ -1079,9 +1078,9 @@ Stem::calc_stem_info (SCM smob)
     {
       /* Highest beam of (UP) beam must never be lower than middle
          staffline */
-      ideal_y = max (ideal_y, 0.0);
+      ideal_y = std::max (ideal_y, 0.0);
       /* Lowest beam of (UP) beam must never be lower than second staffline */
-      ideal_y = max (ideal_y, (-staff_space
+      ideal_y = std::max (ideal_y, (-staff_space
                                - beam_thickness + height_of_my_beams));
     }
 
@@ -1097,7 +1096,7 @@ Stem::calc_stem_info (SCM smob)
           * length_fraction)
        : 0.0);
 
-  Real minimum_length = max (minimum_free, height_of_my_trem)
+  Real minimum_length = std::max (minimum_free, height_of_my_trem)
                         + height_of_my_beams
                         /* stem only extends to center of beam */
                         - 0.5 * beam_thickness;
diff --git a/lily/stencil-integral.cc b/lily/stencil-integral.cc
index a6e6d7c84b..9a23d2f38c 100644
--- a/lily/stencil-integral.cc
+++ b/lily/stencil-integral.cc
@@ -55,7 +55,6 @@ when this transforms a point (x,y), the point is written as matrix:
 #include "skyline.hh"
 #include "skyline-pair.hh"
 #include "spanner.hh"
-using namespace std;
 
 using std::string;
 using std::vector;
@@ -187,8 +186,8 @@ make_draw_line_boxes (vector<Box> &boxes, vector<Drul_array<Offset> > &buildings
   //////////////////////
   if (x1 < x0)
     {
-      swap (x0, x1);
-      swap (y0, y1);
+      std::swap (x0, x1);
+      std::swap (y0, y1);
     }
   Offset left (x0, y0);
   Offset right (x1, y1);
@@ -281,7 +280,7 @@ make_partial_ellipse_boxes (vector<Box> &boxes,
   Offset ep (cos (end) * x_rad, sin (end) * y_rad);
   //////////////////////
   Drul_array<vector<Offset> > points;
-  int quantization = max (1, (int) (((x_rad * trans.xx) + (y_rad * trans.yy)) * M_PI / QUANTIZATION_UNIT));
+  int quantization = std::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++)
@@ -778,7 +777,7 @@ make_glyph_string_boxes (vector<Box> &boxes,
         {
           assert (abs (xlen - ylen) < 10e-3);
 
-          Real scale_factor = max (xlen, ylen);
+          Real scale_factor = std::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]);
diff --git a/lily/stencil.cc b/lily/stencil.cc
index 34b68d9b3a..7c1c918655 100644
--- a/lily/stencil.cc
+++ b/lily/stencil.cc
@@ -249,7 +249,7 @@ Stencil::align_to (Axis a, Real x)
 /*  See scheme Function.  */
 
 // Any stencil that is empty in the orthogonal axis is spacing.
-// Spacing is not subjected to the max (0) rule and can thus be
+// Spacing is not subjected to the std::max (0) rule and can thus be
 // negative.
 
 void
diff --git a/lily/system-start-delimiter.cc b/lily/system-start-delimiter.cc
index e5460a0f04..7eb8c99871 100644
--- a/lily/system-start-delimiter.cc
+++ b/lily/system-start-delimiter.cc
@@ -154,7 +154,7 @@ System_start_delimiter::staff_brace (Grob *me, Real y)
 
   int
   lo = 0;
-  int hi = max ((int) fm->count () - 1, 2);
+  int hi = std::max ((int) fm->count () - 1, 2);
 
   /* do a binary search for each Y, not very efficient, but passable?  */
   Box b;
diff --git a/lily/tab-note-heads-engraver.cc b/lily/tab-note-heads-engraver.cc
index 51ea30da01..700ec99994 100644
--- a/lily/tab-note-heads-engraver.cc
+++ b/lily/tab-note-heads-engraver.cc
@@ -22,7 +22,6 @@
 
 #include "engraver.hh"
 
-using namespace std;
 
 #include "articulations.hh"
 #include "duration.hh"
diff --git a/lily/tab-tie-follow-engraver.cc b/lily/tab-tie-follow-engraver.cc
index fbc5f0c3b2..defbe19668 100644
--- a/lily/tab-tie-follow-engraver.cc
+++ b/lily/tab-tie-follow-engraver.cc
@@ -22,7 +22,6 @@
 
 #include "engraver.hh"
 
-using namespace std;
 
 #include "context.hh"
 #include "item.hh"
diff --git a/lily/text-interface.cc b/lily/text-interface.cc
index 7c5ce5019c..b8ec1d6c88 100644
--- a/lily/text-interface.cc
+++ b/lily/text-interface.cc
@@ -47,7 +47,7 @@ replace_special_characters (string &str, SCM props)
   int max_length = 0;
   for (SCM s = replacement_alist; scm_is_pair (s); s = scm_cdr (s))
     {
-      max_length = max (max_length, scm_to_int
+      max_length = std::max (max_length, scm_to_int
                         (scm_string_length (scm_caar (s))));
     }
 
diff --git a/lily/tie-column.cc b/lily/tie-column.cc
index b814e4c442..1fb17a6f58 100644
--- a/lily/tie-column.cc
+++ b/lily/tie-column.cc
@@ -32,7 +32,6 @@
 #include "tie-formatting-problem.hh"
 #include "tie-configuration.hh"
 
-using namespace std;
 using std::vector;
 
 void
diff --git a/lily/tie-formatting-problem.cc b/lily/tie-formatting-problem.cc
index 6a5e62fde1..d4a7be2cfb 100644
--- a/lily/tie-formatting-problem.cc
+++ b/lily/tie-formatting-problem.cc
@@ -284,7 +284,7 @@ Tie_formatting_problem::set_chord_outline (vector<Item *> bounds,
   for (vsize i = 0; i < bounds.size (); i++)
     ranks.push_back (bounds[i]->get_column ()->get_rank ());
 
-  vector_sort (ranks, less<int> ());
+  vector_sort (ranks, std::less<int> ());
   uniq (ranks);
 
   for (vsize i = 0; i < ranks.size (); i++)
@@ -481,7 +481,7 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
     }
 
   if (y_tune
-      && max (fabs (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y),
+      && std::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))
     {
@@ -577,7 +577,7 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
             continue;
 
           conf->attachment_x_[d]
-            = d * min (d * conf->attachment_x_[d],
+            = d * std::min (d * conf->attachment_x_[d],
                        d * (get_stem_extent (conf->column_ranks_[d], d, X_AXIS)[-d] - d * details_.stem_gap_));
         }
     }
@@ -625,7 +625,7 @@ Tie_formatting_problem::score_aptitude (Tie_configuration *conf,
     }
 
   {
-    Real relevant_dist = max (fabs (curve_y - tie_y) - 0.5, 0.0);
+    Real relevant_dist = std::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");
diff --git a/lily/tuplet-bracket.cc b/lily/tuplet-bracket.cc
index 1bad21ba40..4a8487adc5 100644
--- a/lily/tuplet-bracket.cc
+++ b/lily/tuplet-bracket.cc
@@ -238,7 +238,7 @@ Tuplet_bracket::calc_x_positions (SCM smob)
           if (to_boolean (me->get_property ("full-length-to-extent")))
             coord = robust_relative_extent (bounds[d], commonx, X_AXIS)[LEFT];
 
-          coord = max (coord, x_span[LEFT]);
+          coord = std::max (coord, x_span[LEFT]);
 
           x_span[d] = coord - padding;
         }
diff --git a/lily/tuplet-iterator.cc b/lily/tuplet-iterator.cc
index c43e630c43..ad0d3c7361 100644
--- a/lily/tuplet-iterator.cc
+++ b/lily/tuplet-iterator.cc
@@ -92,7 +92,7 @@ Moment
 Tuplet_iterator::pending_moment () const
 {
   Moment next_mom = Music_wrapper_iterator::pending_moment ();
-  next_mom = min (next_mom, next_split_mom_);
+  next_mom = std::min (next_mom, next_split_mom_);
 
   return next_mom;
 }
@@ -110,7 +110,7 @@ Tuplet_iterator::process (Moment m)
       if (m.main_part_ < music_get_length ().main_part_)
         {
           spanner_duration_ =
-            min (music_get_length () - next_split_mom_, spanner_duration_);
+            std::min (music_get_length () - next_split_mom_, spanner_duration_);
           tuplet_handler_.set_context (get_outlet ());
           report_event (create_event (START));
 
diff --git a/lily/tuplet-number.cc b/lily/tuplet-number.cc
index df97093988..a28458b2b8 100644
--- a/lily/tuplet-number.cc
+++ b/lily/tuplet-number.cc
@@ -342,7 +342,7 @@ count_beams_not_touching_stem (SCM beaming)
         ++count;
     }
 
-  return max (0, count - 1);
+  return std::max (0, count - 1);
 }
 
 MAKE_SCHEME_CALLBACK (Tuplet_number, calc_y_offset, 1);
@@ -418,8 +418,8 @@ Tuplet_number::calc_y_offset (SCM smob)
                   : staff_ext_y[DOWN] > ref_stem_ext[UP];
       if (move)
         {
-          Interval ledger_domain = Interval (min (staff_ext_y[UP], ref_stem_ext[UP]),
-                                             max (staff_ext_y[DOWN], ref_stem_ext[DOWN]));
+          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 num_y (me->extent (commony, Y_AXIS));
           num_y.translate (y_offset);
           Interval num_ledger_overlap (num_y);
diff --git a/lily/vaticana-ligature-engraver.cc b/lily/vaticana-ligature-engraver.cc
index f0e14849e8..36959d0518 100644
--- a/lily/vaticana-ligature-engraver.cc
+++ b/lily/vaticana-ligature-engraver.cc
@@ -732,7 +732,7 @@ Vaticana_ligature_engraver::transform_heads (Spanner *ligature,
   add_mora_column (prev_primitive->get_column ());
 
 #if 0 // experimental code to collapse spacing after ligature
-  /* TODO: set to max (old/new spacing-increment), since other
+  /* TODO: set to std::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 ();
diff --git a/lily/vaticana-ligature.cc b/lily/vaticana-ligature.cc
index eb38442c3f..c8be288013 100644
--- a/lily/vaticana-ligature.cc
+++ b/lily/vaticana-ligature.cc
@@ -108,7 +108,7 @@ vaticana_brew_flexa (Grob *me,
    */
   Real left_height
     = right_height
-      + min (0.12 * abs (interval), 0.3) * staff_space;
+      + std::min (0.12 * abs (interval), 0.3) * staff_space;
 
   /*
    * Compensate optical illusion regarding vertical position of left
diff --git a/lily/volta-bracket.cc b/lily/volta-bracket.cc
index b135e8e198..65e57ea3b1 100644
--- a/lily/volta-bracket.cc
+++ b/lily/volta-bracket.cc
@@ -18,7 +18,6 @@
 */
 
 #include <cstring>
-using namespace std;
 
 #include "warn.hh"
 #include "font-interface.hh"