Install a library containing implementation objects. Make this actually

usable by installing <limits> and <memory> which implement parts of the
Standard C++ Library missing from the NetBSD toolchain.

4 files changed, 398 insertions, 0 deletions

diff --git a/devel/boost/files/Makefile b/devel/boost/files/Makefile
new file mode 100644
index 00000000000..e9946cc6540
--- /dev/null
+++ b/devel/boost/files/Makefile
@@ -0,0 +1,29 @@
+# $NetBSD: Makefile,v 1.1 2000/05/12 06:15:06 jlam Exp $
+
+CXX=		c++
+
+LIB=		libboost.la
+
+SRCS=		libs/timer/prg_display.cpp \
+		libs/timer/prg_timer.cpp \
+		libs/timer/timer.cpp
+OBJS=		${SRCS:.cpp=.lo}
+LOBJS=		${OBJS:T}
+
+CXXFLAGS=	# empty
+CPPFLAGS+=	-I${.CURDIR}
+
+all:	${LIB}
+
+${LIB}:	${LOBJS}
+	${LIBTOOL} --cplusplus ${CXX} ${CXXFLAGS} -o ${.TARGET} ${LOBJS} \
+		-rpath ${PREFIX}/lib -version-info ${BOOST_VERS}
+
+prg_display.lo:	libs/timer/prg_display.cpp
+	${LIBTOOL} ${CXX} ${CXXFLAGS} ${CPPFLAGS} -c ${.ALLSRC}
+
+prg_timer.lo:	libs/timer/prg_timer.cpp
+	${LIBTOOL} ${CXX} ${CXXFLAGS} ${CPPFLAGS} -c ${.ALLSRC}
+
+timer.lo:	libs/timer/timer.cpp
+	${LIBTOOL} ${CXX} ${CXXFLAGS} ${CPPFLAGS} -c ${.ALLSRC}
diff --git a/devel/boost/files/limits b/devel/boost/files/limits
new file mode 100644
index 00000000000..5b6af1d399e
--- /dev/null
+++ b/devel/boost/files/limits
@@ -0,0 +1,266 @@
+/* $NetBSD: limits,v 1.1 2000/05/12 06:15:06 jlam Exp $
+ *
+ * This file is a part of the ISO C++ standard, but is not present in current
+ * versions of NetBSD.  The contents of this file should probably be wrapped
+ * in a check for the appropriate version of the GNU C++ compiler or library.
+ */
+
+#ifndef STD_LIMITS
+#define STD_LIMITS
+
+#include <cfloat>
+#include <climits>
+
+namespace std {
+
+template <class T>
+class numeric_limits {
+public:
+    typedef T	numeric_type;
+
+    static const bool	is_specialized = false;
+};
+
+template <>
+class numeric_limits<char> {
+public:
+    typedef char	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = (CHAR_MIN == SCHAR_MIN);
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return CHAR_MIN; }
+    inline static numeric_type	max() throw() { return CHAR_MAX; }
+};
+
+template <>
+class numeric_limits<signed char> {
+public:
+    typedef char	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return SCHAR_MIN; }
+    inline static numeric_type	max() throw() { return SCHAR_MAX; }
+};
+
+template <>
+class numeric_limits<unsigned char> {
+public:
+    typedef unsigned char	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = false;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return 0; }
+    inline static numeric_type	max() throw() { return UCHAR_MAX; }
+};
+
+template <>
+class numeric_limits<short> {
+public:
+    typedef short	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return SHRT_MIN; }
+    inline static numeric_type	max() throw() { return SHRT_MAX; }
+};
+
+template <>
+class numeric_limits<unsigned short> {
+public:
+    typedef short	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = false;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return 0; }
+    inline static numeric_type	max() throw() { return USHRT_MAX; }
+};
+
+template <>
+class numeric_limits<int> {
+public:
+    typedef int	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return INT_MIN; }
+    inline static numeric_type	max() throw() { return INT_MAX; }
+};
+
+template <>
+class numeric_limits<unsigned int> {
+public:
+    typedef unsigned int	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = false;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return 0; }
+    inline static numeric_type	max() throw() { return UINT_MAX; }
+};
+
+template <>
+class numeric_limits<long> {
+public:
+    typedef long	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return LONG_MIN; }
+    inline static numeric_type	max() throw() { return LONG_MAX; }
+};
+
+template <>
+class numeric_limits<unsigned long> {
+public:
+    typedef unsigned long	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = false;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return 0; }
+    inline static numeric_type	max() throw() { return ULONG_MAX; }
+};
+
+template <>
+class numeric_limits<long long> {
+public:
+    typedef long long	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return LLONG_MIN; }
+    inline static numeric_type	max() throw() { return LLONG_MAX; }
+};
+
+template <>
+class numeric_limits<unsigned long long> {
+public:
+    typedef unsigned long long	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = sizeof (numeric_type) * CHAR_BIT;
+
+    static const bool	is_signed = false;
+    static const bool	is_integer = true;
+    static const bool	is_exact = true;
+
+    inline static numeric_type	min() throw() { return 0; }
+    inline static numeric_type	max() throw() { return ULLONG_MAX; }
+};
+
+template <>
+class numeric_limits<float> {
+public:
+    typedef float	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	radix = FLT_RADIX;
+    static const int	digits = FLT_MANT_DIG;
+    static const int	digits10 = FLT_DIG;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = false;
+    static const bool	is_exact = false;
+
+    inline static numeric_type	min() throw() { return FLT_MIN; }
+    inline static numeric_type	max() throw() { return FLT_MAX; }
+
+    inline static numeric_type	epsilon() throw() { return FLT_EPSILON; }
+
+    static const int	min_exponent = FLT_MIN_EXP;
+    static const int	min_exponent10 = FLT_MIN_10_EXP;
+    static const int	max_exponent = FLT_MAX_EXP;
+    static const int	max_exponent10 = FLT_MAX_10_EXP;
+
+    static const bool	has_infinity = false;
+};
+
+template <>
+class numeric_limits<double> {
+public:
+    typedef double	numeric_type;
+
+    static const bool	is_specialized = true;
+
+    static const int	digits = DBL_MANT_DIG;
+    static const int	digits10 = DBL_DIG;
+
+    static const bool	is_signed = true;
+    static const bool	is_integer = false;
+    static const bool	is_exact = false;
+
+    inline static numeric_type	min() throw() { return DBL_MIN; }
+    inline static numeric_type	max() throw() { return DBL_MAX; }
+
+    inline static numeric_type	epsilon() throw() { return DBL_EPSILON; }
+
+    static const int	min_exponent = DBL_MIN_EXP;
+    static const int	min_exponent10 = DBL_MIN_10_EXP;
+    static const int	max_exponent = DBL_MAX_EXP;
+    static const int	max_exponent10 = DBL_MAX_10_EXP;
+};
+
+} // namespace std
+
+#endif // STD_LIMITS
diff --git a/devel/boost/files/memory b/devel/boost/files/memory
new file mode 100644
index 00000000000..7d2a34a810c
--- /dev/null
+++ b/devel/boost/files/memory
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* $NetBSD: memory,v 1.1 2000/05/12 06:15:06 jlam Exp $
+ *
+ * Removed the #if 0'd code to enable auto_ptr.  This interface and
+ * implementation matches the ISO C++ requirements.
+ */
+
+#ifndef __SGI_STL_MEMORY
+#define __SGI_STL_MEMORY
+
+#include <stl_algobase.h>
+#include <stl_alloc.h>
+#include <stl_construct.h>
+#include <stl_tempbuf.h>
+#include <stl_uninitialized.h>
+#include <stl_raw_storage_iter.h>
+
+#ifdef __GNUC__
+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
+#    define _MUTABLE_IS_KEYWORD
+#    define _EXPLICIT_IS_KEYWORD
+#  endif
+#endif
+
+// Note: auto_ptr is commented out in this release because the details
+//  of the interface are still being discussed by the C++ standardization
+//  committee.  It will be included once the iterface is finalized.
+
+#if defined(_MUTABLE_IS_KEYWORD) && defined(_EXPLICIT_IS_KEYWORD) && \
+    defined(__STL_MEMBER_TEMPLATES)
+
+__STL_BEGIN_NAMESPACE
+
+template <class X> class auto_ptr {
+private:
+  X* ptr;
+  mutable bool owns;
+public:
+  typedef X element_type;
+  explicit auto_ptr(X* p = 0) __STL_NOTHROW : ptr(p), owns(p) {}
+  auto_ptr(const auto_ptr& a) __STL_NOTHROW : ptr(a.ptr), owns(a.owns) {
+    a.owns = 0;
+  }
+  template <class T> auto_ptr(const auto_ptr<T>& a) __STL_NOTHROW
+    : ptr(a.ptr), owns(a.owns) {
+      a.owns = 0;
+  }
+
+  auto_ptr& operator=(const auto_ptr& a) __STL_NOTHROW {
+    if (&a != this) {
+      if (owns)
+        delete ptr;
+      owns = a.owns;
+      ptr = a.ptr;
+      a.owns = 0;
+    }
+  }
+  template <class T> auto_ptr& operator=(const auto_ptr<T>& a) __STL_NOTHROW {
+    if (&a != this) {
+      if (owns)
+        delete ptr;
+      owns = a.owns;
+      ptr = a.ptr;
+      a.owns = 0;
+    }
+  }
+  ~auto_ptr() {
+    if (owns)
+      delete ptr;
+  }
+
+  X& operator*() const __STL_NOTHROW { return *ptr; }
+  X* operator->() const __STL_NOTHROW { return ptr; }
+  X* get() const __STL_NOTHROW { return ptr; }
+  X* release() const __STL_NOTHROW { owns = false; return ptr; }
+};
+
+__STL_END_NAMESPACE
+#endif /* mutable && explicit && member templates */
+
+
+#endif /* __SGI_STL_MEMORY */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/devel/boost/files/patch-sum b/devel/boost/files/patch-sum
new file mode 100644
index 00000000000..1984fd7e439
--- /dev/null
+++ b/devel/boost/files/patch-sum
@@ -0,0 +1,3 @@
+$NetBSD: patch-sum,v 1.1 2000/05/12 06:15:06 jlam Exp $
+
+MD5 (patch-aa) = bd5bc3075d9e9d43756aad989d654dc4