This commit was manufactured by cvs2svn to create branch 'conversion'.

[SVN r7663]

include/boost/cstdint.hpp

@@ -0,0 +1,63 @@
+//  boost cstdint.hpp header file  -------------------------------------------//
+
+//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
+//    8 Aug 99  Initial version
+
+#ifndef BOOST_CSTDINT_HPP
+#define BOOST_CSTDINT_HPP
+
+#include <limits.h> // implementation artifact; not part of interface
+
+#include <boost/stdint.h>
+
+namespace boost
+{
+
+  using ::int8_t;             
+  using ::int_least8_t;       
+  using ::int_fast8_t;        
+  using ::uint8_t;            
+  using ::uint_least8_t;      
+  using ::uint_fast8_t;       
+                     
+  using ::int16_t;            
+  using ::int_least16_t;      
+  using ::int_fast16_t;       
+  using ::uint16_t;           
+  using ::uint_least16_t;     
+  using ::uint_fast16_t;      
+                     
+  using ::int32_t;            
+  using ::int_least32_t;      
+  using ::int_fast32_t;       
+  using ::uint32_t;           
+  using ::uint_least32_t;     
+  using ::uint_fast32_t;      
+                     
+# ifdef ULLONG_MAX
+
+  using ::int64_t;            
+  using ::int_least64_t;      
+  using ::int_fast64_t;       
+  using ::uint64_t;           
+  using ::uint_least64_t;     
+  using ::uint_fast64_t;      
+                     
+# endif
+
+  using ::intmax_t;      
+  using ::uintmax_t;     
+
+} // namespace boost
+
+#endif
+ 

include/boost/integer.hpp

@@ -0,0 +1,79 @@
+//  boost integer.hpp header file  -------------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//   28 Aug 99  Initial version
+
+#ifndef BOOST_INTEGER_HPP
+#define BOOST_INTEGER_HPP
+
+#include <limits>
+
+namespace boost
+{
+
+  //  Helper templates  ------------------------------------------------------//
+
+  //  fast integers from least integers
+  template< typename LeastInt >
+  struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
+
+  //  convert category to type 
+  template< int Category > struct int_least_helper {}; // default is empty
+
+  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
+  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long
+  template<> struct int_least_helper<1> { typedef long least; };
+  template<> struct int_least_helper<2> { typedef int least; };
+  template<> struct int_least_helper<3> { typedef short least; };
+  template<> struct int_least_helper<4> { typedef signed char least; };
+  template<> struct int_least_helper<6> { typedef unsigned long least; };
+  template<> struct int_least_helper<7> { typedef unsigned int least; };
+  template<> struct int_least_helper<8> { typedef unsigned short least; };
+  template<> struct int_least_helper<9> { typedef unsigned char least; };
+
+  //  integer templates specifying number of bits  ---------------------------//
+
+  //  signed
+  template< int Bits >   // bits (including sign) required
+  struct int_t 
+  {
+      typedef int_least_helper
+        <
+          (Bits-1 <= std::numeric_limits<long>::digits) +
+          (Bits-1 <= std::numeric_limits<int>::digits) +
+          (Bits-1 <= std::numeric_limits<short>::digits) +
+          (Bits-1 <= std::numeric_limits<signed char>::digits)
+        >::least  least;
+      typedef int_fast_t<least>::fast  fast;
+  };
+
+  //  unsigned
+  template< int Bits >   // bits required
+  struct uint_t 
+  {
+      typedef int_least_helper
+        < 
+          5 +
+          (Bits <= std::numeric_limits<unsigned long>::digits) +
+          (Bits <= std::numeric_limits<unsigned int>::digits) +
+          (Bits <= std::numeric_limits<unsigned short>::digits) +
+          (Bits <= std::numeric_limits<unsigned char>::digits)
+        >::least  least;
+      typedef int_fast_t<least>::fast  fast;
+  };
+
+//  The same dispatching technique can be used to select types based on
+//  values.  That will be added once boost::integer_traits is available.
+
+
+} // namespace boost
+
+#endif  // BOOST_INTEGER_HPP

include/boost/integer_traits.hpp

