Get rid of legacy build systems and rename cutl/ to libcutl/

4 files changed, 0 insertions, 444 deletions

diff --git a/cutl/shared-ptr/base.cxx b/cutl/shared-ptr/base.cxx
deleted file mode 100644
index 913e6f2..0000000
--- a/cutl/shared-ptr/base.cxx
+++ /dev/null
@@ -1,64 +0,0 @@
-// file      : cutl/shared-ptr/base.cxx
-// license   : MIT; see accompanying LICENSE file
-
-#include <cutl/shared-ptr/base.hxx>
-
-using std::size_t;
-
-//
-//
-cutl::share shared = cutl::share (1);
-cutl::share exclusive = cutl::share (2);
-
-//
-//
-namespace cutl
-{
-  char const* not_shared::
-  what () const LIBCUTL_NOTHROW_NOEXCEPT
-  {
-    return "object is not shared";
-  }
-}
-
-//
-//
-void*
-operator new (size_t n, cutl::share s)
-#ifndef LIBCUTL_CXX11
-  throw (std::bad_alloc)
-#endif
-{
-  if (s == shared)
-  {
-    // Here we need to make sure we don't break the alignment of the
-    // returned block. For that we need to know the maximum alignment
-    // of this platform. Twice the pointer size is a good guess for
-    // most platforms.
-    //
-    size_t* p = static_cast<size_t*> (operator new (n + 2 * sizeof (size_t)));
-    *p++ = 1;          // Initial count.
-    *p++ = 0xDEADBEEF; // Signature.
-    return p;
-  }
-  else
-    return operator new (n);
-
-}
-
-void
-operator delete (void* p, cutl::share s) LIBCUTL_NOTHROW_NOEXCEPT
-{
-  // This version of operator delete is only called when the c-tor
-  // fails. In this case there is no object and we can just free the
-  // memory.
-  //
-  if (s == shared)
-  {
-    size_t* sp = static_cast<size_t*> (p);
-    sp -= 2;
-    operator delete (sp);
-  }
-  else
-    operator delete (p);
-}
diff --git a/cutl/shared-ptr/base.hxx b/cutl/shared-ptr/base.hxx
deleted file mode 100644
index a37115b..0000000
--- a/cutl/shared-ptr/base.hxx
+++ /dev/null
@@ -1,102 +0,0 @@
-// file      : cutl/shared-ptr/base.hxx
-// license   : MIT; see accompanying LICENSE file
-
-#ifndef CUTL_SHARED_PTR_BASE_HXX
-#define CUTL_SHARED_PTR_BASE_HXX
-
-#include <new>
-#include <cstddef>   // std::size_t
-
-#include <cutl/exception.hxx>
-
-#include <cutl/details/config.hxx>
-#include <cutl/details/export.hxx>
-
-namespace cutl
-{
-  struct share
-  {
-    explicit
-    share (char id);
-
-    bool
-    operator== (share) const;
-
-  private:
-    char id_;
-  };
-}
-
-extern LIBCUTL_EXPORT cutl::share shared;
-extern LIBCUTL_EXPORT cutl::share exclusive;
-
-#ifdef LIBCUTL_CXX11
-LIBCUTL_EXPORT void*
-operator new (std::size_t, cutl::share);
-#else
-LIBCUTL_EXPORT void*
-operator new (std::size_t, cutl::share) throw (std::bad_alloc);
-#endif
-
-LIBCUTL_EXPORT void
-operator delete (void*, cutl::share) LIBCUTL_NOTHROW_NOEXCEPT;
-
-namespace cutl
-{
-  struct LIBCUTL_EXPORT not_shared: exception
-  {
-    virtual char const*
-    what () const LIBCUTL_NOTHROW_NOEXCEPT;
-  };
-
-  struct LIBCUTL_EXPORT shared_base
-  {
-    shared_base ();
-    shared_base (shared_base const&);
-    shared_base&
-    operator= (shared_base const&);
-
-    void
-    _inc_ref ();
-
-    bool
-    _dec_ref ();
-
-    std::size_t
-    _ref_count () const;
-
-#ifdef LIBCUTL_CXX11
-    void*
-    operator new (std::size_t, share);
-#else
-    void*
-    operator new (std::size_t, share) throw (std::bad_alloc);
-#endif
-
-    void
-    operator delete (void*, share) LIBCUTL_NOTHROW_NOEXCEPT;
-
-    void
-    operator delete (void*) LIBCUTL_NOTHROW_NOEXCEPT;
-
-  protected:
-    std::size_t counter_;
-  };
-
-  template <typename X>
-  inline X*
-  inc_ref (X*);
-
-  template <typename X>
-  inline void
-  dec_ref (X*);
-
-  template <typename X>
-  inline std::size_t
-  ref_count (X const*);
-}
-
-#include <cutl/shared-ptr/base.ixx>
-#include <cutl/shared-ptr/base.txx>
-
-#endif // CUTL_SHARED_PTR_BASE_HXX
diff --git a/cutl/shared-ptr/base.ixx b/cutl/shared-ptr/base.ixx
deleted file mode 100644
index 21ea856..0000000
--- a/cutl/shared-ptr/base.ixx
+++ /dev/null
@@ -1,80 +0,0 @@
-// file      : cutl/shared-ptr/base.ixx
-// license   : MIT; see accompanying LICENSE file
-
-namespace cutl
-{
-  // share
-  //
-
-  inline share::
-  share (char id)
-      : id_ (id)
-  {
-  }
-
-  inline bool share::
-  operator== (share x) const
-  {
-    return id_ == x.id_;
-  }
-
-  // shared_base
-  //
-
-  inline shared_base::
-  shared_base ()
-      : counter_ (1)
-  {
-  }
-
-  inline shared_base::
-  shared_base (shared_base const&)
-      : counter_ (1)
-  {
-  }
-
-  inline shared_base& shared_base::
-  operator= (shared_base const&)
-  {
-    return *this;
-  }
-
-  inline void shared_base::
-  _inc_ref ()
-  {
-    counter_++;
-  }
-
-  inline bool shared_base::
-  _dec_ref ()
-  {
-    return --counter_ == 0;
-  }
-
-  inline std::size_t shared_base::
-  _ref_count () const
-  {
-    return counter_;
-  }
-
-  inline void* shared_base::
-  operator new (std::size_t n, share)
-#ifndef LIBCUTL_CXX11
-    throw (std::bad_alloc)
-#endif
-  {
-    return ::operator new (n);
-  }
-
-  inline void shared_base::
-  operator delete (void* p, share) LIBCUTL_NOTHROW_NOEXCEPT
-  {
-    ::operator delete (p);
-  }
-
-  inline void shared_base::
-  operator delete (void* p) LIBCUTL_NOTHROW_NOEXCEPT
-  {
-    ::operator delete (p);
-  }
-}
diff --git a/cutl/shared-ptr/base.txx b/cutl/shared-ptr/base.txx
deleted file mode 100644
index d483481..0000000
--- a/cutl/shared-ptr/base.txx
+++ /dev/null
@@ -1,198 +0,0 @@
-// file      : cutl/shared-ptr/base.txx
-// license   : MIT; see accompanying LICENSE file
-
-#include <cutl/meta/answer.hxx>
-#include <cutl/meta/polymorphic-p.hxx>
-
-namespace cutl
-{
-  namespace bits
-  {
-    // Support for locating the counter in the memory block.
-    //
-    template <typename X, bool poly = meta::polymorphic_p<X>::r>
-    struct locator;
-
-    template <typename X>
-    struct locator<X, false>
-    {
-      static std::size_t*
-      counter (X* x)
-      {
-        std::size_t* p (reinterpret_cast<std::size_t*> (x));
-
-        if (*(--p) != 0xDEADBEEF)
-          throw not_shared ();
-
-        return --p;
-      }
-    };
-
-    template <typename X>
-    struct locator<X, true>
-    {
-      static std::size_t*
-      counter (X* x)
-      {
-        std::size_t* p (
-          static_cast<std::size_t*> (
-            dynamic_cast<void*> (x)));
-
-        if (*(--p) != 0xDEADBEEF)
-          throw not_shared ();
-
-        return --p;
-      }
-    };
-
-    template <typename X>
-    std::size_t*
-    counter (X const* p)
-    {
-      return bits::locator<X>::counter (const_cast<X*> (p));
-    }
-
-    // Counter type and operations.
-    //
-    meta::no test (...);
-    meta::yes test (shared_base*);
-
-    template <typename X,
-              std::size_t A = sizeof (bits::test (reinterpret_cast<X*> (0)))>
-    struct counter_type;
-
-    template <typename X>
-    struct counter_type<X, sizeof (meta::no)>
-    {
-      typedef X r;
-    };
-
-    template <typename X>
-    struct counter_type<X, sizeof (meta::yes)>
-    {
-      typedef shared_base r;
-    };
-
-    template <typename X, typename Y>
-    struct counter_ops;
-
-    template <typename X>
-    struct counter_ops<X, X>
-    {
-      counter_ops (X const* p) : counter_ (p ? bits::counter (p) : 0) {}
-      counter_ops (counter_ops const& x) : counter_ (x.counter_) {}
-
-      template <typename Z>
-      counter_ops (counter_ops<Z, Z> const& x) : counter_ (x.counter_) {}
-
-      counter_ops&
-      operator= (counter_ops const& x)
-      {
-        counter_ = x.counter_;
-        return *this;
-      }
-
-      template <typename Z>
-      counter_ops&
-      operator= (counter_ops<Z, Z> const& x)
-      {
-        counter_ = x.counter_;
-        return *this;
-      }
-
-      void
-      reset (X const* p)
-      {
-        counter_ = p ? bits::counter (p) : 0;
-      }
-
-      void
-      inc (X*)
-      {
-        (*counter_)++;
-      }
-
-      void
-      dec (X* p)
-      {
-        if (--(*counter_) == 0)
-        {
-          p->~X ();
-          operator delete (counter_); // Counter is the top of the memory block.
-        }
-      }
-
-      std::size_t
-      count (X const*) const
-      {
-        return *counter_;
-      }
-
-      std::size_t* counter_;
-    };
-
-    template <typename Y>
-    struct counter_ops<shared_base, Y>
-    {
-      counter_ops (Y const*) {}
-      counter_ops (counter_ops const&) {}
-
-      template <typename Z>
-      counter_ops (counter_ops<shared_base, Z> const&) {}
-
-      counter_ops&
-      operator= (counter_ops const&)
-      {
-        return *this;
-      }
-
-      template <typename Z>
-      counter_ops&
-      operator= (counter_ops<shared_base, Z> const&)
-      {
-        return *this;
-      }
-
-      void
-      reset (Y const*) {}
-
-      void
-      inc (shared_base* p) {p->_inc_ref ();}
-
-      void
-      dec (Y* p)
-      {
-        if (static_cast<shared_base*> (p)->_dec_ref ())
-          delete p;
-      }
-
-      std::size_t
-      count (shared_base const* p) const {return p->_ref_count ();}
-    };
-  }
-
-  template <typename X>
-  inline X*
-  inc_ref (X* p)
-  {
-    bits::counter_ops<typename bits::counter_type<X>::r, X> c (p);
-    c.inc (p);
-    return p;
-  }
-
-  template <typename X>
-  inline void
-  dec_ref (X* p)
-  {
-    bits::counter_ops<typename bits::counter_type<X>::r, X> c (p);
-    c.dec (p);
-  }
-
-  template <typename X>
-  inline std::size_t
-  ref_count (X const* p)
-  {
-    bits::counter_ops<typename bits::counter_type<X>::r, X> c (p);
-    return c.count (p);
-  }
-}