From d81a6b6fc86f77f66ed67fbdbf63087fada15a48 Mon Sep 17 00:00:00 2001
From: fred <fred>
Date: Sat, 8 Mar 1997 19:00:51 +0000
Subject: [PATCH] lilypond-0.0.43

---
 flower/include/cursor.inl        | 113 +++++++++++++++++
 flower/include/link.inl          | 102 +++++++++++++++
 flower/include/list.inl          |  56 +++++++++
 flower/include/plist.inl         |  21 ++++
 flower/include/string-data.inl   | 210 +++++++++++++++++++++++++++++++
 flower/include/string-handle.inl | 156 +++++++++++++++++++++++
 6 files changed, 658 insertions(+)
 create mode 100644 flower/include/cursor.inl
 create mode 100644 flower/include/link.inl
 create mode 100644 flower/include/list.inl
 create mode 100644 flower/include/plist.inl
 create mode 100644 flower/include/string-data.inl
 create mode 100644 flower/include/string-handle.inl

diff --git a/flower/include/cursor.inl b/flower/include/cursor.inl
new file mode 100644
index 0000000000..54d3703e60
--- /dev/null
+++ b/flower/include/cursor.inl
@@ -0,0 +1,113 @@
+ // cursor.inl -*-c++-*-
+#ifndef CURSOR_INL
+#define CURSOR_INL
+#include <assert.h>
+
+
+template<class T>
+inline
+Cursor<T>::Cursor( const List<T>& list, Link<T>* pointer ) : 
+    list_((List<T>&) list )
+{
+    if ( list.size() )
+        pointer_ = pointer ? pointer : list.top_;
+    else
+        pointer_ = pointer;
+}
+
+template<class T>
+inline
+Cursor<T>::Cursor( const Cursor<T>& cursor ) :
+    list_( cursor.list_ )
+{
+    pointer_ = cursor.pointer_;
+}
+
+template<class T>
+inline T&
+Cursor<T>::thing()
+{
+    assert( pointer_ );
+    return pointer_->thing();
+}
+
+template<class T>
+Cursor<T>
+Cursor<T>::operator =( const Cursor<T>& c )
+{   
+    assert( &list_ == &c.list_ );
+    pointer_ = c.pointer_;
+    return *this;
+}
+
+template<class T>
+inline void
+Cursor<T>::add( const T& th )
+{
+    list_.add( th, *this );
+}
+
+template<class T>
+inline void
+Cursor<T>::insert( const T& th )
+{
+    list_.insert( th, *this );
+}
+
+template<class T>
+inline  List<T>&
+Cursor<T>::list() const
+{
+    return list_;
+}
+
+template<class T>
+inline Link<T>*
+Cursor<T>::pointer()
+{
+    return pointer_;
+}
+
+template<class T>
+inline bool
+Cursor<T>::backward()
+{
+    return ( pointer_ != 0 );
+}
+
+template<class T>
+inline bool
+Cursor<T>::forward()
+{
+    return ( pointer_ != 0 );
+}
+
+template<class T>
+inline bool
+Cursor<T>::ok()
+{
+    return ( pointer_ != 0 );
+}
+
+
+template<class T>
+inline Cursor<T> 
+Cursor<T>::operator ++( int )    
+{
+    Cursor<T> r (*this);
+    assert( pointer_ );
+    pointer_ = pointer_->next();
+    return r;
+}
+
+template<class T>
+inline Cursor<T>
+Cursor<T>::operator --( int )
+{
+    Cursor<T> r (*this);
+    assert( pointer_ );
+    pointer_ = pointer_->previous();
+    return r;
+}
+
+#endif
diff --git a/flower/include/link.inl b/flower/include/link.inl
new file mode 100644
index 0000000000..3926d6bc2a
--- /dev/null
+++ b/flower/include/link.inl
@@ -0,0 +1,102 @@
+// link.inl -*-c++-*-
+#ifndef LINK_INL
+#define LINK_INL
+#include <assert.h>
+template<class T>
+inline
+void
+Link<T>::OK() const
+{
+#ifndef NDEBUG
+    if (previous_) {
+	assert(previous_->next_ == this);
+    }
+    if (next_) {
+	assert(next_->previous_ == this);
+    }
+#endif    
+}
+
+template<class T>
+inline
+Link<T>::Link( const T& thing ) : 
+    thing_( thing )
+{
+    previous_ = next_ = 0;
+}
+
+template<class T>
+inline
+Link<T>::Link( Link<T>* previous, Link<T>* next, const T& thing ) : 
+    thing_( thing )
+{
+    previous_ = previous;
+    next_ = next;
+}
+
+template<class T>
+inline
+Link<T>*
+Link<T>::next()
+{
+    return next_;
+}
+
+template<class T>
+inline
+Link<T>*
+Link<T>::previous()
+{
+    return previous_;
+}
+
+template<class T>
+inline
+void
+Link<T>::add( const T& thing )
+{
+    
+    Link<T>* l = new Link<T>( this, next_, thing );
+    if ( next_ )
+        next_->previous_ = l;
+    next_ = l;
+}
+
+template<class T>
+inline void
+Link<T>::insert( const T& thing )
+{
+    //    Link<T>* l = new Link<T>( next_, this, thing );
+				// bugfix hwn 16/9/96
+    Link<T>* l = new Link<T>( previous_, this, thing );
+    if ( previous_ )
+        previous_->next_ = l;
+    previous_ = l;
+}
+
+/*
+    don't forget to adjust #l#'s top_ and bottom_.
+    */
+template<class T>
+inline void
+Link<T>::remove(List<T> &l)
+{
+    if ( previous_ ) 
+        previous_->next_ = next_;
+    else 
+	l.top_ = next_;
+
+    if ( next_ )
+        next_->previous_ = previous_;
+    else
+	l.bottom_ = previous_;
+}
+
+template<class T>
+inline
+T&
+Link<T>::thing()
+{
+    return thing_;
+}
+#endif
diff --git a/flower/include/list.inl b/flower/include/list.inl
new file mode 100644
index 0000000000..df0687b7c8
--- /dev/null
+++ b/flower/include/list.inl
@@ -0,0 +1,56 @@
+// -*-c++-*-
+
+#ifndef LIST_INL
+#define LIST_INL
+
+template<class T>
+inline
+List<T>::List()
+{
+    set_empty();
+}
+
+template<class T>
+inline void
+List<T>::set_empty()
+{
+    top_ = bottom_ = 0;
+    size_ = 0;
+}
+
+template<class T>
+inline void
+List<T>::remove( Cursor<T> me )
+{
+    if ( me.ok() ){
+	Link<T> *lp = me.pointer();	
+	lp->remove(*this);
+	delete lp;
+        size_--;
+    }
+}
+
+template<class T>
+inline int
+List<T>::size() const
+{ 
+    return size_;
+}
+
+template<class T>
+inline Cursor<T>
+List<T>::top()const
+{
+    return Cursor<T>( *this, top_ );
+}
+
+
+template<class T>
+inline Cursor<T>
+List<T>::bottom()const
+{
+    return Cursor<T>( *this, bottom_ );
+}
+
+
+#endif
diff --git a/flower/include/plist.inl b/flower/include/plist.inl
new file mode 100644
index 0000000000..82be364334
--- /dev/null
+++ b/flower/include/plist.inl
@@ -0,0 +1,21 @@
+/* -*-c++-*-
+  plist.inl -- part of flowerlib
+
+  (c) 1996 Han-Wen Nienhuys& Jan Nieuwenhuizen
+*/
+
+#ifndef PLIST_INL
+#define PLIST_INL
+
+template<class T>
+void
+PL_copy(IPointerList<T*> &to, IPointerList<T*> const&src)
+{
+    for (PCursor<T*> pc(src); pc.ok(); pc++) {
+	T *q = pc;
+	T *p=new T(*q) ; 
+	to.bottom().add(p);
+    }
+}
+
+#endif
diff --git a/flower/include/string-data.inl b/flower/include/string-data.inl
new file mode 100644
index 0000000000..d2b925d0ce
--- /dev/null
+++ b/flower/include/string-data.inl
@@ -0,0 +1,210 @@
+/* -*-C++-*-
+  String_data.inl -- implement String_data
+
+  source file of Flower lib
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+#ifndef STRINGDATA_INL
+#define STRINGDATA_INL
+
+#include <assert.h>
+#include <memory.h>
+
+#include "string-data.hh"
+const int INITIALMAX=8;
+
+#include <sys/types.h>
+
+INLINE void 
+String_data::OKW() 
+{
+    assert (references == 1);
+}
+
+INLINE void 
+String_data::OK() 
+{
+    assert(maxlen >= length_i_);
+    assert(bool(data_byte_p_));
+    assert(references >= 1);
+}
+
+
+INLINE
+String_data::String_data() 
+{
+    references=0;
+    maxlen = INITIALMAX;
+    data_byte_p_ = new Byte[maxlen + 1];
+    data_byte_p_[0] = 0;
+    length_i_ = 0;
+}
+
+INLINE
+String_data::String_data(String_data const &src) 
+{
+    references=0;	
+    maxlen = length_i_ = src.length_i_;		
+    data_byte_p_ = new Byte[maxlen+1]; // should calc GNU 8byte overhead. 	
+    memcpy( data_byte_p_, src.data_byte_p_, length_i_ + 1 );	
+}
+
+INLINE
+String_data::~String_data() 
+{
+    assert(references == 0);
+    delete[] data_byte_p_;
+}
+
+INLINE void 
+String_data::setmax(int j) 
+{	
+    OKW();
+    if (j > maxlen) {
+	delete data_byte_p_;
+	maxlen = j;
+	data_byte_p_ = new Byte[maxlen + 1];
+    
+	data_byte_p_[0] = 0;
+	length_i_ = 0;
+    }
+}
+
+/* this is all quite hairy:  
+	 update of length_i_
+	 update of maxlen
+	 alloc of buffer
+	 copying of buffer
+ needs blondification: 
+ 	split tasks
+	define change authority
+*/
+INLINE void 
+String_data::remax(int j) 
+{
+    OKW();
+    if (j > maxlen) {
+	Byte *p = new Byte[j + 1];	
+	memcpy( p, data_byte_p_, ( maxlen <? length_i_ ) + 1 );	    
+	maxlen = j;
+	delete[] data_byte_p_;
+	data_byte_p_ = p;
+    }
+}
+
+INLINE void 
+String_data::tighten() 
+{ // should be dec'd const
+    maxlen = length_i_;
+    Byte *p = new Byte[maxlen + 1];	    
+    memcpy( p, data_byte_p_, length_i_ + 1 );	    
+    delete[] data_byte_p_;
+    data_byte_p_ = p;		
+}
+// assignment.
+INLINE void 
+String_data::set( Byte const* byte_c_l, int length_i ) 
+{
+    OKW();
+
+    assert( byte_c_l && byte_c_l != data_byte_p_);
+
+    length_i_ = length_i;
+    remax( length_i_ );     // copies too
+    memcpy( data_byte_p_, byte_c_l, length_i_ );
+    data_byte_p_[ length_i_ ] = 0;
+}
+
+INLINE
+void 
+String_data::set( char const* ch_c_l ) 
+{
+    set( (Byte const*)ch_c_l, strlen( ch_c_l ) );
+}
+
+
+/// concatenation.
+INLINE void 
+String_data::append( Byte const* byte_c_l, int length_i ) 
+{
+    OK();
+    OKW();
+    int old_i = length_i_;
+    
+    length_i_ += length_i;
+    remax( length_i_ );
+    memcpy( data_byte_p_ + old_i, byte_c_l, length_i );	
+    data_byte_p_[ length_i_ ] = 0;
+}
+
+INLINE
+void 
+String_data::operator += ( char const* ch_c_l ) 
+{
+    append( (Byte const*)ch_c_l, strlen( ch_c_l ) );
+}
+
+
+
+INLINE
+char const*
+String_data::ch_c_l() const
+{
+    return (char const*)data_byte_p_; 
+}
+INLINE char* 
+String_data::ch_l() 
+{ 
+    return (char*)data_byte_p_; 
+}
+
+INLINE Byte const*
+String_data::byte_c_l() const 
+{ 
+    return data_byte_p_; 
+}
+
+INLINE Byte* 
+String_data::byte_l() 
+{
+    OKW();
+    return data_byte_p_;
+}
+
+INLINE
+void 
+String_data::trunc(int j) 
+{
+    OKW(); 
+    assert(j >= 0 && j <= length_i_);
+    data_byte_p_[j] = 0;
+    length_i_ = j;
+}
+
+INLINE bool
+String_data::is_binary_bo()const
+{
+//    return !memchr(data_byte_p_, length_i_, 0);
+    return ( (int)strlen( (char const*)data_byte_p_ ) != length_i_ );
+}
+
+INLINE Byte&
+String_data::operator [](int j) 
+{
+    assert(j >= 0 && j <= length_i_);
+    return data_byte_p_[j] ; 
+}
+
+INLINE Byte 
+String_data::operator [](int j) const 
+{
+    assert(j >= 0 && j <= length_i_);
+    return data_byte_p_[j]; 
+}
+
+
+
+
+#endif // __STRING_UTIL_CC //
diff --git a/flower/include/string-handle.inl b/flower/include/string-handle.inl
new file mode 100644
index 0000000000..1f1d44ab13
--- /dev/null
+++ b/flower/include/string-handle.inl
@@ -0,0 +1,156 @@
+/* -*-c++-*-
+   
+  stringhandle.inl -- implement String_handle
+
+  source file of Flower lib
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+#ifndef STRINGHANDLE_INL
+#define STRINGHANDLE_INL
+
+#include <assert.h>
+#include <memory.h>
+
+#include "string-data.hh"
+#include "string-handle.hh"
+
+INLINE void 
+String_handle::down() 
+{ 
+    if (!(--data->references)) delete data; data = 0; 
+}
+
+/// increase ref count
+INLINE void 
+String_handle::up(String_data *d) 
+{ 
+    data=d; data->references ++; 
+}
+
+INLINE void 
+String_handle::copy() 
+{
+    if (data->references !=1){
+	String_data *newdata = new String_data(*data);
+	down();
+	up(newdata);
+    }
+}
+
+INLINE
+String_handle::String_handle() 
+{
+    up(new String_data);
+}
+
+INLINE
+String_handle::~String_handle() 
+{	
+    down();
+}    
+
+INLINE
+String_handle::String_handle(String_handle const & src) 
+{	
+    up(src.data);
+}
+
+INLINE Byte* 
+String_handle::byte_l() 
+{
+    copy();
+    return data->byte_l();
+}
+
+INLINE char* 
+String_handle::ch_l() 
+{
+    copy();
+    return (char*)data->byte_l();
+}
+
+INLINE Byte 
+const* String_handle::byte_c_l() const 
+{
+    return data->byte_c_l();
+}
+
+INLINE char const* 
+String_handle::ch_c_l() const 
+{
+    return (char const*)data->byte_c_l();
+}
+
+INLINE void 
+String_handle::operator =(String_handle const &src) 
+{
+    if (this == &src)
+	return;
+    down();
+    up(src.data);
+}
+
+INLINE void 
+String_handle::operator += (char const *s) 
+{	
+    copy();
+    *data += s;
+}    
+
+
+INLINE Byte 
+String_handle::operator[](int j) const 
+{ 
+    return (*data)[j]; 
+}
+
+// !NOT SAFE!
+// don't use this for loops. Use byte_c_l()
+INLINE Byte &
+String_handle::operator[](int j) 
+{
+    copy(); 	// hmm. Not efficient
+    return data->byte_l()[j];
+}
+
+INLINE void 
+String_handle::append( Byte const* byte_c_l, int length_i ) 
+{
+    copy();
+    data->append( byte_c_l, length_i );
+}
+			   
+INLINE void 
+String_handle::set( Byte const* byte_c_l, int length_i ) 
+{
+    copy();
+    data->set( byte_c_l, length_i );
+}
+			   
+INLINE void 
+String_handle::operator = (char const *p) 
+{
+    copy();
+    data->set( p );
+}
+			   
+INLINE void 
+String_handle::trunc(int j) 
+{
+    copy(); data->trunc(j); 
+}
+
+INLINE int 
+String_handle::length_i() const 
+{ 
+    return data->length_i_; 
+}
+
+INLINE bool
+String_handle::is_binary_bo() const {
+    return data->is_binary_bo();
+}
+
+#endif
-- 
2.39.5