Fixes for 4471 - more Ice stream fixes

7 files changed, 569 insertions, 372 deletions

diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index 8afd1df630d..dff3c8394d6 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -7,6 +7,14 @@
 //
 // **********************************************************************
 
+//
+// We disable deprecation warning here, to allow clean compilation of
+// of deprecated methods from StreamI.h.
+//
+#ifdef _MSC_VER
+#   pragma warning( disable : 4996 )
+#endif
+
 #include <IceUtil/DisableWarnings.h>
 #include <IceUtil/ArgVector.h>
 #include <Ice/GC.h>
diff --git a/cpp/src/Ice/Stream.cpp b/cpp/src/Ice/Stream.cpp
index 20825a9aeab..ec2d636d901 100644
--- a/cpp/src/Ice/Stream.cpp
+++ b/cpp/src/Ice/Stream.cpp
@@ -15,14 +15,3 @@ using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(InputStream* p) { return p; }
 IceUtil::Shared* IceInternal::upCast(OutputStream* p) { return p; }
-
-Ice::ReadObjectCallbackI::ReadObjectCallbackI(PatchFunc func, void* arg) :
-    _func(func), _arg(arg)
-{
-}
-
-void
-Ice::ReadObjectCallbackI::invoke(const ::Ice::ObjectPtr& p)
-{
-    _func(_arg, const_cast< ::Ice::ObjectPtr& >(p));
-}
diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp
index 2189deed602..c9a1dbe5b24 100644
--- a/cpp/src/Ice/StreamI.cpp
+++ b/cpp/src/Ice/StreamI.cpp
@@ -7,6 +7,14 @@
 //
 // **********************************************************************
 
+//
+// We disable deprecation warning here, to allow clean compilation of
+// of deprecated methods.
+//
+#ifdef _MSC_VER
+#   pragma warning( disable : 4996 )
+#endif
+
 #include <Ice/StreamI.h>
 #include <Ice/Initialize.h>
 #include <Ice/LocalException.h>
@@ -54,7 +62,7 @@ Ice::InputStreamI::sliceObjects(bool b)
 }
 
 bool
-Ice::InputStreamI::internalReadBool()
+Ice::InputStreamI::readBool()
 {
     bool v;
     _is->read(v);
@@ -62,7 +70,7 @@ Ice::InputStreamI::internalReadBool()
 }
 
 vector<bool>
-Ice::InputStreamI::internalReadBoolSeq()
+Ice::InputStreamI::readBoolSeq()
 {
     vector<bool> v;
     _is->read(v);
@@ -70,13 +78,13 @@ Ice::InputStreamI::internalReadBoolSeq()
 }
 
 bool*
-Ice::InputStreamI::internalReadBoolSeq(pair<const bool*, const bool*>& p)
+Ice::InputStreamI::readBoolSeq(pair<const bool*, const bool*>& p)
 {
     return _is->read(p);
 }
 
 Byte
-Ice::InputStreamI::internalReadByte()
+Ice::InputStreamI::readByte()
 {
     Byte v;
     _is->read(v);
@@ -84,7 +92,7 @@ Ice::InputStreamI::internalReadByte()
 }
 
 vector<Byte>
-Ice::InputStreamI::internalReadByteSeq()
+Ice::InputStreamI::readByteSeq()
 {
     pair<const Byte*, const Byte*> p;
     _is->read(p);
@@ -93,13 +101,13 @@ Ice::InputStreamI::internalReadByteSeq()
 }
 
 void
-Ice::InputStreamI::internalReadByteSeq(pair<const Byte*, const Byte*>& p)
+Ice::InputStreamI::readByteSeq(pair<const Byte*, const Byte*>& p)
 {
     _is->read(p);
 }
 
 Short
-Ice::InputStreamI::internalReadShort()
+Ice::InputStreamI::readShort()
 {
     Short v;
     _is->read(v);
@@ -107,7 +115,7 @@ Ice::InputStreamI::internalReadShort()
 }
 
 vector<Short>
-Ice::InputStreamI::internalReadShortSeq()
+Ice::InputStreamI::readShortSeq()
 {
     vector<Short> v;
     _is->read(v);
@@ -115,13 +123,13 @@ Ice::InputStreamI::internalReadShortSeq()
 }
 
 Short*
-Ice::InputStreamI::internalReadShortSeq(pair<const Short*, const Short*>& p)
+Ice::InputStreamI::readShortSeq(pair<const Short*, const Short*>& p)
 {
     return _is->read(p);
 }
 
 Int
-Ice::InputStreamI::internalReadInt()
+Ice::InputStreamI::readInt()
 {
     Int v;
     _is->read(v);
@@ -129,7 +137,7 @@ Ice::InputStreamI::internalReadInt()
 }
 
 vector<Int>
-Ice::InputStreamI::internalReadIntSeq()
+Ice::InputStreamI::readIntSeq()
 {
     vector<Int> v;
     _is->read(v);
@@ -137,13 +145,13 @@ Ice::InputStreamI::internalReadIntSeq()
 }
 
 Int*
-Ice::InputStreamI::internalReadIntSeq(pair<const Int*, const Int*>& p)
+Ice::InputStreamI::readIntSeq(pair<const Int*, const Int*>& p)
 {
     return _is->read(p);
 }
 
 Long
-Ice::InputStreamI::internalReadLong()
+Ice::InputStreamI::readLong()
 {
     Long v;
     _is->read(v);
@@ -151,7 +159,7 @@ Ice::InputStreamI::internalReadLong()
 }
 
 vector<Long>
-Ice::InputStreamI::internalReadLongSeq()
+Ice::InputStreamI::readLongSeq()
 {
     vector<Long> v;
     _is->read(v);
@@ -159,13 +167,13 @@ Ice::InputStreamI::internalReadLongSeq()
 }
 
 Long*
-Ice::InputStreamI::internalReadLongSeq(pair<const Long*, const Long*>& p)
+Ice::InputStreamI::readLongSeq(pair<const Long*, const Long*>& p)
 {
     return _is->read(p);
 }
 
 Float
