Upgrade boost to version 1.53.0 and clipper to 5.03

include/boost/archive/archive_exception.hpp

@@ -43,6 +43,8 @@ namespace archive {
 class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) archive_exception : 
     public virtual std::exception
 {
+protected:
+    char m_buffer[128];
 public:
     typedef enum {
         no_exception,       // initialized without code
@@ -74,8 +76,6 @@ public:
                             // type has been instantiated in more than one module.
         output_stream_error // error on input stream
     } exception_code;
-protected:
-    std::string m_msg;
 public:
     exception_code code;
     archive_exception(
@@ -83,9 +83,11 @@ public:
         const char * e1 = NULL,
         const char * e2 = NULL
     );
-    ~archive_exception() throw ();
-    virtual const char *what( ) const throw();
+    virtual ~archive_exception() throw();
+    virtual const char *what() const throw();
 protected:
+    unsigned int
+    append(unsigned int l, const char * a);
     archive_exception();
 };
 

include/boost/archive/basic_archive.hpp

@@ -150,7 +150,8 @@ private:
     base_type t;
 public:
     object_id_type(): t(0) {};
-    explicit object_id_type(const unsigned int & t_) : t(t_){
+    // note: presumes that size_t >= unsigned int.
+    explicit object_id_type(const std::size_t & t_) : t(t_){
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
     object_id_type(const object_id_type & t_) : 

include/boost/archive/detail/basic_serializer_map.hpp

@@ -19,7 +19,7 @@
 #include <set>
 
 #include <boost/config.hpp>
-#include <boost/utility.hpp>
+#include <boost/noncopyable.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header

include/boost/archive/detail/iserializer.hpp

@@ -61,7 +61,7 @@ namespace std{
 
 #define DONT_USE_HAS_NEW_OPERATOR (                    \
     defined(__BORLANDC__)                              \
-    || defined(__IBMCPP__)                             \
+    || BOOST_WORKAROUND(__IBMCPP__, < 1210)            \
     || defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)     \
     || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
 )

include/boost/archive/impl/basic_text_iprimitive.ipp

@@ -87,7 +87,7 @@ basic_text_iprimitive<IStream>::load_binary(
         > 
         binary;
         
-    binary ti_begin = binary(
+    binary i = binary(
         BOOST_MAKE_PFTO_WRAPPER(
             iterators::istream_iterator<CharType>(is)
         )
@@ -96,13 +96,11 @@ basic_text_iprimitive<IStream>::load_binary(
     char * caddr = static_cast<char *>(address);
     
     // take care that we don't increment anymore than necessary
-    while(--count > 0){
-        *caddr++ = static_cast<char>(*ti_begin);
-        ++ti_begin;
+    while(count-- > 0){
+        *caddr++ = static_cast<char>(*i++);
     }
-    *caddr++ = static_cast<char>(*ti_begin);
 
-    iterators::istream_iterator<CharType> i;
+    // skip over any excess input
     for(;;){
         BOOST_DEDUCED_TYPENAME IStream::int_type r;
         r = is.get();

include/boost/archive/impl/basic_text_oprimitive.ipp

@@ -51,7 +51,7 @@ basic_text_oprimitive<OStream>::save_binary(
                     8
                 >
             > 
-            ,72
+            ,76
             ,const char // cwpro8 needs this
         > 
         base64_text;

include/boost/archive/iterators/binary_from_base64.hpp

@@ -43,7 +43,7 @@ struct to_6_bit {
             -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
             -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
             -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
-            52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
+            52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
             -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
             15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
             -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,

include/boost/archive/iterators/head_iterator.hpp

@@ -42,8 +42,8 @@ private:
     > super_t;
 
     typedef head_iterator<Predicate, Base> this_t;
-    typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
-    typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+    typedef super_t::value_type value_type;
+    typedef super_t::reference reference_type;
 
     reference_type dereference_impl(){
         if(! m_end){

include/boost/archive/iterators/istream_iterator.hpp

@@ -49,16 +49,17 @@ class istream_iterator :
     > super_t;
     typedef BOOST_DEDUCED_TYPENAME std::basic_istream<Elem> istream_type;
  
-    //Access the value referred to 
-    Elem dereference() const {
-        return m_current_value;
-    }
-
     bool equal(const this_t & rhs) const {
         // note: only  works for comparison against end of stream
         return m_istream == rhs.m_istream;
     }
 
+/*
+    //Access the value referred to 
+    Elem dereference() const {
+        return m_current_value;
+    }
+
     void increment(){
         if(NULL != m_istream){
             m_current_value = static_cast<Elem>(m_istream->get());
@@ -67,6 +68,17 @@ class istream_iterator :
             }
         }
     }
+*/
+    //Access the value referred to 
+    Elem dereference() const {
+        return m_istream->peek();
+    }
+
+    void increment(){
+        if(NULL != m_istream){
+            m_istream->ignore(1);
+        }
+    }
 
     istream_type *m_istream;
     Elem m_current_value;
@@ -74,7 +86,7 @@ public:
     istream_iterator(istream_type & is) :
         m_istream(& is)
     {
-        increment();
+        //increment();
     }
 
     istream_iterator() :

include/boost/archive/iterators/remove_whitespace.hpp

@@ -24,6 +24,7 @@
 
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/filter_iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
 
 //#include <boost/detail/workaround.hpp>
 //#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300)
@@ -140,13 +141,19 @@ public:
 template<class Base>
 class remove_whitespace : 
     public filter_iterator<
-        remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+        remove_whitespace_predicate<
+            BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+            //BOOST_DEDUCED_TYPENAME Base::value_type
+        >,
         Base
     >
 {
     friend class boost::iterator_core_access;
     typedef filter_iterator<
-        remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+        remove_whitespace_predicate<
+            BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+            //BOOST_DEDUCED_TYPENAME Base::value_type
+        >,
         Base
     > super_t;
 public:

include/boost/archive/iterators/transform_width.hpp

@@ -24,8 +24,6 @@
 // character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
 // or 3 8 bit characters
 
-#include <algorithm>
-
 #include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO
 #include <boost/serialization/pfto.hpp>
 
@@ -66,101 +64,105 @@ class transform_width :
     typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
     typedef BOOST_DEDUCED_TYPENAME iterator_value<Base>::type base_value_type;
 
-    CharType fill();
+    void fill();
 
-    CharType dereference_impl(){
-        if(! m_full){
-            m_current_value = fill();
-            m_full = true;
-        }
-        return m_current_value;
+    CharType dereference() const {
+        if(!m_buffer_out_full)
+            const_cast<this_t *>(this)->fill();
+        return m_buffer_out;
     }
 
-    CharType dereference() const {
-        return const_cast<this_t *>(this)->dereference_impl();
+    bool equal_impl(const this_t & rhs){
+        if(BitsIn < BitsOut) // discard any left over bits
+            return this->base_reference() == rhs.base_reference();
+        else{
+            // BitsIn > BitsOut  // zero fill
+            if(this->base_reference() == rhs.base_reference()){
+                m_end_of_sequence = true;
+                return 0 == m_remaining_bits;
+            }
+            return false;
+        }
     }
 
-    // test for iterator equality
+    // standard iterator interface
     bool equal(const this_t & rhs) const {
-        return
-            this->base_reference() == rhs.base_reference();
-        ;
+        return const_cast<this_t *>(this)->equal_impl(rhs);
     }
 
     void increment(){
-        m_displacement += BitsOut;
-
-        while(m_displacement >= BitsIn){
-            m_displacement -= BitsIn;
-            if(0 == m_displacement)
-                m_bufferfull = false;
-            if(! m_bufferfull){
-                // note: suspect that this is not invoked for borland
-                ++(this->base_reference());
-            }
-        }
-        m_full = false;
+        m_buffer_out_full = false;
     }
 
-    CharType m_current_value;
-    // number of bits left in current input character buffer
-    unsigned int m_displacement;
-    base_value_type m_buffer;
-    // flag to current output character is ready - just used to save time
-    bool m_full;
-    // flag to indicate that m_buffer has data
-    bool m_bufferfull;
+    bool m_buffer_out_full;
+    CharType m_buffer_out;
+
+    // last read element from input
+    base_value_type m_buffer_in;
+
+    // number of bits to left in the input buffer.
+    unsigned int m_remaining_bits;
+
+    // flag to indicate we've reached end of data.
+    bool m_end_of_sequence;
 
 public:
     // make composible buy using templated constructor
     template<class T>
     transform_width(BOOST_PFTO_WRAPPER(T) start) : 
         super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
-        m_displacement(0),
-        m_full(false),
-        m_bufferfull(false)
+        m_buffer_out_full(false),
+        m_remaining_bits(0),
+        m_end_of_sequence(false)
     {}
     // intel 7.1 doesn't like default copy constructor
     transform_width(const transform_width & rhs) : 
         super_t(rhs.base_reference()),
-        m_current_value(rhs.m_current_value),
-        m_displacement(rhs.m_displacement),
-        m_buffer(rhs.m_buffer),
-        m_full(rhs.m_full),
-        m_bufferfull(rhs.m_bufferfull)
+        m_buffer_out_full(rhs.m_buffer_out_full),
+        m_remaining_bits(rhs.m_remaining_bits),
+        m_buffer_in(rhs.m_buffer_in),
+        m_end_of_sequence(false)
     {}
 };
 
-template<class Base, int BitsOut, int BitsIn, class CharType>
-CharType transform_width<Base, BitsOut, BitsIn, CharType>::fill(){
-    CharType retval = 0;
+template<
+    class Base, 
+    int BitsOut, 
+    int BitsIn, 
+    class CharType
+>
+void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
     unsigned int missing_bits = BitsOut;
-    for(;;){
-        unsigned int bcount;
-        if(! m_bufferfull){
-            m_buffer = * this->base_reference();
-            m_bufferfull = true;
-            bcount = BitsIn;
+    m_buffer_out = 0;
+    do{
+        if(0 == m_remaining_bits){
+            if(m_end_of_sequence){
+                m_buffer_in = 0;
+                m_remaining_bits = missing_bits;
             }
-        else
-            bcount = BitsIn - m_displacement;
-        unsigned int i = (std::min)(bcount, missing_bits);
+            else{
+                m_buffer_in = * this->base_reference()++;
+                m_remaining_bits = BitsIn;
+            }
+        }
+
+        // append these bits to the next output
+        // up to the size of the output
+        unsigned int i = std::min(missing_bits, m_remaining_bits);
         // shift interesting bits to least significant position
-        unsigned int j = m_buffer >> (bcount - i);
-        // strip off uninteresting bits
-        // (note presumption of two's complement arithmetic)
-        j &= ~(-(1 << i));
+        base_value_type j = m_buffer_in >> (m_remaining_bits - i);
+        // and mask off the un interesting higher bits
+        // note presumption of twos complement notation
+        j &= (1 << i) - 1;
         // append then interesting bits to the output value
-        retval <<= i;
-        retval |= j;
+        m_buffer_out <<= i;
+        m_buffer_out |= j;
+
+        // and update counters
         missing_bits -= i;
-        if(0 == missing_bits)
-            break;
-        // note: suspect that this is not invoked for borland 5.51
-        ++(this->base_reference());
-        m_bufferfull = false;
-    }
-    return retval;
+        m_remaining_bits -= i;
+    }while(0 < missing_bits);
+    m_buffer_out_full = true;
 }
 
 } // namespace iterators