@@ -0,0 +1,147 @@
+/* boost integer_traits.hpp header file
+ *
+ * Copyright Jens Maurer 2000
+ * Permission to use, copy, modify, sell, and distribute this software
+ * is hereby granted without free provided that the above copyright notice
+ * appears in all copies and that both that copyright notice and this
+ * permission notice appear in supporting documentation,
+ *
+ * Jens Maurer makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * $Id$
+ *
+ * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
+ */
+
+#ifndef BOOST_INTEGER_TRAITS_HPP
+#define BOOST_INTEGER_TRAITS_HPP
+
+#include <limits>
+#include <boost/config.hpp>
+
+// This is an implementation detail and not part of the interface
+#include <limits.h>
+
+
+namespace boost {
+template<class T>
+class integer_traits : public std::numeric_limits<T>
+{
+public:
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+  static const bool is_integral = false;
+#else
+  enum { is_integral = false };
+#endif
+};
+
+namespace detail {
+template<class T, T min_val, T max_val>
+class integer_traits_base
+{
+public:
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+  static const bool is_integral = true;
+  static const T const_min = min_val;
+  static const T const_max = max_val;
+#else
+  enum {
+    is_integral = true,
+    const_min = min_val,
+    const_max = max_val
+  };
+#endif
+};
+} // namespace detail
+
+template<>
+class integer_traits<bool>
+  : public std::numeric_limits<bool>,
+    public detail::integer_traits_base<bool, false, true>
+{ };
+
+template<>
+class integer_traits<char>
+  : public std::numeric_limits<char>,
+    public detail::integer_traits_base<char, CHAR_MIN, CHAR_MAX>
+{ };
+
+template<>
+class integer_traits<signed char>
+  : public std::numeric_limits<signed char>,
+    public detail::integer_traits_base<signed char, SCHAR_MIN, SCHAR_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned char>
+  : public std::numeric_limits<unsigned char>,
+    public detail::integer_traits_base<unsigned char, 0, UCHAR_MAX>
+{ };
+
+// What about wchar_t ?
+
+template<>
+class integer_traits<short>
+  : public std::numeric_limits<short>,
+    public detail::integer_traits_base<short, SHRT_MIN, SHRT_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned short>
+  : public std::numeric_limits<unsigned short>,
+    public detail::integer_traits_base<unsigned short, 0, USHRT_MAX>
+{ };
+
+template<>
+class integer_traits<int>
+  : public std::numeric_limits<int>,
+    public detail::integer_traits_base<int, INT_MIN, INT_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned int>
+  : public std::numeric_limits<unsigned int>,
+    public detail::integer_traits_base<unsigned int, 0, UINT_MAX>
+{ };
+
+template<>
+class integer_traits<long>
+  : public std::numeric_limits<long>,
+    public detail::integer_traits_base<long, LONG_MIN, LONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long>
+  : public std::numeric_limits<unsigned long>,
+    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
+{ };
+
+#ifdef ULLONG_MAX
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
+{ };
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, ULLONG_MAX>
+{ };
+#elif defined(ULONG_LONG_MAX)
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>
+{ };
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
+{ };
+#endif
+
+} // namespace boost
+
+#endif /* BOOST_INTEGER_TRAITS_HPP */

include/boost/stdint.h

@@ -0,0 +1,119 @@
+ //  boost stdint.h header file  ---------------------------------------------//
+
+//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  NOTE WELL: C++ programs are advised to use <boost/cstdint.hpp> rather than
+//  this header.
+
+//  Revision History
+//    8 Aug 99  Initial version
+
+#ifndef BOOST_STDINT_H
+#define BOOST_STDINT_H
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_SYSTEM_HAS_STDINT_H
+#include <stdint.h>
+
+#else
+
+//  This is not a complete implementation of the 1999 C Standard stdint.h
+//  header; it doesn't supply various macros which are not advisable for use in
+//  C++ programs.
+
+#include <limits.h> // implementation artifact; not part of interface
+
+//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
+//  platforms.  For other systems, they will have to be hand tailored.
+//  Because the fast types are assumed to be the same as the undecorated types,
+//  it may be possible to hand tailor a more efficient implementation.
+
+//  8-bit types  -------------------------------------------------------------//
+
+# if UCHAR_MAX == 0xff
+     typedef signed char     int8_t;
+     typedef signed char     int_least8_t;
+     typedef signed char     int_fast8_t;
+     typedef unsigned char   uint8_t;
+     typedef unsigned char   uint_least8_t;
+     typedef unsigned char   uint_fast8_t;
+# else
+#    error defaults not correct; you must hand modify boost/stdint.hpp
+# endif
+
+//  16-bit types  ------------------------------------------------------------//
+
+# if USHRT_MAX == 0xffff
+     typedef short           int16_t;
+     typedef short           int_least16_t;
+     typedef short           int_fast16_t;
+     typedef unsigned short  uint16_t;
+     typedef unsigned short  uint_least16_t;
+     typedef unsigned short  uint_fast16_t;
+# else
+#    error defaults not correct; you must hand modify boost/stdint.hpp
+# endif
+
+//  32-bit types  ------------------------------------------------------------//
+
+# if UINT_MAX == 0xffffffff
+     typedef int             int32_t;
+     typedef int             int_least32_t;
+     typedef int             int_fast32_t;
+     typedef unsigned int    uint32_t;
+     typedef unsigned int    uint_least32_t;
+     typedef unsigned int    uint_fast32_t;
+# elif ULONG_MAX == 0xffffffff
+     typedef long            int32_t;
+     typedef long            int_least32_t;
+     typedef long            int_fast32_t;
+     typedef unsigned long   uint32_t;
+     typedef unsigned long   uint_least32_t;
+     typedef unsigned long   uint_fast32_t;
+# else
+#    error defaults not correct; you must hand modify boost/stdint.hpp
+# endif
+
+//  64-bit types + intmax_t and uintmax_t  -----------------------------------//
+
+# ifdef ULLONG_MAX
+#    if ULLONG_MAX == 18446744073709551615 // 2**64 - 1
+     typedef long long            intmax_t;
+     typedef unsigned long long   uintmax_t;
+     typedef long long            int64_t;
+     typedef long long            int_least64_t;
+     typedef long long            int_fast64_t;
+     typedef unsigned long long   uint64_t;
+     typedef unsigned long long   uint_least64_t;
+     typedef unsigned long long   uint_fast64_t;
+#    else
+#       error defaults not correct; you must hand modify boost/stdint.hpp
+#    endif
+# elif ULONG_MAX != 0xffffffff
+
+#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
+     typedef long                 intmax_t;
+     typedef unsigned long        uintmax_t;
+     typedef long                 int64_t;
+     typedef long                 int_least64_t;
+     typedef long                 int_fast64_t;
+     typedef unsigned long        uint64_t;
+     typedef unsigned long        uint_least64_t;
+     typedef unsigned long        uint_fast64_t;
+#    else
+#       error defaults not correct; you must hand modify boost/stdint.hpp
+#    endif
+# else // assume no 64-bit integers
+     typedef int32_t              intmax_t;
+     typedef uint32_t             uintmax_t;
+# endif
+
+#endif  // BOOST_SYSTEM_HAS_STDINT_H not defined
+#endif  // BOOST_STDINT_H