-Ice::InputStreamI::internalReadFloat()
+Ice::InputStreamI::readFloat()
 {
     Float v;
     _is->read(v);
@@ -173,7 +181,7 @@ Ice::InputStreamI::internalReadFloat()
 }
 
 vector<Float>
-Ice::InputStreamI::internalReadFloatSeq()
+Ice::InputStreamI::readFloatSeq()
 {
     vector<Float> v;
     _is->read(v);
@@ -181,13 +189,13 @@ Ice::InputStreamI::internalReadFloatSeq()
 }
 
 Float*
-Ice::InputStreamI::internalReadFloatSeq(pair<const Float*, const Float*>& p)
+Ice::InputStreamI::readFloatSeq(pair<const Float*, const Float*>& p)
 {
     return _is->read(p);
 }
 
 Double
-Ice::InputStreamI::internalReadDouble()
+Ice::InputStreamI::readDouble()
 {
     Double v;
     _is->read(v);
@@ -195,7 +203,7 @@ Ice::InputStreamI::internalReadDouble()
 }
 
 vector<Double>
-Ice::InputStreamI::internalReadDoubleSeq()
+Ice::InputStreamI::readDoubleSeq()
 {
     vector<Double> v;
     _is->read(v);
@@ -203,13 +211,13 @@ Ice::InputStreamI::internalReadDoubleSeq()
 }
 
 Double*
-Ice::InputStreamI::internalReadDoubleSeq(pair<const Double*, const Double*>& p)
+Ice::InputStreamI::readDoubleSeq(pair<const Double*, const Double*>& p)
 {
     return _is->read(p);
 }
 
 string
-Ice::InputStreamI::internalReadString(bool convert)
+Ice::InputStreamI::readString(bool convert)
 {
     string v;
     _is->read(v, convert);
@@ -217,7 +225,7 @@ Ice::InputStreamI::internalReadString(bool convert)
 }
 
 vector<string>
-Ice::InputStreamI::internalReadStringSeq(bool convert)
+Ice::InputStreamI::readStringSeq(bool convert)
 {
     vector<string> v;
     _is->read(v, convert);
@@ -225,7 +233,7 @@ Ice::InputStreamI::internalReadStringSeq(bool convert)
 }
 
 wstring
-Ice::InputStreamI::internalReadWstring()
+Ice::InputStreamI::readWstring()
 {
     wstring v;
     _is->read(v);
@@ -233,7 +241,7 @@ Ice::InputStreamI::internalReadWstring()
 }
 
 vector<wstring>
-Ice::InputStreamI::internalReadWstringSeq()
+Ice::InputStreamI::readWstringSeq()
 {
     vector<wstring> v;
     _is->read(v);
@@ -257,14 +265,17 @@ Ice::InputStreamI::readAndCheckSeqSize(int minSize)
 }
 
 ObjectPrx
-Ice::InputStreamI::internalReadProxy()
+Ice::InputStreamI::readProxy()
 {
     Ice::ObjectPrx v;
     _is->read(v);
     return v;
 }
 
-static void
+namespace 
+{
+
+void
 patchObject(void* addr, ObjectPtr& v)
 {
     ReadObjectCallback* cb = static_cast<ReadObjectCallback*>(addr);
@@ -272,6 +283,8 @@ patchObject(void* addr, ObjectPtr& v)
     cb->invoke(v);
 }
 
+}
+
 void
 Ice::InputStreamI::readObject(const ReadObjectCallbackPtr& cb)
 {
@@ -288,6 +301,108 @@ Ice::InputStreamI::readTypeId()
 }
 
 void
