lilypond-0.1.8

diff --git a/flower/include/interval.hh b/flower/include/interval.hh
index bf4e4cc0e74d56758eaa3653dbb59a3671a86297..19d50611146e3c628888a6a92191d1cc5d3fff47 100644 (file)
--- a/flower/include/interval.hh
+++ b/flower/include/interval.hh
@@ -26,24 +26,24 @@ struct Interval_t {
     static T infinity() ;
     
     T center() { return (left + right) / T(2);}
-    void translate(T t) {
+    void translate (T t) {
        left += t;
        right += t;
     }
-    T& idx(int j) {
+    T& idx (int j) {
        if (j==-1)
            return left;
        else if (j==1)
            return right;
        else
-           assert(false);
+           assert (false);
        return left;            
     }
     T& operator[](int j) {
-       return idx(j);
+       return idx (j);
     }
     T operator[](int j) const {
-       return ((Interval_t<T> *)this)->idx(j);
+       return ((Interval_t<T> *)this)->idx (j);
     }
     T &max() { return right;}
     T max()const { return right;}
@@ -53,17 +53,17 @@ struct Interval_t {
       PRE
       *this and h are comparable
       */
-    void unite(Interval_t<T> h);
-    void intersect(Interval_t<T> h);
+    void unite (Interval_t<T> h);
+    void intersect (Interval_t<T> h);
 
     T length() const;
     void set_empty() ;
     bool empty_b() const { return left > right; }
-    bool contains_b(Interval_t<T> const&) const;
+    bool contains_b (Interval_t<T> const&) const;
     Interval_t() {
        set_empty();
     }
-    Interval_t(T m, T M) {
+    Interval_t (T m, T M) {
        left =m;
        right = M;
     }
@@ -83,7 +83,7 @@ struct Interval_t {
        return *this;
     }
     String str() const;    
-    bool elt_b(T r);
+    bool elt_b (T r);
 };
 
 
@@ -91,7 +91,7 @@ struct Interval_t {
   inclusion ordering. Crash if not comparable.
   */
 template<class T>
-int Interval__compare(const Interval_t<T>&,Interval_t<T> const&);
+int Interval__compare (const Interval_t<T>&,Interval_t<T> const&);
 
 /*
   INLINE
@@ -99,21 +99,21 @@ int Interval__compare(const Interval_t<T>&,Interval_t<T> const&);
 
 #include "compare.hh"
 
-template_instantiate_compare(Interval_t<T>&, Interval__compare, template<class T>);
+TEMPLATE_INSTANTIATE_COMPARE(Interval_t<T>&, Interval__compare, template<class T>);
 
 
 template<class T>
 inline Interval_t<T>
-intersection(Interval_t<T> a, Interval_t<T> const&b)
+intersection (Interval_t<T> a, Interval_t<T> const&b)
 {
-    a.intersect(b);
+    a.intersect (b);
     return a;
     
 }
 
 template<class T>
 inline
-Interval_t<T> operator +(T a,Interval_t<T> i )
+Interval_t<T> operator +(T a,Interval_t<T> i)
 {
     i += a;
     return i;
@@ -121,13 +121,13 @@ Interval_t<T> operator +(T a,Interval_t<T> i )
 
 template<class T>
 inline
-Interval_t<T> operator +(Interval_t<T> i,T a ){
+Interval_t<T> operator +(Interval_t<T> i,T a){
     return a+i;
 }
 
 template<class T>
 inline
-Interval_t<T> operator *(T a,Interval_t<T> i )
+Interval_t<T> operator *(T a,Interval_t<T> i)
 {
     i *= a;
     return i;
@@ -135,15 +135,13 @@ Interval_t<T> operator *(T a,Interval_t<T> i )
 
 template<class T>
 inline
-Interval_t<T> operator *(Interval_t<T> i,T a ){
+Interval_t<T> operator *(Interval_t<T> i,T a){
     return a*i;
 }
 
 typedef Interval_t<Real> Interval;
 
 
-#define Interval__instantiate(T) template struct Interval_t<T>;\
-  template  int Interval__compare(const Interval_t<T>&,Interval_t<T> const&)
 
 
 #endif // INTERVAL_HH

diff --git a/flower/include/interval.tcc b/flower/include/interval.tcc
index ab2eb95ec3b72f53c0c172c89574b303fca92312..efb7644133f4203dd8a9d5e4fca81868587ffb7d 100644 (file)
--- a/flower/include/interval.tcc
+++ b/flower/include/interval.tcc
@@ -1,3 +1,15 @@
+/*
+  interval.tcc -- implement Interval_t
+
+  source file of the Flower Library
+
+  (c) 1996,1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef INTERVAL_TCC
+#define INTERVAL_TCC
+
 #include <assert.h> 
 #include <math.h>
 #include "interval.hh"
@@ -6,7 +18,7 @@
 
 template<class T>
 int
-_Interval__compare(const Interval_t<T>&a,Interval_t<T> const&b)
+_Interval__compare (const Interval_t<T>&a,Interval_t<T> const&b)
 {
     if (a.left == b.left && a.right == b.right)
        return 0;
@@ -22,9 +34,9 @@ _Interval__compare(const Interval_t<T>&a,Interval_t<T> const&b)
 
 template<class T>
 bool 
-Interval_t<T>::contains_b(Interval_t<T> const& a)const
+Interval_t<T>::contains_b (Interval_t<T> const& a)const
 {
-    int c_i= _Interval__compare( *this, a);
+    int c_i= _Interval__compare (*this, a);
     if (c_i == -2)
        return false;
     return c_i >= 0;
@@ -32,11 +44,11 @@ Interval_t<T>::contains_b(Interval_t<T> const& a)const
 
 template<class T>
 int
-Interval__compare(const Interval_t<T>&a,Interval_t<T> const&b)
+Interval__compare (const Interval_t<T>&a,Interval_t<T> const&b)
 {
-    int i = _Interval__compare(a,b);
+    int i = _Interval__compare (a,b);
     if (i < -1)
-       assert(false);
+       assert (false);
     return i;
 }
 
@@ -51,13 +63,13 @@ Interval_t<T>::set_empty()
 template<class T>
 T
 Interval_t<T>::length() const {
-    assert(right >= left);
+    assert (right >= left);
     return right-left;
 }
 
 template<class T>
 void
-Interval_t<T>::unite(Interval_t<T> h)
+Interval_t<T>::unite (Interval_t<T> h)
 {
     if (h.left<left)
        left = h.left;
@@ -71,22 +83,22 @@ Interval_t<T>::unite(Interval_t<T> h)
 
 template<class T>
 void
-Interval_t<T>::intersect(Interval_t<T> h)
+Interval_t<T>::intersect (Interval_t<T> h)
 {
 #if defined (__GNUG__) && ! defined (__STRICT_ANSI__)
     left = h.left >? left;
     right = h.right <?right;
 #else
-    left = max(h.left, left);
-    right = min(h.right, right);
+    left = max (h.left, left);
+    right = min (h.right, right);
 #endif
 }
 
 template<class T>
 Interval_t<T>
-intersect(Interval_t<T> x, Interval_t<T> const &y)
+intersect (Interval_t<T> x, Interval_t<T> const &y)
 {
-    x.intersect(y);
+    x.intersect (y);
     return x;
 }
 
@@ -96,14 +108,20 @@ Interval_t<T>::str() const
 {
     if (empty_b())
        return "[empty]";
-    String s("[");
+    String s ("[");
  
-    return s + String( left ) + String( "," ) + String( right ) + String( "]" );
+    return s + String (left) + String ("," ) + String (right ) + String ("]" );
 }
 
 template<class T>
 bool
-Interval_t<T>::elt_b(T r)
+Interval_t<T>::elt_b (T r)
 {
     return r >= left && r <= right;
 }
+
+
+#define INTERVAL__INSTANTIATE(T) struct Interval_t<T>;\
+  template  int Interval__compare(const Interval_t<T>&,Interval_t<T> const&)
+
+#endif // INTERVAL_TCC

diff --git a/flower/include/plist.tcc b/flower/include/plist.tcc
index ba4a0f20b037af367921882b11bb42b784f28fc3..f7733d508d0e77b8bba75eadd00554cc9c7c3170 100644 (file)
--- a/flower/include/plist.tcc
+++ b/flower/include/plist.tcc
@@ -1,15 +1,15 @@
 #include "plist.hh"
 
-#define PL_instantiate(a)  template class Link_list<a*>; \
+#define PL_INSTANTIATE(a) class Link_list<a*>; \
        template class PCursor<a*>;
-#define IPL_instantiate(a) PL_instantiate(a); \
+#define IPL_INSTANTIATE(a) PL_INSTANTIATE(a); \
        template class Pointer_list<a*>
        
 template<class T>
 void
 Pointer_list<T>::junk()
 {
-    PCursor<T> c( *this );
+    PCursor<T> c (*this);
     while (c.ok()) {
        delete c.remove_p();
     }
@@ -17,9 +17,9 @@ Pointer_list<T>::junk()
 
 template<class T>
 PCursor<T> 
-Link_list<T>::find(T what ) const
+Link_list<T>::find (T what) const
 {
-    PCursor<T> i(*this);
+    PCursor<T> i (*this);
     for (; i.ok(); i++)
        if (i.ptr() == what)
           break;

diff --git a/lily/template2.cc b/lily/template2.cc
index b09b378aee598c06cd2a510b8a91325dd3f49841..67c24f5a58a719bd6f02de65e7afd2e680aa9da4 100644 (file)
--- a/lily/template2.cc
+++ b/lily/template2.cc
@@ -10,4 +10,4 @@
 #include "plist.tcc"
 #include "pcursor.tcc"
 
-IPL_instantiate(Line_spacer);
+ template IPL_INSTANTIATE(Line_spacer);

diff --git a/lily/template3.cc b/lily/template3.cc
index 82d84d1965e0f83a62d235765bd2af8eb8e869cf..2e368d5219ecb2dc453b450e5a393bf183843803 100644 (file)
--- a/lily/template3.cc
+++ b/lily/template3.cc
@@ -13,5 +13,5 @@
 #include "plist.tcc"
 #include "pcursor.tcc"
 
-IPL_instantiate(Atom);
-IPL_instantiate(Input_translator);
+template IPL_INSTANTIATE(Atom);
+template IPL_INSTANTIATE(Input_translator);

diff --git a/lily/template5.cc b/lily/template5.cc
index e57925bf5b38a7057f9fa4a22cb67b21c468c4b7..bf7523d7d85b690aeed66ffd7c3fe0a8f6e8730e 100644 (file)
--- a/lily/template5.cc
+++ b/lily/template5.cc
@@ -14,13 +14,13 @@
 
 #include "interval.tcc"
 
-Interval__instantiate(Rational);
-Interval__instantiate(int);
+template INTERVAL__INSTANTIATE(Rational);
+template INTERVAL__INSTANTIATE(int);
 
 Rational
 Interval_t<Rational>::infinity()
 {
-    return Rational(INT_MAX);
+    return Rational (INT_MAX);
 }
 
 int

diff --git a/lily/template6.cc b/lily/template6.cc
index 38344df6000db2fb012485e3df97d87ddd6402ef..e8f04f81224345d6b1b6acfd38e7211477553057 100644 (file)
--- a/lily/template6.cc
+++ b/lily/template6.cc
@@ -3,5 +3,5 @@
 #include "engraver.hh"
 #include "performer.hh"
 
-IPL_instantiate(Engraver);
-IPL_instantiate(Performer);
+template IPL_INSTANTIATE(Engraver);
+template IPL_INSTANTIATE(Performer);

diff --git a/lily/template7.cc b/lily/template7.cc
index 6a5bb7d83f7f7c1dee7d232b35771fd6682bfb90..b36c23275373da1581f1ae217a5355cb8ecd72ca 100644 (file)
--- a/lily/template7.cc
+++ b/lily/template7.cc
@@ -14,5 +14,5 @@
 #include "music-list.hh"
 #include "music-iterator.hh"
 
-IPL_instantiate(Music);
-IPL_instantiate(Music_iterator);
+template IPL_INSTANTIATE(Music);
+template IPL_INSTANTIATE(Music_iterator);

diff --git a/lily/template8.cc b/lily/template8.cc
index de06b70477f10154c6b1d063135242f67a210bc2..de2fa8af8e13f4c371e70f927bedadc4c024d89d 100644 (file)
--- a/lily/template8.cc
+++ b/lily/template8.cc
@@ -15,7 +15,7 @@
 #include "plist.tcc"
 
 
-IPL_instantiate(Audio_element);
-IPL_instantiate(Audio_column);
+template IPL_INSTANTIATE(Audio_element);
+template IPL_INSTANTIATE(Audio_column);