[Boost-commit] svn:boost r81846 - in trunk/boost/archive: . impl iterators

Subject: [Boost-commit] svn:boost r81846 - in trunk/boost/archive: . impl iterators
From: ramey_at_[hidden]
Date: 2012-12-11 00:32:10

Author: ramey
Date: 2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
New Revision: 81846
URL: http://svn.boost.org/trac/boost/changeset/81846

Log:
fixed problem where base64 read un initialized memory
made sure base64 zero filled.
made base64 lines 76 char wide in accordance with the standard
fixed gcc error message re looser throw constaints
Text files modified: 
   trunk/boost/archive/archive_exception.hpp            |    10 +-                                      
   trunk/boost/archive/impl/basic_text_iprimitive.ipp   |    18 ++--                                    
   trunk/boost/archive/impl/basic_text_oprimitive.ipp   |     2                                         
   trunk/boost/archive/iterators/binary_from_base64.hpp |     2                                         
   trunk/boost/archive/iterators/istream_iterator.hpp   |    24 +++++-                                  
   trunk/boost/archive/iterators/transform_width.hpp    |   138 ++++++++++++++++++++------------------- 
   6 files changed, 104 insertions(+), 90 deletions(-)

Modified: trunk/boost/archive/archive_exception.hpp
==============================================================================
--- trunk/boost/archive/archive_exception.hpp	(original)
+++ trunk/boost/archive/archive_exception.hpp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -43,6 +43,8 @@
 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 @@
                             // 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 @@
         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();
 };
 

Modified: trunk/boost/archive/impl/basic_text_iprimitive.ipp
==============================================================================
--- trunk/boost/archive/impl/basic_text_iprimitive.ipp	(original)
+++ trunk/boost/archive/impl/basic_text_iprimitive.ipp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -86,23 +86,21 @@
             ,CharType
         > 
         binary;
-
-    binary ti_begin = binary(
+        
+    binary i = binary(
         BOOST_MAKE_PFTO_WRAPPER(
             iterators::istream_iterator<CharType>(is)
         )
     );
-                
+
     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();
@@ -112,7 +110,7 @@
             break;
     }
 }
-
+    
 template<class IStream>
 BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
 basic_text_iprimitive<IStream>::basic_text_iprimitive(

Modified: trunk/boost/archive/impl/basic_text_oprimitive.ipp
==============================================================================
--- trunk/boost/archive/impl/basic_text_oprimitive.ipp	(original)
+++ trunk/boost/archive/impl/basic_text_oprimitive.ipp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -51,7 +51,7 @@
                     8
                 >
             > 
-            ,72
+            ,76
             ,const char // cwpro8 needs this
         > 
         base64_text;

Modified: trunk/boost/archive/iterators/binary_from_base64.hpp
==============================================================================
--- trunk/boost/archive/iterators/binary_from_base64.hpp	(original)
+++ trunk/boost/archive/iterators/binary_from_base64.hpp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -43,7 +43,7 @@
             -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,

Modified: trunk/boost/archive/iterators/istream_iterator.hpp
==============================================================================
--- trunk/boost/archive/iterators/istream_iterator.hpp	(original)
+++ trunk/boost/archive/iterators/istream_iterator.hpp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -49,16 +49,17 @@
     > 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 @@
             }
         }
     }
+*/
+    //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 @@
     istream_iterator(istream_type & is) :
         m_istream(& is)
     {
-        increment();
+        //increment();
     }
 
     istream_iterator() :

Modified: trunk/boost/archive/iterators/transform_width.hpp
==============================================================================
--- trunk/boost/archive/iterators/transform_width.hpp	(original)
+++ trunk/boost/archive/iterators/transform_width.hpp	2012-12-11 00:32:06 EST (Tue, 11 Dec 2012)
@@ -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 @@
     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{
+                m_buffer_in = * this->base_reference()++;
+                m_remaining_bits = BitsIn;
+            }
         }
-        else
-            bcount = BitsIn - m_displacement;
-        unsigned int i = (std::min)(bcount, missing_bits);
+
+        // 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