+Ice::InputStreamI::read(bool& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(::Ice::Byte& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(::Ice::Short& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(Ice::Int& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(Ice::Long& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(Ice::Float& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(Ice::Double& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(std::string& v, bool convert)
+{
+    _is->read(v, convert);
+}
+
+void
+Ice::InputStreamI::read(std::vector<std::string>& v, bool convert)
+{
+    _is->read(v, convert);
+}
+
+void
+Ice::InputStreamI::read(std::wstring& v)
+{
+    _is->read(v);
+}
+
+void
+Ice::InputStreamI::read(std::pair<const bool*, const bool*>& p, ::IceUtil::ScopedArray<bool>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
+Ice::InputStreamI::read(std::pair<const Ice::Byte*, const Ice::Byte*>& p)
+{
+    _is->read(p);
+}
+void
+Ice::InputStreamI::read(std::pair<const Ice::Short*, const Ice::Short*>& p, ::IceUtil::ScopedArray<Ice::Short>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
+Ice::InputStreamI::read(std::pair<const Ice::Int*, const Ice::Int*>& p, ::IceUtil::ScopedArray<Ice::Int>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
+Ice::InputStreamI::read(std::pair<const Ice::Long*, const Ice::Long*>& p, ::IceUtil::ScopedArray<Ice::Long>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
+Ice::InputStreamI::read(std::pair<const Ice::Float*, const Ice::Float*>& p, ::IceUtil::ScopedArray<Ice::Float>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
+Ice::InputStreamI::read(std::pair<const Ice::Double*, const Ice::Double*>& p, 
+                        ::IceUtil::ScopedArray<Ice::Double>& result)
+{
+    result.reset(_is->read(p));
+}
+
+void
 Ice::InputStreamI::throwException()
 {
     _is->throwException();
@@ -370,81 +485,96 @@ Ice::OutputStreamI::communicator() const
 }
 
 void
-Ice::OutputStreamI::internalWriteBool(bool v)
+Ice::OutputStreamI::writeObject(const ObjectPtr& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteBoolSeq(const vector<bool>& v)
+Ice::OutputStreamI::writeException(const UserException& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteBoolSeq(const bool* begin, const bool* end)
+Ice::OutputStreamI::writeProxy(const ObjectPrx& v)
 {
-    _os->write(begin, end);
+    _os->write(v);
+}
+
+void
+Ice::OutputStreamI::writeSize(Int sz)
+{
+    if(sz < 0)
+    {
+        throw MarshalException(__FILE__, __LINE__);
+    }
+
+    _os->writeSize(sz);
 }
 
 void
-Ice::OutputStreamI::internalWriteByte(Byte v)
+Ice::OutputStreamI::writeTypeId(const string& id)
+{
+    _os->writeTypeId(id);
+}
+
+void
+Ice::OutputStreamI::write(bool v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteByteSeq(const vector<Byte>& v)
+Ice::OutputStreamI::write(Byte v)
 {
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteByteSeq(const Byte* begin, const Byte* end)
+Ice::OutputStreamI::write(Short v)
 {
-    _os->write(begin, end);
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteShort(Short v)
+Ice::OutputStreamI::write(Int v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteShortSeq(const vector<Short>& v)
+Ice::OutputStreamI::write(Long v)
 {
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteShortSeq(const Short* begin, const Short* end)
+Ice::OutputStreamI::write(Float v)
 {
-    _os->write(begin, end);
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteInt(Int v)
+Ice::OutputStreamI::write(Double v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteIntSeq(const vector<Int>& v)
+Ice::OutputStreamI::write(const string& v, bool convert)
+{
+    _os->write(v, convert);
+}
+
+void
+Ice::OutputStreamI::write(const char* v, bool convert)
+{
+    _os->write(v, convert);
+}
+
+void
+Ice::OutputStreamI::write(const vector<string>& v, bool convert)
 {
     if(v.size() == 0)
     {
@@ -452,49 +582,131 @@ Ice::OutputStreamI::internalWriteIntSeq(const vector<Int>& v)
     }
     else
     {
-        _os->write(&v[0], &v[0] + v.size());
+        _os->write(&v[0], &v[0] + v.size(), convert);
     }
 }
 
 void
-Ice::OutputStreamI::internalWriteIntSeq(const Int* begin, const Int* end)
+Ice::OutputStreamI::write(const wstring& v)
+{
+    _os->write(v);
+}
+
+void
+Ice::OutputStreamI::write(const bool* begin, const bool* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::internalWriteLong(Long v)
+Ice::OutputStreamI::write(const Byte* begin, const Byte* end)
 {
-    _os->write(v);
+    _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::internalWriteLongSeq(const vector<Long>& v)
+Ice::OutputStreamI::write(const Int* begin, const Int* end)
 {
-    if(v.size() == 0)
+    _os->write(begin, end);
+}
+
+void
+Ice::OutputStreamI::write(const Long* begin, const Long* end)
+{
+    _os->write(begin, end);
+}
+
+void
+Ice::OutputStreamI::write(const Float* begin, const Float* end)
+{
+    _os->write(begin, end);
+}
+
+void
+Ice::OutputStreamI::write(const Double* begin, const Double* end)
+{
+    _os->write(begin, end);
+}
+
+void
+Ice::OutputStreamI::startSlice()
+{
+    _os->startWriteSlice();
+}
+
+void
+Ice::OutputStreamI::endSlice()
+{
+    _os->endWriteSlice();
+}
+
+void
+Ice::OutputStreamI::startEncapsulation()
+{
+    _os->startWriteEncaps();
+}
+
+void
+Ice::OutputStreamI::endEncapsulation()
+{
+    _os->endWriteEncapsChecked();
+}
+
+void
+Ice::OutputStreamI::writePendingObjects()
+{
+    _os->writePendingObjects();
+}
+
+void
+Ice::OutputStreamI::finished(vector<Byte>& bytes)
+{
+    vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes);
+}
+
+void
+Ice::OutputStreamI::reset(bool clearBuffer)
+{
+    _os->clear();
+    
+    if(clearBuffer)
     {
-        _os->writeSize(0);
+        _os->b.clear();
     }
     else
     {
-        _os->write(&v[0], &v[0] + v.size());
+        _os->b.reset();
     }
+    
+    _os->i = _os->b.begin();
 }
 
 void
-Ice::OutputStreamI::internalWriteLongSeq(const Long* begin, const Long* end)
+Ice::OutputStreamI::writeBool(bool v)
 {
-    _os->write(begin, end);
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteFloat(Float v)
+Ice::OutputStreamI::writeBoolSeq(const vector<bool>& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteFloatSeq(const vector<Float>& v)
+Ice::OutputStreamI::writeBoolSeq(const bool* begin, const bool* end)
+{
+    write(begin, end);
+}
+
+void
+Ice::OutputStreamI::writeByte(Byte v)
+{
+    _os->write(v);
+}
+
+void
+Ice::OutputStreamI::writeByteSeq(const vector<Byte>& v)
 {
     if(v.size() == 0)
     {
@@ -507,19 +719,19 @@ Ice::OutputStreamI::internalWriteFloatSeq(const vector<Float>& v)
 }
 
 void
-Ice::OutputStreamI::internalWriteFloatSeq(const Float* begin, const Float* end)
+Ice::OutputStreamI::writeByteSeq(const Ice::Byte* begin, const Ice::Byte* end)
 {
-    _os->write(begin, end);
+    write(begin, end);
 }
 
 void
-Ice::OutputStreamI::internalWriteDouble(Double v)
+Ice::OutputStreamI::writeShort(Short v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteDoubleSeq(const vector<Double>& v)
+Ice::OutputStreamI::writeShortSeq(const vector<Short>& v)
 {
     if(v.size() == 0)
     {
@@ -532,19 +744,19 @@ Ice::OutputStreamI::internalWriteDoubleSeq(const vector<Double>& v)
 }
 
 void
-Ice::OutputStreamI::internalWriteDoubleSeq(const Double* begin, const Double* end)
+Ice::OutputStreamI::writeShortSeq(const Ice::Short* begin, const Ice::Short* end)
 {
-    _os->write(begin, end);
+    write(begin, end);
 }
 
 void
-Ice::OutputStreamI::internalWriteString(const string& v, bool convert)
+Ice::OutputStreamI::writeInt(Int v)
 {
-    _os->write(v, convert);
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteStringSeq(const vector<string>& v, bool convert)
+Ice::OutputStreamI::writeIntSeq(const vector<Int>& v)
 {
     if(v.size() == 0)
     {
@@ -552,18 +764,24 @@ Ice::OutputStreamI::internalWriteStringSeq(const vector<string>& v, bool convert
     }
     else
     {
-        _os->write(&v[0], &v[0] + v.size(), convert);
+        _os->write(&v[0], &v[0] + v.size());
     }
 }
 
 void
-Ice::OutputStreamI::internalWriteWstring(const wstring& v)
+Ice::OutputStreamI::writeIntSeq(const Ice::Int* begin, const Ice::Int* end)
+{
+    write(begin, end);
+}
+
+void
+Ice::OutputStreamI::writeLong(Long v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::internalWriteWstringSeq(const vector<wstring>& v)
+Ice::OutputStreamI::writeLongSeq(const vector<Long>& v)
 {
     if(v.size() == 0)
     {
@@ -576,92 +794,104 @@ Ice::OutputStreamI::internalWriteWstringSeq(const vector<wstring>& v)
 }
 
 void
-Ice::OutputStreamI::writeSize(Int sz)
+Ice::OutputStreamI::writeLongSeq(const Ice::Long* begin, const Ice::Long* end)
 {
-    if(sz < 0)
-    {
-        throw MarshalException(__FILE__, __LINE__);
-    }
-
-    _os->writeSize(sz);
+    write(begin, end);
 }
 
 void
-Ice::OutputStreamI::internalWriteProxy(const ObjectPrx& v)
+Ice::OutputStreamI::writeFloat(Float v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::writeObject(const ObjectPtr& v)
+Ice::OutputStreamI::writeFloatSeq(const vector<Float>& v)
 {
-    _os->write(v);
+    if(v.size() == 0)
+    {
+        _os->writeSize(0);
+    }
+    else
+    {
+        _os->write(&v[0], &v[0] + v.size());
+    }
 }
 
 void
-Ice::OutputStreamI::writeTypeId(const string& id)
+Ice::OutputStreamI::writeFloatSeq(const Ice::Float* begin, const Ice::Float* end)
 {
-    _os->writeTypeId(id);
+    write(begin, end);
 }
 
 void
-Ice::OutputStreamI::writeException(const UserException& v)
+Ice::OutputStreamI::writeDouble(Double v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::startSlice()
+Ice::OutputStreamI::writeDoubleSeq(const vector<Double>& v)
 {
-    _os->startWriteSlice();
+    if(v.size() == 0)
+    {
+        _os->writeSize(0);
+    }
+    else
+    {
+        _os->write(&v[0], &v[0] + v.size());
+    }
 }
 
 void
-Ice::OutputStreamI::endSlice()
+Ice::OutputStreamI::writeDoubleSeq(const Ice::Double* begin, const Ice::Double* end)
 {
-    _os->endWriteSlice();
+    write(begin, end);
 }
 
 void
-Ice::OutputStreamI::startEncapsulation()
+Ice::OutputStreamI::write(const Short* begin, const Short* end)
 {
-    _os->startWriteEncaps();
+    _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::endEncapsulation()
+Ice::OutputStreamI::writeString(const string& v, bool convert)
 {
-    _os->endWriteEncapsChecked();
+    _os->write(v, convert);
 }
 
 void
-Ice::OutputStreamI::writePendingObjects()
+Ice::OutputStreamI::writeStringSeq(const vector<string>& v, bool convert)
 {
-    _os->writePendingObjects();
+    if(v.size() == 0)
+    {
+        _os->writeSize(0);
+    }
+    else
+    {
+        _os->write(&v[0], &v[0] + v.size(), convert);
+    }
 }
 
 void
-Ice::OutputStreamI::finished(vector<Byte>& bytes)
+Ice::OutputStreamI::writeWstring(const wstring& v)
 {
-    vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes);
+    _os->write(v);
 }
 
 void
-Ice::OutputStreamI::reset(bool clearBuffer)
+Ice::OutputStreamI::writeWstringSeq(const vector<wstring>& v)
 {
-    _os->clear();
-    
-    if(clearBuffer)
+    if(v.size() == 0)
     {
-        _os->b.clear();
+        _os->writeSize(0);
     }
     else
     {
-        _os->b.reset();
+        _os->write(&v[0], &v[0] + v.size());
     }
-    
-    _os->i = _os->b.begin();
-}       
+}
 
 //
 // ObjectReader
diff --git a/cpp/src/Ice/StreamI.h b/cpp/src/Ice/StreamI.h
index 4017c85d7d1..a39214885fc 100644
--- a/cpp/src/Ice/StreamI.h
+++ b/cpp/src/Ice/StreamI.h
@@ -11,7 +11,14 @@
 #define ICE_STREAM_I_H
 
 #include <Ice/Stream.h>
-#include <Ice/BasicStream.h>
+
+namespace IceInternal
+{
+
+// Forward declaration.
+class BasicStream;
+
+};
 
 namespace Ice
 {
@@ -23,19 +30,56 @@ class InputStreamI : public InputStream
 {
 public:
 
-    InputStreamI(const Ice::CommunicatorPtr&, const std::vector< Ice::Byte >&);
-    InputStreamI(const Ice::CommunicatorPtr&, const std::pair< const Ice::Byte*, const Ice::Byte* >&);
+    InputStreamI(const CommunicatorPtr&, const std::vector< Byte >&);
+    InputStreamI(const CommunicatorPtr&, const std::pair< const Byte*, const Byte* >&);
     virtual ~InputStreamI();
 
-    virtual Ice::CommunicatorPtr communicator() const;
+    virtual CommunicatorPtr communicator() const;
 
     virtual void sliceObjects(bool);
 
-    virtual Ice::Int readSize();
-    virtual Ice::Int readAndCheckSeqSize(int);
-
-    virtual void readObject(const Ice::ReadObjectCallbackPtr&);
-
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual bool readBool();
+    virtual Byte readByte();
+    virtual Short readShort();
+    virtual Int readInt();
+    virtual Long readLong();
+    virtual Float readFloat();
+    virtual Double readDouble();
+    virtual ::std::string readString(bool = true);
+    virtual ::std::wstring readWstring();
+    
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual std::vector< bool > readBoolSeq();
+    virtual std::vector< Byte > readByteSeq();
+    virtual std::vector< Short > readShortSeq();
+    virtual std::vector< Int > readIntSeq();
+    virtual std::vector< Long > readLongSeq();
+    virtual std::vector< Float > readFloatSeq();
+    virtual std::vector< Double > readDoubleSeq();
+    virtual std::vector< std::string > readStringSeq(bool = true);
+    virtual std::vector< std::wstring > readWstringSeq();
+    
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual bool* readBoolSeq(std::pair<const bool*, const bool*>&);
+    virtual void readByteSeq(std::pair<const Byte*, const Byte*>&);
+    virtual Short* readShortSeq(std::pair<const Short*, const Short*>&);
+    virtual Int* readIntSeq(std::pair<const Int*, const Int*>&);
+    virtual Long* readLongSeq(std::pair<const Long*, const Long*>&);
+    virtual Float* readFloatSeq(std::pair<const Float*, const Float*>&);
+    virtual Double* readDoubleSeq(std::pair<const Double*, const Double*>&);
+
+    virtual Int readSize();
+    virtual Int readAndCheckSeqSize(int);
+
+    virtual ObjectPrx readProxy();
+    virtual void readObject(const ReadObjectCallbackPtr&);
     virtual std::string readTypeId();
 
     virtual void throwException();
@@ -51,49 +95,28 @@ public:
     virtual void readPendingObjects();
 
     virtual void rewind();
-
-private:
-    
-    virtual bool internalReadBool();
-    virtual ::Ice::Byte internalReadByte();
-    virtual ::Ice::Short internalReadShort();
-    virtual ::Ice::Int internalReadInt();
-    virtual ::Ice::Long internalReadLong();
-    virtual ::Ice::Float internalReadFloat();
-    virtual ::Ice::Double internalReadDouble();
-    virtual ::std::string internalReadString(bool = true);
-    virtual ::std::wstring internalReadWstring();
-    virtual ::Ice::ObjectPrx internalReadProxy();
     
-    //
-    // Remove these methods when the old Stream api, is removed.
-    //
-    virtual std::vector< bool > internalReadBoolSeq();
-    virtual bool* internalReadBoolSeq(std::pair<const bool*, const bool*>&);
-
-    virtual std::vector< Ice::Byte > internalReadByteSeq();
-    virtual void internalReadByteSeq(std::pair<const Ice::Byte*, const Ice::Byte*>&);
-
-    virtual std::vector< Ice::Short > internalReadShortSeq();
-    virtual Ice::Short* internalReadShortSeq(std::pair<const Ice::Short*, const Ice::Short*>&);
-
-    virtual std::vector< Ice::Int > internalReadIntSeq();
-    virtual Ice::Int* internalReadIntSeq(std::pair<const Ice::Int*, const Ice::Int*>&);
-
-    virtual std::vector< Ice::Long > internalReadLongSeq();
-    virtual Ice::Long* internalReadLongSeq(std::pair<const Ice::Long*, const Ice::Long*>&);
-
-    virtual std::vector< Ice::Float > internalReadFloatSeq();
-    virtual Ice::Float* internalReadFloatSeq(std::pair<const Ice::Float*, const Ice::Float*>&);
+    virtual void read(bool& v);
+    virtual void read(Byte& v);
+    virtual void read(Short& v);
+    virtual void read(Int& v);
+    virtual void read(Long& v);
+    virtual void read(Float& v);
+    virtual void read(Double& v);
+    virtual void read(std::string& v, bool convert = true);
+    virtual void read(std::vector<std::string>&, bool);
+    virtual void read(std::wstring& v);
+    virtual void read(std::pair<const bool*, const bool*>&, ::IceUtil::ScopedArray<bool>&);
+    virtual void read(std::pair<const Byte*, const Byte*>&);
+    virtual void read(std::pair<const Short*, const Short*>&, ::IceUtil::ScopedArray<Short>&);
+    virtual void read(std::pair<const Int*, const Int*>&, ::IceUtil::ScopedArray<Int>&);
+    virtual void read(std::pair<const Long*, const Long*>&, ::IceUtil::ScopedArray<Long>&);
+    virtual void read(std::pair<const Float*, const Float*>&, ::IceUtil::ScopedArray<Float>&);
+    virtual void read(std::pair<const Double*, const Double*>&, ::IceUtil::ScopedArray<Double>&);
 
-    virtual std::vector< Ice::Double > internalReadDoubleSeq();
-    virtual Ice::Double* internalReadDoubleSeq(std::pair<const Ice::Double*, const Ice::Double*>&);
-
-    virtual std::vector< std::string > internalReadStringSeq(bool = true);
-
-    virtual std::vector< std::wstring > internalReadWstringSeq();
+private:
 
-    Ice::CommunicatorPtr _communicator;
+    const CommunicatorPtr _communicator;
     IceInternal::BasicStream* _is;
     std::vector< ReadObjectCallbackPtr > _callbacks;
 };
@@ -105,18 +128,75 @@ class OutputStreamI : public OutputStream
 {
 public:
 
-    OutputStreamI(const Ice::CommunicatorPtr&, IceInternal::BasicStream* = 0);
+    OutputStreamI(const CommunicatorPtr&, IceInternal::BasicStream* = 0);
     virtual ~OutputStreamI();
 
-    virtual Ice::CommunicatorPtr communicator() const;
+    virtual CommunicatorPtr communicator() const;
 
-    virtual void writeObject(const ::Ice::ObjectPtr&);
-    virtual void writeException(const Ice::UserException&);
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual void writeBool(bool);
+    virtual void writeByte(Byte);
+    virtual void writeShort(Short);
+    virtual void writeInt(Int);
+    virtual void writeLong(Long);
+    virtual void writeFloat(Float);
+    virtual void writeDouble(Double);
+    virtual void writeString(const ::std::string&, bool = true);
+    virtual void writeWstring(const ::std::wstring&);
     
-    virtual void writeSize(Ice::Int);
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual void writeBoolSeq(const std::vector< bool >&);
+    virtual void writeByteSeq(const std::vector< Byte >&);    
+    virtual void writeShortSeq(const std::vector< Short >&);
+    virtual void writeIntSeq(const std::vector< Int >&);
+    virtual void writeLongSeq(const std::vector< Long >&);
+    virtual void writeFloatSeq(const std::vector< Float >&);    
+    virtual void writeDoubleSeq(const std::vector< Double >&);
+    virtual void writeStringSeq(const std::vector< std::string >&, bool = true);
+    virtual void writeWstringSeq(const std::vector< std::wstring >&);
 
-    virtual void writeTypeId(const std::string&);
+    //
+    // These methods should be removed when the old stream API is removed.
+    //
+    virtual void writeBoolSeq(const bool*, const bool*);
+    virtual void writeByteSeq(const Byte*, const Byte*);
+    virtual void writeShortSeq(const Short*, const Short*);
+    virtual void writeIntSeq(const Int*, const Int*);
+    virtual void writeLongSeq(const Long*, const Long*);
+    virtual void writeFloatSeq(const Float*, const Float*);
+    virtual void writeDoubleSeq(const Double*, const Double*);
+
+    virtual void writeObject(const ObjectPtr&);
+    virtual void writeException(const UserException&);
+    virtual void writeProxy(const ObjectPrx&);
+        
+    virtual void writeSize(Int);
 
+    virtual void writeTypeId(const std::string&);
+    
+    virtual void write(bool);
+    virtual void write(Byte);
+    virtual void write(Short);
+    virtual void write(Int);
+    virtual void write(Long);
+    virtual void write(Float);
+    virtual void write(Double);
+    virtual void write(const std::string&, bool = true);
+    virtual void write(const std::vector<std::string>&, bool);
+    virtual void write(const char* v, bool = true);
+    virtual void write(const std::wstring& v);
+
+    virtual void write(const bool*, const bool*);
+    virtual void write(const Byte*, const Byte*);
+    virtual void write(const Short*, const Short*);
+    virtual void write(const Int*, const Int*);
+    virtual void write(const Long*, const Long*);
+    virtual void write(const Float*, const Float*);
+    virtual void write(const Double*, const Double*);
 
     virtual void startSlice();
     virtual void endSlice();
@@ -126,54 +206,15 @@ public:
 
     virtual void writePendingObjects();
 
-    virtual void finished(std::vector< Ice::Byte >&);
+    virtual void finished(std::vector< Byte >&);
 
     virtual void reset(bool);
 
 private:
-    
-    virtual void internalWriteBool(bool);
-    virtual void internalWriteByte(::Ice::Byte);
-    virtual void internalWriteShort(::Ice::Short);
-    virtual void internalWriteInt(::Ice::Int);
-    virtual void internalWriteLong(::Ice::Long);
-    virtual void internalWriteFloat(::Ice::Float);
-    virtual void internalWriteDouble(::Ice::Double);
-    virtual void internalWriteString(const ::std::string&, bool = true);
-    virtual void internalWriteWstring(const ::std::wstring&);
-    virtual void internalWriteProxy(const ::Ice::ObjectPrx&);
-    
-    //
-    // Remove these methods when the old Stream api, is removed.
-    //
-    virtual void internalWriteBoolSeq(const std::vector< bool >&);
-    virtual void internalWriteBoolSeq(const bool*, const bool*);
-
-    virtual void internalWriteByteSeq(const std::vector< Ice::Byte >&);
-    virtual void internalWriteByteSeq(const Ice::Byte*, const Ice::Byte*);
-
-    virtual void internalWriteShortSeq(const std::vector< Ice::Short >&);
-    virtual void internalWriteShortSeq(const Ice::Short*, const Ice::Short*);
-
-    virtual void internalWriteIntSeq(const std::vector< Ice::Int >&);
-    virtual void internalWriteIntSeq(const Ice::Int*, const Ice::Int*);
-
-    virtual void internalWriteLongSeq(const std::vector< Ice::Long >&);
-    virtual void internalWriteLongSeq(const Ice::Long*, const Ice::Long*);
-
-    virtual void internalWriteFloatSeq(const std::vector< Ice::Float >&);
-    virtual void internalWriteFloatSeq(const Ice::Float*, const Ice::Float*);
-
-    virtual void internalWriteDoubleSeq(const std::vector< Ice::Double >&);
-    virtual void internalWriteDoubleSeq(const Ice::Double*, const Ice::Double*);
-
-    virtual void internalWriteStringSeq(const std::vector< std::string >&, bool = true);
-
-    virtual void internalWriteWstringSeq(const std::vector< std::wstring >&);
 
-    Ice::CommunicatorPtr _communicator;
+    const CommunicatorPtr _communicator;
     IceInternal::BasicStream* _os;
-    bool _own;
+    const bool _own;
 };
 
 }
diff --git a/cpp/src/IcePatch2/FileServerI.cpp b/cpp/src/IcePatch2/FileServerI.cpp
index 30235000b62..a33171edd8f 100644
--- a/cpp/src/IcePatch2/FileServerI.cpp
+++ b/cpp/src/IcePatch2/FileServerI.cpp
@@ -119,7 +119,7 @@ IcePatch2::FileServerI::getFileCompressed_async(const AMD_FileServer_getFileComp
         return;
     }
 
-    IceUtilInternal::ScopedArray<Byte> bytes(new Byte[num]);
+    IceUtil::ScopedArray<Byte> bytes(new Byte[num]);
 #ifdef _WIN32
     int r;
     if((r =
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index ba658453f1a..a944eda7250 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -145,7 +145,7 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
                     {
                         s = " " + s;
                     }
-                    return "::std::pair< ::IceUtilInternal::ScopedArray<" + s + ">," +
+                    return "::std::pair< ::IceUtil::ScopedArray<" + s + ">," +
                         " ::std::pair<const " + s + "*, const " + s + "*> >";
                 }
                 else
@@ -854,7 +854,7 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, const string&
                     }
                     else
                     {
-                        out << nl << "::IceUtilInternal::ScopedArray<" << s << "> ___" << fixedParam << '('
+                        out << nl << "::IceUtil::ScopedArray<" << s << "> ___" << fixedParam << '('
                             << stream << deref << func << fixedParam << "));";
                     }
                 }
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 7b98df83ab9..ad30d5025eb 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -718,11 +718,8 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         H << nl << "virtual void __read(::IceInternal::BasicStream*, bool);";
         
         H.zeroIndent();
-        H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-        H.restoreIndent();
-        H << nl << "// Stream API is not supported with VC++ 6";
-        H.zeroIndent();
-        H << nl << "#else";
+        H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+        H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
         H.restoreIndent();
         H << nl << "virtual void __write(const ::Ice::OutputStreamPtr&) const;";
         H << nl << "virtual void __read(const ::Ice::InputStreamPtr&, bool);";
@@ -768,11 +765,8 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scoped.substr(2)
               << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
@@ -822,11 +816,8 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             //
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr&) const";
             C << sb;
@@ -1074,11 +1065,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         if(_stream)
         {
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H.restoreIndent();
             H << nl << dllExport << "void ice_write(const ::Ice::OutputStreamPtr&) const;";
             H << nl << dllExport << "void ice_read(const ::Ice::InputStreamPtr&);";
@@ -1107,11 +1095,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scoped.substr(2)
               << "::ice_write(const ::Ice::OutputStreamPtr& __outS) const";
@@ -1146,11 +1131,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         {
             H << sp;
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H.restoreIndent();
             H << nl << "void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
               << p->name() << "Ptr&);";
@@ -1162,11 +1144,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
               
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
               << "(const ::Ice::OutputStreamPtr& __outS, const " << fixKwd(p->scoped() + "Ptr") << "& __v)";
@@ -1190,11 +1169,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         {
             H << sp;
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H.restoreIndent();
             H << nl << dllExport << "void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
               << name << "&);";
@@ -1205,11 +1181,8 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
               << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& __v)";
@@ -1305,11 +1278,8 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             if(_stream)
             {
                 H.zeroIndent();
-                H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-                H.restoreIndent();
-                H << nl << "// Stream API is not supported with VC++ 6";
-                H.zeroIndent();
-                H << nl << "#else";
+                H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+                H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
                 H.restoreIndent();
                 H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
                   << typeName << "&);";
@@ -1375,11 +1345,8 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             {
                 C << sp;
                 C.zeroIndent();
-                C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-                C.restoreIndent();
-                C << nl << "// Stream API is not supported with VC++ 6";
-                C.zeroIndent();
-                C << nl << "#else";
+                C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+                C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
                 C.restoreIndent();
                 C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
                   << "(const ::Ice::OutputStreamPtr& __outS, const " << scopedName << "& v)";
@@ -1411,9 +1378,9 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
                 C << sb;
                 if(protobuf)
                 {
-                    C << nl << "std::vector< ::Ice::Byte> data;";
-                    C << nl << "__inS->read(data);";
-                    C << nl << "if(!v.ParseFromArray(data.begin(), data.end()))";
+                    C << nl << "std::pair<const ::Ice::Byte*, const ::Ice::Byte*> data;";
+                    C << nl << "__inS->readByteSeq(data);";
+                    C << nl << "if(!v.ParseFromArray(data.first, data.second - data.first))";
                     C << sb;
                     C << nl << "throw ::Ice::MarshalException(__FILE__, __LINE__, \"ParseFromArray failed\");";
                     C << eb;
@@ -1443,11 +1410,8 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             if(_stream)
             {
                 H.zeroIndent();
-                H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-                H.restoreIndent();
-                H << nl << "// Stream API is not supported with VC++ 6";
-                H.zeroIndent();
-                H << nl << "#else";
+                H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+                H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
                 H.restoreIndent();
                 H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
                   << name << "&);";
@@ -1485,11 +1449,8 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             {
                 C << sp;
                 C.zeroIndent();
-                C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-                C.restoreIndent();
-                C << nl << "// Stream API is not supported with VC++ 6";
-                C.zeroIndent();
-                C << nl << "#else";
+                C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+                C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
                 C.restoreIndent();
                 C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
                   << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
@@ -1561,11 +1522,8 @@ Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
         if(_stream)
         {
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H.restoreIndent();
             H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const " << name
               << "&);";
@@ -1606,11 +1564,8 @@ Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
               << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
@@ -1675,12 +1630,8 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
         if(_stream)
         {
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H.restoreIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name()
               << "(const ::Ice::OutputStreamPtr&, " << name << ");";
             H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << p->name() << "(const ::Ice::InputStreamPtr&, " << name << "&);";
@@ -1729,12 +1680,8 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C.restoreIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
               << "(const ::Ice::OutputStreamPtr& __outS, " << scoped << " v)";
             C << sb;
@@ -1825,7 +1772,7 @@ void
 Slice::Gen::TypesVisitor::emitUpcall(const ExceptionPtr& base, const string& call, bool isLocal)
 {
     C.zeroIndent();
-    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     C.restoreIndent();
     C << nl << (base ? fixKwd(base->name()) : string(isLocal ? "LocalException" : "UserException")) << call;
     C.zeroIndent();
@@ -2018,7 +1965,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_context(const ::Ice::Context& __context) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_context(__context).get());";
@@ -2038,7 +1985,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_adapterId(const std::string& __id) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_adapterId(__id).get());";
@@ -2054,7 +2001,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_endpoints(__endpoints).get());";
@@ -2070,7 +2017,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_locatorCacheTimeout(int __timeout) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_locatorCacheTimeout(__timeout).get());";
@@ -2086,7 +2033,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_connectionCached(bool __cached) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_connectionCached(__cached).get());";
@@ -2100,7 +2047,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_endpointSelection(::Ice::EndpointSelectionType __est) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_endpointSelection(__est).get());";
@@ -2116,7 +2063,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_secure(bool __secure) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_secure(__secure).get());";
@@ -2132,7 +2079,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_preferSecure(bool __preferSecure) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_preferSecure(__preferSecure).get());";
@@ -2148,7 +2095,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_router(const ::Ice::RouterPrx& __router) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_router(__router).get());";
@@ -2163,7 +2110,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
 
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_locator(const ::Ice::LocatorPrx& __locator) const";
     H << sb;
-    H.dec(); H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H.dec(); H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_locator(__locator).get());";
@@ -2178,7 +2125,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
 
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_collocationOptimized(bool __co) const";
     H << sb;
-    H.dec(); H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H.dec(); H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_collocationOptimized(__co).get());";
@@ -2190,7 +2137,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_twoway() const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_twoway().get());";
@@ -2206,7 +2153,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_oneway() const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_oneway().get());";
@@ -2221,7 +2168,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_batchOneway() const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_batchOneway().get());";
@@ -2237,7 +2184,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_datagram() const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_datagram().get());";
@@ -2253,7 +2200,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_batchDatagram() const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_batchDatagram().get());";
@@ -2269,7 +2216,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_compress(bool __compress) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_compress(__compress).get());";
@@ -2285,7 +2232,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_timeout(int __timeout) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_timeout(__timeout).get());";
@@ -2301,7 +2248,7 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H << nl << nl << "::IceInternal::ProxyHandle<" << name << "> ice_connectionId(const std::string& __id) const";
     H << sb;
     H.dec();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H.inc();
     H << nl << "typedef ::IceProxy::Ice::Object _Base;";
     H << nl << "return dynamic_cast<" << name << "*>(_Base::ice_connectionId(__id).get());";
@@ -2605,7 +2552,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");";
 
         //
-        // COMPILERBUG: It's necessary to generate the allocate code here before 
+        // COMPILERFIX: It's necessary to generate the allocate code here before 
         // this if(!__result->wait()). If generated after this if block, we get
         // access violations errors with the test/Ice/slicing/objects test on VC9 
         // and Windows 64 bits when compiled with optimization (see bug 4400).
@@ -4165,11 +4112,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
       
         
         H.zeroIndent();
-        H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-        H.restoreIndent();
-        H << nl << "// Stream API is not supported with VC++ 6";
-        H.zeroIndent();
-        H << nl << "#else";
+        H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+        H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
         H.restoreIndent();
         H << nl << "virtual void __write(const ::Ice::OutputStreamPtr&) const;";
         H << nl << "virtual void __read(const ::Ice::InputStreamPtr&, bool);";
@@ -4213,11 +4157,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
             C << sb;
@@ -4255,11 +4196,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             //
             // Emit placeholder functions to catch errors.
@@ -5106,7 +5044,7 @@ void
 Slice::Gen::ObjectVisitor::emitUpcall(const ClassDefPtr& base, const string& call)
 {
     C.zeroIndent();
-    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     C.restoreIndent();
     C << nl << (base ? fixKwd(base->name()) : string("Object")) << call;
     C.zeroIndent();
@@ -5409,7 +5347,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << nl << "catch(::Ice::Exception& ex)";
         H << sb;
 	H.zeroIndent();
-	H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+	H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
 	H.restoreIndent();
         H << nl << "__exception(__result, ex);";
 	H.zeroIndent();
@@ -5424,7 +5362,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << nl << "if(response)";
         H << sb;
 	H.zeroIndent();
-	H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+	H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
 	H.restoreIndent();
         H << nl << "(callback.get()->*response)" << spar;
         if(ret)
@@ -5654,11 +5592,8 @@ Slice::Gen::HandleVisitor::visitClassDecl(const ClassDeclPtr& p)
         {
             H << sp;
             H.zeroIndent();
-            H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            H.restoreIndent();
-            H << nl << "// Stream API is not supported with VC++ 6";
-            H.zeroIndent();
-            H << nl << "#else";
+            H << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            H << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             H.restoreIndent();
             H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << name << "Prx(const ::Ice::OutputStreamPtr&, const " << name
               << "Prx&);";
@@ -5718,11 +5653,8 @@ Slice::Gen::HandleVisitor::visitClassDefStart(const ClassDefPtr& p)
         {
             C << sp;
             C.zeroIndent();
-            C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
-            C.restoreIndent();
-            C << nl << "// Stream API is not supported with VC++ 6";
-            C.zeroIndent();
-            C << nl << "#else";
+            C << nl << "// COMPILERFIX: Stream API is not supported with VC++ 6";
+            C << nl << "#if !defined(_MSC_VER) || (_MSC_VER >= 1300)";
             C.restoreIndent();
             C << nl << "void" << nl << scope.substr(2) << "ice_write" << name
               << "Prx(const ::Ice::OutputStreamPtr& __outS, const " << scope << name << "Prx& v)";
@@ -5748,9 +5680,7 @@ Slice::Gen::HandleVisitor::visitClassDefStart(const ClassDefPtr& p)
             C << nl << "void" << nl << scope.substr(2) << "ice_read" << name << "(const ::Ice::InputStreamPtr& __inS, "
               << scope << name << "Ptr& __v)";
             C << sb;
-            C << nl << "::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(" << scope << "__patch__"
-              << name << "Ptr, &__v);";
-            C << nl << "__inS->readObject(__cb);";
+            C << nl << "__inS->read(__v);";
             C << eb;
             C.zeroIndent();
             C << nl << "#endif";
@@ -6321,7 +6251,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
         H << nl << "void __sent(bool sentSynchronously)";
         H << sb;
         H.zeroIndent();
-        H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+        H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
         H.restoreIndent();
         H << nl << "AMICallbackBase::__sent(sentSynchronously);";
         H.zeroIndent();
@@ -6585,7 +6515,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
         C << nl << "else";
         C << sb;
         C.zeroIndent();
-        C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+        C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
         C.restoreIndent();
         C << nl << "IncomingAsync::ice_exception(ex);";
         C.zeroIndent();
@@ -6618,7 +6548,7 @@ Slice::Gen::StreamVisitor::visitModuleStart(const ModulePtr& m)
         return false;
     }
     H.zeroIndent();
-    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
+    H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
     H << nl << "#else";
     H.restoreIndent();
     H << nl << "namespace Ice" << nl << '{';
@@ -6644,7 +6574,6 @@ Slice::Gen::StreamVisitor::visitExceptionStart(const ExceptionPtr& p)
         H << nl << "struct StreamTrait< " << fixKwd(scoped) << ">";
         H << sb;
         H << nl << "static const ::Ice::StreamTraitType type = ::Ice::StreamTraitTypeUserException;";
-        H << nl << "static const int enumLimit = 0;";
         H << eb << ";" << nl;
     }
     return true;