Support for optionals

48 files changed, 5626 insertions, 4812 deletions

diff --git a/cpp/include/Ice/BasicStream.h b/cpp/include/Ice/BasicStream.h
index bd37b334043..f016939a47a 100644
--- a/cpp/include/Ice/BasicStream.h
+++ b/cpp/include/Ice/BasicStream.h
@@ -18,6 +18,7 @@
 #include <Ice/Protocol.h>
 #include <Ice/SlicedDataF.h>
 #include <Ice/UserExceptionFactory.h>
+#include <Ice/StreamTraits.h>
 
 namespace Ice
 {
@@ -37,25 +38,18 @@ typedef IceUtil::Handle<WstringConverter> WstringConverterPtr;
 namespace IceInternal
 {
 
-//
-// Optional data member type.
-//
-enum MemberType
+template<typename T> inline void 
+patchHandle(void* addr, Ice::ObjectPtr& v)
 {
-    MemberTypeF1 = 0,
-    MemberTypeF2 = 1,
-    MemberTypeF4 = 2,
-    MemberTypeF8 = 3,
-    MemberTypeVSize = 4,
-    MemberTypeFSize = 5,
-    MemberTypeReserved = 6,
-    MemberTypeEndMarker = 7
-};
+    IceInternal::Handle<T>* p = static_cast<IceInternal::Handle<T>*>(addr);
+    __patch(*p, v); // Generated __patch method, necessary for forward declarations.
+}
 
 class ICE_API BasicStream : public Buffer
 {
 public:
 
+    typedef size_t size_type;
     typedef void (*PatchFunc)(void*, Ice::ObjectPtr&);
 
     BasicStream(Instance*, const Ice::EncodingVersion&, bool = false);
@@ -81,6 +75,7 @@ public:
     void* closure(void*);
 
     void swap(BasicStream&);
+    void resetEncaps();
 
     void resize(Container::size_type sz)
     {
@@ -172,23 +167,9 @@ public:
             _currentWriteEncaps->encoder->writePendingObjects();
         }
 
-        Container::size_type start = _currentWriteEncaps->start;
-        Ice::Int sz = static_cast<Ice::Int>(b.size() - start); // Size includes size and version.
-        Ice::Byte* dest = &(*(b.begin() + start));
-
-#ifdef ICE_BIG_ENDIAN
-        const Ice::Byte* src = reinterpret_cast<const Ice::Byte*>(&sz) + sizeof(Ice::Int) - 1;
-        *dest++ = *src--;
-        *dest++ = *src--;
-        *dest++ = *src--;
-        *dest = *src;
-#else
-        const Ice::Byte* src = reinterpret_cast<const Ice::Byte*>(&sz);
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest = *src;
-#endif
+        // Size includes size and version.
+        const Ice::Int sz = static_cast<Ice::Int>(b.size() - _currentWriteEncaps->start);
+        write(sz, &(*(b.begin() + _currentWriteEncaps->start)));
 
         WriteEncaps* oldEncaps = _currentWriteEncaps;
         _currentWriteEncaps = _currentWriteEncaps->previous;
@@ -263,6 +244,7 @@ public:
 
         return _currentReadEncaps->encoding;
     }
+
     void endReadEncaps()
     {
         assert(_currentReadEncaps);
@@ -270,13 +252,27 @@ public:
         if(_currentReadEncaps->decoder)
         {
             _currentReadEncaps->decoder->readPendingObjects();
+        } 
+        else if(i < b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz &&
+                _currentReadEncaps->encoding != Ice::Encoding_1_0)
+        {
+            //
+            // Read remaining encapsulation optionals. This returns
+            // true if the optionals end with the end marker. The end
+            // marker indicates that there are more to read from the
+            // encapsuliation: object instances. In this case, don't
+            // bother reading the objects, just skip to the end of the
+            // encapsulation.
+            //
+            if(skipOpts())
+            {
+                i = b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz;
+            }
         }
 
-        Container::size_type start = _currentReadEncaps->start;
-        Ice::Int sz = _currentReadEncaps->sz;
-        if(i != b.begin() + start + sz)
+        if(i != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
         {
-            if(i + 1 != b.begin() + start + sz)
+            if(i + 1 != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
             {
                 throwEncapsulationException(__FILE__, __LINE__);
             }
@@ -424,34 +420,35 @@ public:
             *dest = static_cast<Ice::Byte>(v);
         }
     }
-    void readSize(Ice::Int& v) // Inlined for performance reasons.
+    Ice::Int readSize() // Inlined for performance reasons.
     {
         Ice::Byte byte;
         read(byte);
-        unsigned val = static_cast<unsigned char>(byte);
+        unsigned char val = static_cast<unsigned char>(byte);
         if(val == 255)
         {
+            Ice::Int v;
             read(v);
             if(v < 0)
             {
                 throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
             }
+            return v;
         }
         else
         {
-            v = static_cast<Ice::Int>(static_cast<unsigned char>(byte));
+            return static_cast<Ice::Int>(static_cast<unsigned char>(byte));
         }
     }
     void readSizeSeq(std::vector<Ice::Int>& v)
     {
-        Ice::Int sz;
-        readSize(sz);
+        Ice::Int sz = readAndCheckSeqSize(1);
         if(sz > 0)
         {
             v.resize(sz);
             for(Ice::Int n = 0; n < sz; ++n)
             {
-                readSize(v[n]);
+                v[n] = readSize();
             }
         }
         else
@@ -460,7 +457,7 @@ public:
         }
     }
 
-    void readAndCheckSeqSize(int, Ice::Int&);
+    Ice::Int readAndCheckSeqSize(int);
 
     void writeBlob(const std::vector<Ice::Byte>&);
     void readBlob(std::vector<Ice::Byte>&, Ice::Int);
@@ -492,22 +489,94 @@ public:
         }
     }
 
-    void writeOpt(int tag, MemberType type)
+    template<typename T> void write(const T& v)
     {
-        assert(_currentWriteEncaps && _currentWriteEncaps->encoder);
-        _currentWriteEncaps->encoder->writeOpt(tag, type);
+        Ice::StreamHelper<T, Ice::StreamTrait<T>::type>::write(this, v);
     }
-    bool readOpt(int tag, MemberType expectedType)
+    template<typename T> void read(T& v)
     {
-        assert(_currentReadEncaps && _currentReadEncaps->decoder);
-        return _currentReadEncaps->decoder->readOpt(tag, expectedType);
+        Ice::StreamHelper<T, Ice::StreamTrait<T>::type>::read(this, v);
     }
-    
+
+    template<typename T> void write(Ice::Int tag, const IceUtil::Optional<T>& v)
+    {
+        if(v)
+        {
+            writeOpt(tag, Ice::StreamOptionalHelper<T,
+                                                    Ice::StreamTrait<T>::type, 
+                                                    Ice::StreamTrait<T>::optionalType>::optionalType);
+            Ice::StreamOptionalHelper<T, Ice::StreamTrait<T>::type, Ice::StreamTrait<T>::optionalType>::write(this, *v);
+        }
+    }
+    template<typename T> void read(Ice::Int tag, IceUtil::Optional<T>& v)
+    {
+        if(readOpt(tag, Ice::StreamOptionalHelper<T, 
+                                                  Ice::StreamTrait<T>::type, 
+                                                  Ice::StreamTrait<T>::optionalType>::optionalType))
+        {
+            v.__setIsSet();
+            Ice::StreamOptionalHelper<T, Ice::StreamTrait<T>::type, Ice::StreamTrait<T>::optionalType>::read(this, *v);
+        }
+        else
+        {
+            v = IceUtil::None;
+        }
+    }
+
+    //
+    // Template functions for sequences and custom sequences
+    // 
+    template<typename T> void write(const std::vector<T>& v)
+    {
+        if(v.empty())
+        {
+            writeSize(0);
+        }
+        else
+        {
+            write(&v[0], &v[0] + v.size());
+        }
+    }
+    template<typename T> void write(const T* begin, const T* end)
+    {
+        writeSize(static_cast<Ice::Int>(end - begin));
+        for(const T* p = begin; p != end; ++p)
+        {
+            write(*p);
+        }
+    }
+
+    // Read/write type and tag for optionals
+    void writeOpt(Ice::Int tag, Ice::OptionalType type)
+    {
+        assert(_currentWriteEncaps);
+        if(_currentWriteEncaps->encoder)
+        {
+            _currentWriteEncaps->encoder->writeOpt(tag, type);
+        }
+        else
+        {
+            writeOptImpl(tag, type);
+        }
+    }
+    bool readOpt(Ice::Int tag, Ice::OptionalType expectedType)
+    {
+        assert(_currentReadEncaps);
+        if(_currentReadEncaps->decoder)
+        {
+            return _currentReadEncaps->decoder->readOpt(tag, expectedType);
+        }
+        else
+        {
+            return readOptImpl(tag, expectedType);
+        }
+    }
+
+    // Byte
     void write(Ice::Byte v)
     {
         b.push_back(v);
     }
-    void write(Ice::Byte v, int limit);
     void write(const Ice::Byte*, const Ice::Byte*);
     void read(Ice::Byte& v)
     {
@@ -517,9 +586,10 @@ public:
         }
         v = *i++;
     }
-    void read(Ice::Byte& v, int limit);
+    void read(std::vector<Ice::Byte>&);
     void read(std::pair<const Ice::Byte*, const Ice::Byte*>&);
 
+    // Bool
     void write(bool v)
     {
         b.push_back(static_cast<Ice::Byte>(v));
@@ -537,14 +607,14 @@ public:
     void read(std::vector<bool>&);
     bool* read(std::pair<const bool*, const bool*>&);
 
+    // Short
     void write(Ice::Short);
-    void write(Ice::Short, int limit);
     void write(const Ice::Short*, const Ice::Short*);
     void read(Ice::Short&);
-    void read(Ice::Short&, int limit);
     void read(std::vector<Ice::Short>&);
     Ice::Short* read(std::pair<const Ice::Short*, const Ice::Short*>&);
 
+    // Int
     void write(Ice::Int v) // Inlined for performance reasons.
     {
         Container::size_type pos = b.size();
@@ -568,8 +638,6 @@ public:
 #endif
     }
 
-    void write(Ice::Int, int limit);
-
     void read(Ice::Int& v) // Inlined for performance reasons.
     {
         if(b.end() - i < static_cast<int>(sizeof(Ice::Int)))
@@ -592,24 +660,26 @@ public:
         *dest = *src;
 #endif
     }
-    void read(Ice::Int& v, int limit);
 
     void write(const Ice::Int*, const Ice::Int*);
     void read(std::vector<Ice::Int>&);
     Ice::Int* read(std::pair<const Ice::Int*, const Ice::Int*>&);
 
+    // Long
     void write(Ice::Long);
     void write(const Ice::Long*, const Ice::Long*);
     void read(Ice::Long&);
     void read(std::vector<Ice::Long>&);
     Ice::Long* read(std::pair<const Ice::Long*, const Ice::Long*>&);
 
+    // Float
     void write(Ice::Float);
     void write(const Ice::Float*, const Ice::Float*);
     void read(Ice::Float&);
     void read(std::vector<Ice::Float>&);
     Ice::Float* read(std::pair<const Ice::Float*, const Ice::Float*>&);
 
+    // Double
     void write(Ice::Double);
     void write(const Ice::Double*, const Ice::Double*);
     void read(Ice::Double&);
@@ -625,6 +695,7 @@ public:
     //
     void write(const char*);
 
+    // String
     void writeConverted(const std::string& v);
     void write(const std::string& v, bool convert = true)
     {
@@ -649,8 +720,7 @@ public:
     void readConverted(std::string&, Ice::Int);
     void read(std::string& v, bool convert = true)
     {
-        Ice::Int sz;
-        readSize(sz);
+        Ice::Int sz = readSize();
         if(sz > 0)
         {
             if(b.end() - i < sz)
@@ -679,21 +749,45 @@ public:
     void read(std::wstring&);
     void read(std::vector<std::wstring>&);
 
+    // Proxy
     void write(const Ice::ObjectPrx&);
+    template<typename T> void write(const IceInternal::ProxyHandle<T>& v)
+    {
+        write(Ice::ObjectPrx(upCast(v.get())));
+    }
     void read(Ice::ObjectPrx&);
+    template<typename T> void read(IceInternal::ProxyHandle<T>& v)
+    {
+        __read(this, v); // Generated __read method, necessary for forward declarations.
+    }
 
+    // Class
     void write(const Ice::ObjectPtr& v)
     {
         initWriteEncaps();
         _currentWriteEncaps->encoder->write(v);
     }
+    template<typename T> void write(const IceInternal::Handle<T>& v)
+    {
+        write(Ice::ObjectPtr(upCast(v.get())));
+    }
     void read(PatchFunc patchFunc, void* patchAddr)
     {
         assert(patchFunc && patchAddr);
         initReadEncaps();
         _currentReadEncaps->decoder->read(patchFunc, patchAddr);
     }
-    void write(const Ice::UserException& e)
+    template<typename T> void read(IceInternal::Handle<T>& v)
+    {
+        read(&patchHandle<T>, &v);
+    }
+
+    // Enum
+    Ice::Int readEnum(Ice::Int);
+    void writeEnum(Ice::Int, Ice::Int);
+
+    // Exception
+    void writeException(const Ice::UserException& e)
     {
         initWriteEncaps();
         _currentWriteEncaps->encoder->write(e);
@@ -706,6 +800,40 @@ public:
 
     void sliceObjects(bool);
 
+    // Read/write/skip optionals
+    bool readOptImpl(Ice::Int, Ice::OptionalType);
+    void writeOptImpl(Ice::Int, Ice::OptionalType);
+    bool skipOpt(Ice::OptionalType);
+    bool skipOpts();
+    
+    // Skip bytes from the stream
+    void skip(size_type size)
+    {
+        if(i + size > b.end())
+        {
+            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        }
+        i += size;
+    }    
+    void skipSize()
+    {
+        Ice::Byte b;
+        read(b);
+        if(static_cast<unsigned char>(b) == 255)
+        {
+            skip(4);
+        }
+    }
+
+    size_type pos()
+    {
+        return b.size();
+    }
+    void rewrite(Ice::Int value, size_type p)
+    {
+        write(value, b.begin() + p);
+    }
+
     struct IndirectPatchEntry
     {
         Ice::Int index;
@@ -783,10 +911,21 @@ private:
         void endSlice();
         void skipSlice();
 
-        bool readOpt(int, MemberType);
+        bool readOpt(Ice::Int readTag, Ice::OptionalType expectedType)
+        {
+            if(_sliceType == NoSlice)
+            {
+                return _stream->readOptImpl(readTag, expectedType);
+            }
+            else if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+            {
+                return _stream->readOptImpl(readTag, expectedType);
+            }
+            return false;
+        }
 
         void readPendingObjects();
-        
+
     private:
 
         const std::string& readTypeId() const;
@@ -794,55 +933,6 @@ private:
         void addPatchEntry(Ice::Int, PatchFunc, void*);
         Ice::SlicedDataPtr readSlicedData();
         
-        bool skipOpt(MemberType type)
-        {
-            int sz;
-            switch(type)
-            {
-            case MemberTypeF1:
-            {
-                sz = 1;
-                break;
-            }
-            case MemberTypeF2:
-            {
-                sz = 2;
-                break;
-            }
-            case MemberTypeF4:
-            {
-                sz = 4;
-                break;
-            }
-            case MemberTypeF8:
-            {
-                sz = 8;
-                break;
-            }
-            case MemberTypeVSize:
-            {
-                _stream->readSize(sz);
-                break;
-            }
-            case MemberTypeFSize:
-            {
-                _stream->read(sz);
-                break;
-            }
-            default:
-            {
-                return false;
-            }
-            }
-            
-            if(_stream->i + sz > _stream->b.end())
-            {
-                _stream->throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-            }
-            _stream->i += sz;
-            return true;
-        }
-        
         BasicStream* _stream;
         ReadEncaps* _encaps;
         const bool _sliceObjects;
@@ -891,7 +981,18 @@ private:
         void startSlice(const std::string&, bool);
         void endSlice();
 
-        void writeOpt(int, MemberType);
+        void writeOpt(Ice::Int tag, Ice::OptionalType type)
+        {
+            if(_sliceType == NoSlice)
+            {
+                return _stream->writeOptImpl(tag, type);
+            }
+            else
+            {
+                _sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+                return _stream->writeOptImpl(tag, type);
+            }
+        }
 
         void writePendingObjects();
 
diff --git a/cpp/include/Ice/ObjectF.h b/cpp/include/Ice/ObjectF.h
index 15b664d0638..b4c4be1a55e 100644
--- a/cpp/include/Ice/ObjectF.h
+++ b/cpp/include/Ice/ObjectF.h
@@ -17,10 +17,9 @@ namespace Ice
 {
 
 class Object;
-ICE_API IceUtil::Shared* upCast(::Ice::Object*);
+ICE_API Object* upCast(Object*);
 typedef IceInternal::Handle< Object > ObjectPtr;
-
-void ICE_API __patch__ObjectPtr(void*, ObjectPtr&);
+ICE_API void __patch(ObjectPtr& obj, ObjectPtr& v);
 
 }
 
diff --git a/cpp/include/Ice/SlicedData.h b/cpp/include/Ice/SlicedData.h
index 736a41c9691..2295592925f 100644
--- a/cpp/include/Ice/SlicedData.h
+++ b/cpp/include/Ice/SlicedData.h
@@ -36,6 +36,11 @@ struct ICE_API SliceInfo : public ::IceUtil::Shared
     // The Ice objects referenced by this slice.
     //
     ::std::vector<ObjectPtr> objects;
+
+    //
+    // Whether or not the slice contains optional members.
+    //
+    bool hasOptionalMembers;
 };
 
 //
diff --git a/cpp/include/Ice/Stream.h b/cpp/include/Ice/Stream.h
index 3d758a8a25d..ab889addb7f 100644
--- a/cpp/include/Ice/Stream.h
+++ b/cpp/include/Ice/Stream.h
@@ -17,200 +17,11 @@
 #include <Ice/Proxy.h>
 #include <Ice/SlicedDataF.h>
 #include <IceUtil/Shared.h>
+#include <Ice/StreamTraits.h>
 
 namespace Ice
 {
 
-enum StreamTraitType
-{
-    StreamTraitTypeBuiltin,
-    StreamTraitTypeStruct,
-    StreamTraitTypeStructClass,     // struct with cpp:class metadata
-    StreamTraitTypeByteEnum,        // Enums with up to 127 enumerators
-    StreamTraitTypeShortEnum,       // Enums with up to 32767 enumerators
-    StreamTraitTypeIntEnum,         // Enums with more than 32767 enumerators
-    StreamTraitTypeSequence,
-#ifndef __BCPLUSPLUS__ // COMPILERFIX: See StreamTrait<vector<bool>> comment below
-    StreamTraitTypeSequenceBool,
-#endif
-    StreamTraitTypeDictionary,
-    StreamTraitTypeUserException,
-    StreamTraitTypeUnknown
-};
-
-//
-// Base trait template. This doesn't actually do anything -- we just
-// use it as a template that we can specialize.
-//
-template<typename T>
-struct StreamTrait
-{
-    static const StreamTraitType type = StreamTraitTypeUnknown;
-    static const int minWireSize = 0;
-};
-
-//
-// StreamTrait specialization for std::vector
-//
-template<typename T>
-struct StreamTrait< ::std::vector<T> >
-{
-    static const StreamTraitType type = StreamTraitTypeSequence;
-    static const int minWireSize = 1;
-};
-
-//
-// StreamTrait specialization for std::vector<bool>. Sequences of bool
-// are handled specifically because C++ optimizations for vector<bool>
-// prevent us from reading vector of bools the same way as other
-// sequences (see StreamReader<StreamTraitTypeSequenceBool>::read
-// implementation below)
-//
-// COMPILERFIX: BCC2010 doesn't allow use of full specialization over
-// partial specialization.
-//
-#ifndef __BCPLUSPLUS__
-template<>
-struct StreamTrait< ::std::vector<bool> >
-{
-    static const StreamTraitType type = StreamTraitTypeSequenceBool;
-    static const int minWireSize = 1;
-};
-#endif
-
-template<>
-struct StreamTrait<UserException>
-{
-    static const StreamTraitType type = StreamTraitTypeUserException;
-};
-
-//
-// StreamTrait specialization for std::map.
-//
-template<typename K, typename V>
-struct StreamTrait< ::std::map<K, V> >
-{
-    static const StreamTraitType type = StreamTraitTypeDictionary;
-    static const int minWireSize = 1;
-};
-
-//
-// StreamTrait specialization for builtins (these are needed for sequence
-// marshalling to figure out the minWireSize of each built-in).
-//
-template<>
-struct StreamTrait< bool>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 1;
-};
-
-template<>
-struct StreamTrait< Byte>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 1;
-};
-
-template<>
-struct StreamTrait< Short>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 2;
-};
-
-template<>
-struct StreamTrait< Int>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 4;
-};
-
-template<>
-struct StreamTrait< Long>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 8;
-};
-
-template<>
-struct StreamTrait< Float>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 4;
-};
-
-template<>
-struct StreamTrait< Double>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 8;
-};
-
-template<>
-struct StreamTrait< ::std::string>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 1;
-};
-
-template<>
-struct StreamTrait< ::std::wstring>
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 1;
-};
-
-template<typename T>
-struct StreamTrait< ::IceInternal::ProxyHandle<T> >
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 2;
-};
-
-template<typename T>
-struct StreamTrait< ::IceInternal::Handle<T> >
-{
-    static const StreamTraitType type = StreamTraitTypeBuiltin;
-    static const int minWireSize = 4;
-};
-
-//
-// This is the non-specialized version of the writer. For each kind of
-// user-defined type (enum, struct, etc), we specialize this template
-// to call the correct member function that writes an instance of that
-// type to the stream.
-//
-template<StreamTraitType st>
-struct StreamWriter
-{
-    template<typename T>
-    static void write(const OutputStreamPtr&, const T&)
-    {
-        // This asserts because we end up writing something for which
-        // we never defined a trait.
-        assert(false);
-    }
-};
-
-//
-// This is the non-specialized version of the reader. For each kind of
-// user-defined type (enum, struct, etc), we specialize this template
-// to call the correct member function that reads an instance of that
-// type to the stream.
-//
-template<StreamTraitType st>
-struct StreamReader
-{
-    template<typename T>
-    static void read(const InputStreamPtr&, T&)
-    {
-        // This asserts because we end up reading something for which
-        // we never define a trait.
-        assert(false);
-    }
-};
-
 class ICE_API ReadObjectCallback : public ::IceUtil::Shared
 {
 public:
@@ -298,39 +109,81 @@ public:
     }
 #endif
 
-    ICE_DEPRECATED_API virtual bool readBool() = 0;
-    ICE_DEPRECATED_API virtual Byte readByte() = 0;
-    ICE_DEPRECATED_API virtual Short readShort() = 0;
-    ICE_DEPRECATED_API virtual Int readInt() = 0;
-    ICE_DEPRECATED_API virtual Long readLong() = 0;
-    ICE_DEPRECATED_API virtual Float readFloat() = 0;
-    ICE_DEPRECATED_API virtual Double readDouble() = 0;
-    ICE_DEPRECATED_API virtual ::std::string readString(bool = true) = 0;
-    ICE_DEPRECATED_API virtual ::std::wstring readWstring() = 0;
-
-    ICE_DEPRECATED_API virtual ::std::vector<bool> readBoolSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Byte> readByteSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Short> readShortSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Int> readIntSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Long> readLongSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Float> readFloatSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector<Double> readDoubleSeq() = 0;
-    ICE_DEPRECATED_API virtual ::std::vector< ::std::string> readStringSeq(bool = true) = 0;
-    ICE_DEPRECATED_API virtual ::std::vector< ::std::wstring> readWstringSeq() = 0;
-
-    ICE_DEPRECATED_API virtual bool* readBoolSeq(::std::pair<const bool*, const bool*>&) = 0;
-    ICE_DEPRECATED_API virtual void readByteSeq(::std::pair<const Byte*, const Byte*>&) = 0;
-    ICE_DEPRECATED_API virtual Short* readShortSeq(::std::pair<const Short*, const Short*>&) = 0;
-    ICE_DEPRECATED_API virtual Int* readIntSeq(::std::pair<const Int*, const Int*>&) = 0;
-    ICE_DEPRECATED_API virtual Long* readLongSeq(::std::pair<const Long*, const Long*>&) = 0;
-    ICE_DEPRECATED_API virtual Float* readFloatSeq(::std::pair<const Float*, const Float*>&) = 0;
-    ICE_DEPRECATED_API virtual Double* readDoubleSeq(::std::pair<const Double*, const Double*>&) = 0;
+    //
+    // Sequences of bool are handled specifically because C++
+    // optimizations for vector<bool> prevent us from reading vector
+    // of bools the same way as other sequences.
+    //
+    void 
+    read(std::vector<bool>& v)
+    {
+        Int sz = readAndCheckSeqSize(StreamTrait<bool>::minWireSize);
+        v.resize(sz);
+        for(std::vector<bool>::iterator p = v.begin(); p != v.end(); ++p)
+        {
+            //
+            // We can't just call inS->read(*p) here because *p is
+            // a compiler dependent bit reference.
+            //
+            bool b;
+            read(b);
+            *p = b;
+        }
+    }
 
     virtual Int readSize() = 0;
     virtual Int readAndCheckSeqSize(int) = 0;
 
     virtual ObjectPrx readProxy() = 0;
+    template<typename T> void read(IceInternal::ProxyHandle<T>& v)
+    {
+        ObjectPrx proxy = readProxy();
+        if(!proxy)
+        {
+            v = 0;
+        }
+        else
+        {
+            v = new T;
+            v->__copyFrom(proxy);
+        }
+    }
+
     virtual void readObject(const ReadObjectCallbackPtr&) = 0;
+    template<typename T> void read(IceInternal::Handle<T>& v)
+    {
+        readObject(new ReadObjectCallbackI<T>(v));
+    }
+
+    Int
+    readEnum(Int limit)
+    {
+        if(getEncoding() == Encoding_1_0)
+        {
+            if(limit <= 127)
+            {
+                Byte value;
+                read(value);
+                return value;
+            }
+            else if(limit <= 32767)
+            {
+                Short value;
+                read(value);
+                return value;
+            }
+            else 
+            {
+                Int value;
+                read(value);
+                return value;
+            }
+        }
+        else
+        {
+            return readSize();
+        }
+    }
 
     virtual void throwException() = 0;
     virtual void throwException(const UserExceptionReaderFactoryPtr&) = 0;
@@ -349,10 +202,15 @@ public:
     virtual void endEncapsulation() = 0;
     virtual Ice::EncodingVersion skipEncapsulation() = 0;
 
+    virtual Ice::EncodingVersion getEncoding() = 0;
+
     virtual void readPendingObjects() = 0;
 
     virtual void rewind() = 0;
 
+    virtual void skip(Ice::Int) = 0;
+    virtual void skipSize() = 0;
+
     virtual void read(bool&) = 0;
     virtual void read(Byte&) = 0;
     virtual void read(Short&) = 0;
@@ -372,32 +230,22 @@ public:
     virtual void read(::std::pair<const Float*, const Float*>&, ::IceUtil::ScopedArray<Float>&) = 0;
     virtual void read(::std::pair<const Double*, const Double*>&, ::IceUtil::ScopedArray<Double>&) = 0;
 
-    template<typename T> inline void
-    read(::IceInternal::ProxyHandle<T>& v)
-    {
-        ObjectPrx proxy = readProxy();
-        if(!proxy)
-        {
-            v = 0;
-        }
-        else
-        {
-            v = new T;
-            v->__copyFrom(proxy);
-        }
-    }
+    virtual bool readOptional(Int, OptionalType) = 0; 
 
-    template<typename T> inline void
-    read(::IceInternal::Handle<T>& v)
+    template<typename T> inline void read(T& v)
     {
-        ReadObjectCallbackPtr cb = new ReadObjectCallbackI<T>(v);
-        readObject(cb);
+        StreamHelper<T, StreamTrait<T>::type>::read(this, v);
     }
 
-    template<typename T> inline void
-    read(T& v)
+    template<typename T> inline void read(Ice::Int tag, IceUtil::Optional<T>& v)
     {
-        StreamReader< StreamTrait<T>::type>::read(this, v);
+        if(readOptional(tag, StreamOptionalHelper<T, 
+                                                  Ice::StreamTrait<T>::type, 
+                                                  Ice::StreamTrait<T>::optionalType>::optionalType))
+        {
+            v.__setIsSet();
+            StreamOptionalHelper<T, Ice::StreamTrait<T>::type, Ice::StreamTrait<T>::optionalType>::read(this, *v);
+        }
     }
 
     virtual void closure(void*) = 0;
@@ -408,39 +256,48 @@ class ICE_API OutputStream : public ::IceUtil::Shared
 {
 public:
 
-    virtual CommunicatorPtr communicator() const = 0;
+    typedef size_t size_type;
 
-    ICE_DEPRECATED_API virtual void writeBool(bool) = 0;
-    ICE_DEPRECATED_API virtual void writeByte(Byte) = 0;
-    ICE_DEPRECATED_API virtual void writeShort(Short) = 0;
-    ICE_DEPRECATED_API virtual void writeInt(Int) = 0;
-    ICE_DEPRECATED_API virtual void writeLong(Long) = 0;
-    ICE_DEPRECATED_API virtual void writeFloat(Float) = 0;
-    ICE_DEPRECATED_API virtual void writeDouble(Double) = 0;
-    ICE_DEPRECATED_API virtual void writeString(const ::std::string&, bool = true) = 0;
-    ICE_DEPRECATED_API virtual void writeWstring(const ::std::wstring&)= 0;
-
-    ICE_DEPRECATED_API virtual void writeBoolSeq(const ::std::vector<bool>&) = 0;
-    ICE_DEPRECATED_API virtual void writeByteSeq(const ::std::vector<Byte>&) = 0;
-    ICE_DEPRECATED_API virtual void writeShortSeq(const ::std::vector<Short>&) = 0;
-    ICE_DEPRECATED_API virtual void writeIntSeq(const ::std::vector<Int>&) = 0;
-    ICE_DEPRECATED_API virtual void writeLongSeq(const ::std::vector<Long>&) = 0;
-    ICE_DEPRECATED_API virtual void writeFloatSeq(const ::std::vector<Float>&) = 0;
-    ICE_DEPRECATED_API virtual void writeDoubleSeq(const ::std::vector<Double>&) = 0;
-    ICE_DEPRECATED_API virtual void writeStringSeq(const ::std::vector< ::std::string>&, bool = true) = 0;
-    ICE_DEPRECATED_API virtual void writeWstringSeq(const ::std::vector< ::std::wstring>&) = 0;
-
-    ICE_DEPRECATED_API virtual void writeBoolSeq(const bool*, const bool*) = 0;
-    ICE_DEPRECATED_API virtual void writeByteSeq(const Byte*, const Byte*) = 0;
-    ICE_DEPRECATED_API virtual void writeShortSeq(const Short*, const Short*) = 0;
-    ICE_DEPRECATED_API virtual void writeIntSeq(const Int*, const Int*) = 0;
-    ICE_DEPRECATED_API virtual void writeLongSeq(const Long*, const Long*) = 0;
-    ICE_DEPRECATED_API virtual void writeFloatSeq(const Float*, const Float*) = 0;
-    ICE_DEPRECATED_API virtual void writeDoubleSeq(const Double*, const Double*) = 0;
+    virtual CommunicatorPtr communicator() const = 0;
 
     virtual void writeSize(Int) = 0;
+
     virtual void writeProxy(const ObjectPrx&) = 0;
+    template<typename T> void write(const IceInternal::ProxyHandle<T>& v)
+    {
+        writeProxy(ObjectPrx(upCast(v.get())));
+    }
+
     virtual void writeObject(const ObjectPtr&) = 0;
+    template<typename T> void write(const IceInternal::Handle<T>& v)
+    {
+        writeObject(ObjectPtr(upCast(v.get())));
+    }
+
+    void
+    writeEnum(Int v, Int limit)
+    {
+        if(getEncoding() == Encoding_1_0)
+        {
+            if(limit <= 127)
+            {
+                write(static_cast<Byte>(v));
+            }
+            else if(limit <= 32767)
+            {
+                write(static_cast<Short>(v));
+            }
+            else 
+            {
+                write(v);
+            }
+        }
+        else
+        {
+            writeSize(v);
+        }
+    }
+
     virtual void writeException(const UserException&) = 0;
 
     virtual void format(FormatType) = 0;
@@ -458,10 +315,15 @@ public:
     virtual void startEncapsulation() = 0;
     virtual void endEncapsulation() = 0;
 
+    virtual Ice::EncodingVersion getEncoding() = 0;
+
     virtual void writePendingObjects() = 0;
 
     virtual void finished(::std::vector<Byte>&) = 0;
 
+    virtual size_type pos() = 0;
+    virtual void rewrite(size_type, Int) = 0;
+
     virtual void reset(bool) = 0;
 
     virtual void write(bool) = 0;
@@ -484,264 +346,37 @@ public:
     virtual void write(const Float*, const Float*) = 0;
     virtual void write(const Double*, const Double*) = 0;
 
-    template<typename T> inline void
-    write(const ::IceInternal::ProxyHandle<T>& v)
-    {
-        writeProxy(v);
-    }
-
-    template<typename T> inline void
-    write(const ::IceInternal::Handle<T>& v)
-    {
-        writeObject(v);
-    }
-
-    template<typename T> inline void
-    write(const T& v)
-    {
-        StreamWriter<StreamTrait<T>::type>::write(this, v);
-    }
-};
-
-template<> // StreamWriter specialization for structs
-struct StreamWriter<StreamTraitTypeStruct>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        v.ice_write(outS);
-    }
-};
-
-template<> // StreamReader specialization for structs
-struct StreamReader<StreamTraitTypeStruct>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
-    {
-        v.ice_read(inS);
-    }
-};
-
-template<> // StreamWriter specialization for structs with cpp:class metadata
-struct StreamWriter<StreamTraitTypeStructClass>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        v->ice_write(outS);
-    }
-};
-
-template<> // StreamReader specialization for structs with cpp:class metadata
-struct StreamReader<StreamTraitTypeStructClass>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, const T& v)
-    {
-        v->ice_read(inS);
-    }
-};
-
-template<> // StreamWriter specialization for byte enums
-struct StreamWriter<StreamTraitTypeByteEnum>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        outS->write(static_cast<Byte>(v));
-    }
-};
-
-template<> // StreamReader specialization for byte enums
-struct StreamReader<StreamTraitTypeByteEnum>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
-    {
-        Byte val;
-        inS->read(val);
-        if(val > StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        v = static_cast<T>(val);
-    }
-};
-
-template<> // StreamWriter specialization for short enums
-struct StreamWriter<StreamTraitTypeShortEnum>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        outS->write(static_cast<Short>(v));
-    }
-};
-
-template<> // StreamReader specialization for short enums
-struct StreamReader<StreamTraitTypeShortEnum>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
-    {
-        Short val;
-        inS->read(val);
-        if(val < 0 || val > StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        v = static_cast<T>(val);
-    }
-};
-
-template<> // StreamWriter specialization for int enums
-struct StreamWriter<StreamTraitTypeIntEnum>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        outS->write(static_cast<Int>(v));
-    }
-};
-
-template<> // StreamReader specialization for int enums
-struct StreamReader<StreamTraitTypeIntEnum>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
-    {
-        Int val;
-        inS->read(val);
-        if(val < 0 || val > StreamTrait<T>::enumLimit)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        v = static_cast<T>(val);
-    }
-};
+    virtual void writeOptional(Int, OptionalType) = 0; 
 
-template<> // StreamWriter specialization for sequences
-struct StreamWriter<StreamTraitTypeSequence>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
+    template<typename T> inline void write(const T& v)
     {
-        outS->writeSize(static_cast<Int>(v.size()));
-        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
-        {
-            outS->write(*p);
-        }
+        StreamHelper<T, StreamTrait<T>::type>::write(this, v);
     }
-};
 
-template<> // StreamReader specialization for sequences
-struct StreamReader<StreamTraitTypeSequence>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
+    template<typename T> inline void write(Ice::Int tag, const IceUtil::Optional<T>& v)
     {
-        Int sz = inS->readAndCheckSeqSize(StreamTrait<typename T::value_type>::minWireSize);
-        v.resize(sz);
-        for(typename T::iterator p = v.begin(); p != v.end(); ++p)
+        if(v)
         {
-            inS->read(*p);
+            writeOptional(tag, StreamOptionalHelper<T,
+                                                    Ice::StreamTrait<T>::type, 
+                                                    Ice::StreamTrait<T>::optionalType>::optionalType);
+            StreamOptionalHelper<T, Ice::StreamTrait<T>::type, Ice::StreamTrait<T>::optionalType>::write(this, *v);
         }
     }
-};
 
-#ifndef __BCPLUSPLUS__ // COMPILERFIX: See StreamTrait<vector<bool>> comment above
-template<> // StreamWriter specialization for sequences of bool
-struct StreamWriter<StreamTraitTypeSequenceBool>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        outS->writeSize(static_cast<Int>(v.size()));
-        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
-        {
-            outS->write(*p);
-        }
-    }
-};
-
-template<> // Reader specialization for sequences of bool
-struct StreamReader<StreamTraitTypeSequenceBool>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
-    {
-        Int sz = inS->readAndCheckSeqSize(StreamTrait<bool>::minWireSize);
-        v.resize(sz);
-        for(typename T::iterator p = v.begin(); p != v.end(); ++p)
-        {
-            //
-            // We can't just call inS->read(*p) here because *p is
-            // a compiler dependent bit reference.
-            //
-            bool b;
-            inS->read(b);
-            *p = b;
-        }
-    }
-};
-#endif
-
-template<> // StreamWriter specialization for dictionaries.
-struct StreamWriter<StreamTraitTypeDictionary>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        outS->writeSize(static_cast<Int>(v.size()));
-        typename T::const_iterator p;
-        for(p = v.begin(); p != v.end(); ++p)
-        {
-            outS->write(p->first);
-            outS->write(p->second);
-        }
-    }
-};
-
-template<> // StreamReader specialization for dictionaries.
-struct StreamReader<StreamTraitTypeDictionary>
-{
-    template<typename T>
-    static void read(const InputStreamPtr& inS, T& v)
+    //
+    // Template functions for sequences and custom sequences
+    // 
+    template<typename T> void write(const T* begin, const T* end)
     {
-        Int sz = inS->readSize();
-        while(sz--)
+        writeSize(static_cast<Ice::Int>(end - begin));
+        for(const T* p = begin; p != end; ++p)
         {
-            typename T::value_type p;
-            inS->read(const_cast<typename T::key_type&>(p.first));
-            typename T::iterator i = v.insert(v.end(), p);
-            inS->read(i->second);
+            write(*p);
         }
     }
 };
 
-template<> // StreamWriter specialization for UserExceptions.
-struct StreamWriter<StreamTraitTypeUserException>
-{
-    template<typename T>
-    static void write(const OutputStreamPtr& outS, const T& v)
-    {
-        outS->writeException(v);
-    }
-};
-
 class ICE_API ObjectReader : public Object
 {
 public:
diff --git a/cpp/include/Ice/StreamTraits.h b/cpp/include/Ice/StreamTraits.h
new file mode 100644
index 00000000000..7fb60324802
--- /dev/null
+++ b/cpp/include/Ice/StreamTraits.h
@@ -0,0 +1,805 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_STREAM_TRAITS_H
+#define ICE_STREAM_TRAITS_H
+
+#include <IceUtil/ScopedArray.h>
+#include <IceUtil/Iterator.h>
+
+#include <Ice/ObjectF.h>
+
+
+namespace Ice
+{
+
+//
+// The different types of Slice types supported by the stream
+// marshalling/un-marshalling methods.
+//
+enum StreamTraitType
+{
+    StreamTraitTypeBuiltin,
+    StreamTraitTypeStruct,
+    StreamTraitTypeStructClass, // struct with cpp:class metadata
+    StreamTraitTypeEnum,
+    StreamTraitTypeSequence,
+    StreamTraitTypeDictionary,
+    StreamTraitTypeProxy,
+    StreamTraitTypeClass,
+    StreamTraitTypeUserException,
+    StreamTraitTypeUnknown
+};
+
+//
+// The optional type.
+//
+// Optional data members or attribute is encoded with a specific
+// optional type. This optional type describes how the data is encoded
+// and how it can be skiped by the un-marhsalling code if the optional
+// isn't known to the receiver.
+//
+enum OptionalType
+{
+    OptionalTypeF1 = 0,
+    OptionalTypeF2 = 1,
+    OptionalTypeF4 = 2,
+    OptionalTypeF8 = 3,
+    OptionalTypeSize = 4,
+    OptionalTypeVSize = 5,
+    OptionalTypeFSize = 6,
+    OptionalTypeEndMarker = 7
+};
+
+//
+// Base trait template. This doesn't actually do anything -- we just
+// use it as a template that we can specialize. 
+//
+// Note that types which don't define a specialized trait will end up
+// using this trait. The marshalling of unknown types assume that 
+// such traits are custom sequences. If not appropriate, a trait has
+// to defined with the appropriate type.
+//
+template<typename T>
+struct StreamTrait
+{
+    static const StreamTraitType type = StreamTraitTypeUnknown;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize; // Not used
+    static const bool isVariableLength = true;
+};
+
+//
+// StreamTrait specialization for std::vector
+//
+template<typename T>
+struct StreamTrait< ::std::vector<T> >
+{
+    static const StreamTraitType type = StreamTraitTypeSequence;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize; // Not used but still need to be defined.
+    static const bool isVariableLength = true;
+};
+
+template<typename T, typename U>
+struct StreamTrait< ::std::pair<T, U> >
+{
+    static const StreamTraitType type = StreamTraitTypeSequence;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize; // Not used but still need to be defined.
+    static const bool isVariableLength = true;
+};
+
+//
+// StreamTrait specialization for user exceptions.
+//
+template<>
+struct StreamTrait<UserException>
+{
+    static const StreamTraitType type = StreamTraitTypeUserException;
+};
+
+//
+// StreamTrait specialization for std::map.
+//
+template<typename K, typename V>
+struct StreamTrait< ::std::map<K, V> >
+{
+    static const StreamTraitType type = StreamTraitTypeDictionary;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize; // Not used
+    static const bool isVariableLength = true;
+};
+
+//
+// StreamTrait specialization for builtins (these are needed for sequence
+// marshalling to figure out the minWireSize of each built-in).
+//
+template<>
+struct StreamTrait< bool>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeF1;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Byte>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeF1;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Short>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 2;
+    static const OptionalType optionalType = OptionalTypeF2;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Int>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 4;
+    static const OptionalType optionalType = OptionalTypeF4;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Long>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 8;
+    static const OptionalType optionalType = OptionalTypeF8;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Float>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 4;
+    static const OptionalType optionalType = OptionalTypeF4;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< Double>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 8;
+    static const OptionalType optionalType = OptionalTypeF8;
+    static const bool isVariableLength = false;
+};
+
+template<>
+struct StreamTrait< ::std::string>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize;
+    static const bool isVariableLength = true;
+};
+
+template<>
+struct StreamTrait< ::std::wstring>
+{
+    static const StreamTraitType type = StreamTraitTypeBuiltin;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeVSize;
+    static const bool isVariableLength = true;
+};
+
+template<typename T>
+struct StreamTrait< ::IceInternal::ProxyHandle<T> >
+{
+    static const StreamTraitType type = StreamTraitTypeProxy;
+    static const int minWireSize = 2;
+    static const OptionalType optionalType = OptionalTypeFSize;
+    static const bool isVariableLength = true;
+};
+
+template<typename T>
+struct StreamTrait< ::IceInternal::Handle<T> >
+{
+    static const StreamTraitType type = StreamTraitTypeClass;
+    static const int minWireSize = 1;
+    static const OptionalType optionalType = OptionalTypeSize;
+    static const bool isVariableLength = true;
+};
+
+//
+// StreamHelper templates used by streams to read and write data.
+//
+
+template<typename T, StreamTraitType st> 
+struct StreamHelper 
+{
+    template<class S> static inline void
+    write(S* stream, const T& v)
+    {
+        assert(false);
+    }
+
+    template<class S> static inline void
+    read(S* stream, T& v)
+    {
+        assert(false);
+    }
+};
+
+template<typename T, StreamTraitType st, OptionalType ot>
+struct StreamOptionalHelper 
+{
+    static const OptionalType optionalType = ot;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        assert(ot != OptionalTypeVSize && ot != OptionalTypeFSize || st == StreamTraitTypeBuiltin);
+        StreamHelper<T, st>::write(stream, v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        assert(ot != OptionalTypeVSize && ot != OptionalTypeFSize || st == StreamTraitTypeBuiltin);
+        StreamHelper<T, st>::read(stream, v);
+    }
+};
+
+// Helper for builtins, delegates read/write to the stream.
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeBuiltin>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->write(v);
+    }
+
+    template<class S> static inline void
+    read(S* stream, T& v)
+    {
+        stream->read(v);
+    }
+};
+
+// Helper for structs, uses generated __read/__write methods
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeStruct>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        v.__write(stream);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        v.__read(stream);
+    }
+};
+
+// Helper for class structs, uses generated __read/__write methods
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeStructClass>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        v->__write(stream);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        v = new typename T::element_type();
+        v->__read(stream);
+    }
+};
+
+// Helper for enums
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeEnum>
+{
+    template<class S> static inline void
+    write(S* stream, const T& v)
+    {
+        if(static_cast<Int>(v) < 0 || static_cast<Int>(v) >= StreamTrait<T>::enumLimit)
+        {
+            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
+        }
+        stream->writeEnum(static_cast<Int>(v), StreamTrait<T>::enumLimit);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        Int value = stream->readEnum(StreamTrait<T>::enumLimit);
+        if(value < 0 || value >= StreamTrait<T>::enumLimit)
+        {
+            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
+        }
+        v = static_cast<T>(value);
+    }
+};
+
+// Helper for sequences
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeSequence>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->writeSize(static_cast<Int>(v.size()));
+        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
+        {
+            stream->write(*p);
+        }
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        Int sz = stream->readAndCheckSeqSize(StreamTrait<T>::minWireSize);
+        T(sz).swap(v);
+        for(typename T::iterator p = v.begin(); p != v.end(); ++p)
+        {
+            stream->read(*p);
+        }
+    }
+};
+
+// Helper for array and range:array custom sequence parameters
+template<typename T>
+struct StreamHelper<std::pair<const T*, const T*>, StreamTraitTypeSequence>
+{
+    template<class S> static inline void 
+    write(S* stream, const std::pair<const T*, const T*>& v)
+    {
+        stream->write(v.first, v.second);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, std::pair<const T*, const T*>& v)
+    {
+        stream->read(v);
+    }
+};
+
+// Helper for range custom sequence parameters
+template<typename T>
+struct StreamHelper<std::pair<T, T>, StreamTraitTypeSequence>
+{
+    template<class S> static inline void 
+    write(S* stream, const std::pair<T, T>& v)
+    {
+        stream->writeSize(static_cast< ::Ice::Int>(IceUtilInternal::distance(v.first, v.second)));
+        for(T p = v.first; p != v.second; ++p)
+        {
+            stream->write(*p);
+        }
+    }
+
+    template<class S> static inline void 
+    read(S* stream, std::pair<T, T>& v)
+    {
+        stream->read(v);
+    }
+};
+
+// Helper for zero-copy array sequence parameters
+template<typename T>
+struct StreamHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >, StreamTraitTypeSequence>
+{
+    template<class S> static inline void 
+    write(S* stream, const std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> > & v)
+    {
+        assert(false); // Only used to un-marshal
+    }
+
+    template<class S> static inline void 
+    read(S* stream, std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >& v)
+    {
+        v.first.reset(stream->read(v.second));
+    }
+};
+
+// Helper for dictionaries
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeDictionary>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->writeSize(static_cast<Int>(v.size()));
+        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
+        {
+            stream->write(p->first);
+            stream->write(p->second);
+        }
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        Int sz = stream->readSize();
+        while(sz--)
+        {
+            typename T::value_type p;
+            stream->read(const_cast<typename T::key_type&>(p.first));
+            typename T::iterator i = v.insert(v.end(), p);
+            stream->read(i->second);
+        }
+    }
+};
+
+// Helper for user exceptions
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeUserException>
+{
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->writeException(v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        assert(false);
+    }
+};
+
+// Helper for proxies
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeProxy>
+{
+    template<class S> static inline void
+    write(S* stream, const T& v)
+    {
+        stream->write(v);
+    }
+
+    template<class S> static inline void
+    read(S* stream, T& v)
+    {
+        stream->read(v);
+    }
+};
+
+// Helper for classes
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeClass>
+{
+    template<class S> static inline void
+    write(S* stream, const T& v)
+    {
+        stream->write(v);
+    }
+
+    template<class S> static inline void
+    read(S* stream, T& v)
+    {
+        stream->read(v);
+    }
+};
+
+// Helper for unknown types, assume custom sequences.
+template<typename T>
+struct StreamHelper<T, StreamTraitTypeUnknown> : StreamHelper<T, StreamTraitTypeSequence>
+{
+};
+
+//
+// Helpers to read/write optional attributes or members.
+//
+
+// Helper to write fixed size structs
+template<typename T>
+struct StreamOptionalHelper<T, StreamTraitTypeStruct, OptionalTypeVSize>
+{
+    static const OptionalType optionalType = OptionalTypeVSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->writeSize(StreamTrait<T>::minWireSize);
+        stream->write(v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        stream->skipSize();
+        stream->read(v);
+    }
+};
+
+// Helper to write variable size structs
+template<typename T>
+struct StreamOptionalHelper<T, StreamTraitTypeStruct, OptionalTypeFSize>
+{
+    static const OptionalType optionalType = OptionalTypeFSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        stream->write((Int)0);
+        typename S::size_type p = stream->pos();
+        stream->write(v);
+        stream->rewrite(static_cast<Int>(stream->pos() - p), p - 4);
+    }
+
+    template<class S> static inline void
+    read(S* stream, T& v)
+    {
+        stream->skip(4);
+        stream->read(v);
+    }
+};
+
+// Class structs are encoded like structs 
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<T, StreamTraitTypeStructClass, ot> : StreamOptionalHelper<T, StreamTraitTypeStruct, ot>
+{
+};
+
+// Optional proxies are encoded like variable size structs, using the FSize encoding
+template<typename T>
+struct StreamOptionalHelper<T, StreamTraitTypeProxy, OptionalTypeFSize> : 
+    StreamOptionalHelper<T, StreamTraitTypeStruct, OptionalTypeFSize>
+{
+};
+
+//
+// Helpers to read/write optional sequences or dictionaries
+//
+
+template<typename T, bool isVariableLength, int sz>
+struct StreamOptionalContainerHelper
+{
+    static const OptionalType optionalType = OptionalTypeFSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v, Ice::Int n) 
+    {
+        assert(false); 
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v) 
+    { 
+        assert(false); 
+    }
+};
+
+//
+// Encode containers of variable size elements with the FSize optional
+// type, since we can't easily figure out the size of the container
+// before encoding. This is the same encoding as variable size structs
+// so we just re-use its implementation.
+//
+template<typename T, int sz>
+struct StreamOptionalContainerHelper<T, true, sz>
+{
+    static const OptionalType optionalType = OptionalTypeFSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v, Ice::Int n) 
+    {
+        StreamOptionalHelper<T, StreamTraitTypeStruct, OptionalTypeFSize>::write(stream, v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v) 
+    {
+        StreamOptionalHelper<T, StreamTraitTypeStruct, OptionalTypeFSize>::read(stream, v);
+    }
+};
+
+//
+// Encode containers of fixed size elements with the VSize optional
+// type since we can figure out the size of the container before
+// encoding. 
+//
+template<typename T, int sz>
+struct StreamOptionalContainerHelper<T, false, sz>
+{ 
+    static const OptionalType optionalType = OptionalTypeVSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v, Ice::Int n)
+    {
+        //
+        // The container size is the number of elements * the size of
+        // an element and the size-encoded number of elements (1 or
+        // 5 depending on the number of elements).
+        //
+        stream->writeSize(sz * n + (n < 255 ? 1 : 5));
+        stream->write(v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        stream->skipSize();
+        stream->read(v);
+    }
+};
+
+//
+// Optimization: containers of 1 byte elements are encoded with the
+// VSize optional type. There's no need to encode an additional size
+// for those, the number of elements of the container can be used to
+// skip the optional.
+//
+template<typename T>
+struct StreamOptionalContainerHelper<T, false, 1>
+{ 
+    static const OptionalType optionalType = OptionalTypeVSize;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v, Ice::Int n) 
+    {
+        StreamOptionalHelper<T, StreamTraitTypeBuiltin, OptionalTypeVSize>::write(stream, v);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        StreamOptionalHelper<T, StreamTraitTypeBuiltin, OptionalTypeVSize>::read(stream, v);
+    }
+};
+
+//
+// Helper to write sequences, delegates to the optional container
+// helper template partial specializations.
+//
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<T, StreamTraitTypeSequence, ot>
+{
+    typedef typename T::value_type E;
+    static const int size = StreamTrait<E>::minWireSize;
+    static const bool isVariableLength = StreamTrait<E>::isVariableLength;
+
+    // The optional type of a sequence depends on wether or not elements are fixed
+    // or variable size elements and their size.
+    static const OptionalType optionalType = StreamOptionalContainerHelper<T, isVariableLength, size>::optionalType;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        StreamOptionalContainerHelper<T, isVariableLength, size>::write(stream, v, v.size());
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        StreamOptionalContainerHelper<T, isVariableLength, size>::read(stream, v);
+    }
+};
+
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<std::pair<const T*, const T*>, StreamTraitTypeSequence, ot>
+{
+    typedef std::pair<const T*, const T*> P;
+    static const int size = StreamTrait<T>::minWireSize;
+    static const bool isVariableLength = StreamTrait<T>::isVariableLength;
+
+    // The optional type of a sequence depends on wether or not elements are fixed
+    // or variable size elements and their size.
+    static const OptionalType optionalType = StreamOptionalContainerHelper<P, isVariableLength, size>::optionalType;
+
+    template<class S> static inline void 
+    write(S* stream, const P& v)
+    {
+        Ice::Int n = static_cast<Ice::Int>(v.second - v.first);
+        StreamOptionalContainerHelper<P, isVariableLength, size>::write(stream, v, n);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, P& v)
+    {
+        StreamOptionalContainerHelper<P, isVariableLength, size>::read(stream, v);
+    }
+};
+
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<std::pair<T, T>, StreamTraitTypeSequence, ot>
+{
+    typedef std::pair<T, T> P;
+    static const int size = StreamTrait<typename T::value_type>::minWireSize;
+    static const bool isVariableLength = StreamTrait<typename T::value_type>::isVariableLength;
+
+    // The optional type of a sequence depends on wether or not elements are fixed
+    // or variable size elements and their size.
+    static const OptionalType optionalType = StreamOptionalContainerHelper<P, isVariableLength, size>::optionalType;
+
+    template<class S> static inline void 
+    write(S* stream, const P& v)
+    {
+        Ice::Int n = static_cast<Ice::Int>(v.second - v.first);
+        StreamOptionalContainerHelper<P, isVariableLength, size>::write(stream, v, n);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, P& v)
+    {
+        StreamOptionalContainerHelper<P, isVariableLength, size>::read(stream, v);
+    }
+};
+
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >,
+                            StreamTraitTypeSequence, ot>
+{
+    typedef std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> > P;
+    static const int size = StreamTrait<T>::minWireSize;
+    static const bool isVariableLength = StreamTrait<T>::isVariableLength;
+
+    // The optional type of a sequence depends on wether or not elements are fixed
+    // or variable size elements and their size.
+    static const OptionalType optionalType = StreamOptionalContainerHelper<P, isVariableLength, size>::optionalType;
+
+    template<class S> static inline void 
+    write(S* stream, const P& v)
+    {
+        assert(false);
+    }
+
+    template<class S> static inline void 
+    read(S* stream, P& v)
+    {
+        StreamOptionalContainerHelper<P, isVariableLength, size>::read(stream, v);
+    }
+};
+
+
+//
+// Helper to write dictionaries, delegates to the optional container
+// helper template partial specializations.
+//
+template<typename T, OptionalType ot>
+struct StreamOptionalHelper<T, StreamTraitTypeDictionary, ot>
+{
+    typedef typename T::key_type K;
+    typedef typename T::mapped_type V;
+
+    static const int size = StreamTrait<K>::minWireSize + StreamTrait<V>::minWireSize;
+    static const bool isVariableLength = StreamTrait<K>::isVariableLength || StreamTrait<V>::isVariableLength;
+
+    // The optional type of a dictionary depends on wether or not elements are fixed
+    // or variable size elements.
+    static const OptionalType optionalType = StreamOptionalContainerHelper<T, isVariableLength, size>::optionalType;
+
+    template<class S> static inline void 
+    write(S* stream, const T& v)
+    {
+        StreamOptionalContainerHelper<T, isVariableLength, size>::write(stream, v, v.size());
+    }
+
+    template<class S> static inline void 
+    read(S* stream, T& v)
+    {
+        StreamOptionalContainerHelper<T, isVariableLength, size>::read(stream, v);
+    }
+};
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Exception.h b/cpp/include/IceUtil/Exception.h
index 18b1296b303..03a6fa6d836 100644
--- a/cpp/include/IceUtil/Exception.h
+++ b/cpp/include/IceUtil/Exception.h
@@ -119,6 +119,21 @@ private:
     std::string _path;
 };
 
+class ICE_UTIL_API OptionalNotSetException : public Exception
+{
+public:
+    
+    OptionalNotSetException(const char*, int);
+    virtual ~OptionalNotSetException() throw();
+    virtual std::string ice_name() const;
+    virtual Exception* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
 }
 
 #endif
diff --git a/cpp/include/IceUtil/Optional.h b/cpp/include/IceUtil/Optional.h
new file mode 100644
index 00000000000..17c7ffa6a81
--- /dev/null
+++ b/cpp/include/IceUtil/Optional.h
@@ -0,0 +1,290 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_OPTIONAL_H
+#define ICE_UTIL_OPTIONAL_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtilInternal
+{
+
+struct NoneType 
+{
+};
+
+}
+
+namespace IceUtil
+{
+
+const IceUtilInternal::NoneType None = {};
+
+template<typename T>
+class Optional
+{
+public:
+
+    typedef T element_type;
+
+    Optional() : _isSet(false)
+    {
+    }
+
+    Optional(IceUtilInternal::NoneType) : _isSet(false)
+    {
+    }
+
+    Optional(const T& p) : _value(p), _isSet(true)
+    {
+    }
+    
+    template<typename Y>
+    Optional(const Optional<Y>& r) : _value(r._value), _isSet(r._isSet)
+    {
+    }
+
+    Optional(const Optional& r) : _value(r._value), _isSet(r._isSet)
+    {
+    }
+    
+    ~Optional()
+    {
+    }
+    
+    Optional& operator=(IceUtilInternal::NoneType)
+    {
+        _value = T();
+        _isSet = false;
+        return *this;
+    }
+
+    Optional& operator=(const T& p)
+    {
+        _value = p;
+        _isSet = true;
+        return *this;
+    }
+        
+    template<typename Y>
+    Optional& operator=(const Optional<Y>& r)
+    {
+        _value = r._value;
+        _isSet = r._isSet;
+        return *this;
+    }
+
+    Optional& operator=(const Optional& r)
+    {
+        _value = r._value;
+        _isSet = r._isSet;
+        return *this;
+    }
+
+    const T& get() const
+    {
+        checkIsSet();
+        return _value;
+    }
+    T& get()
+    {
+        checkIsSet();
+        return _value;
+    }
+
+    const T* operator->() const
+    {
+        return &get();
+    }
+    T* operator->()
+    {
+        return &get();
+    }
+
+    const T& operator*() const
+    {
+        return get();
+    }
+    T& operator*()
+    {
+        return get();
+    }
+
+    operator bool() const
+    {
+        return _isSet;
+    }
+
+    bool operator!() const 
+    { 
+        return !_isSet;
+    }
+
+    void swap(Optional& other)
+    {
+        std::swap(_isSet, other._isSet);
+        std::swap(_value, other._value);
+    }
+
+    void __setIsSet()
+    {
+        _isSet = true;
+    }
+
+private:
+
+    void checkIsSet() const
+    {
+        if(!_isSet)
+        {
+            throwOptionalNotSetException(__FILE__, __LINE__);
+        }
+    }
+    
+    void throwOptionalNotSetException(const char *, int) const;
+
+    T _value;
+    bool _isSet;
+};
+
+template<typename T> inline void 
+Optional<T>::throwOptionalNotSetException(const char* file, int line) const
+{
+    throw OptionalNotSetException(file, line);
+}
+
+template<typename T, typename U>
+inline bool operator==(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs == *rhs;
+    }
+
+    // Note: don't use if { } else { }. This causes lots warnings when
+    // compiling with GCC and optimization enabled. See bug 2330.
+    return !lhs && !rhs;
+}
+
+template<typename T, typename U>
+inline bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !operator==(lhs, rhs);
+}
+
+template<typename T, typename U>
+inline bool operator<(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs < *rhs;
+    }
+
+    // Note: don't use if { } else { }. This causes lots warnings when
+    // compiling with GCC and optimization enabled. See bug 2330.
+    return !lhs && rhs;
+}
+
+template<typename T, typename U>
+inline bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return lhs < rhs || lhs == rhs;
+}
+
+template<typename T, typename U>
+inline bool operator>(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !(lhs < rhs || lhs == rhs);
+}
+
+template<typename T, typename U>
+inline bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+// Optional<T> vs Y
+
+template<typename T, typename Y>
+inline bool operator==(const Optional<T>& lhs, const Y& rhs)
+{
+    return operator==(lhs, Optional<Y>(rhs));
+}
+
+template<typename T, typename Y>
+inline bool operator!=(const Optional<T>& lhs, const Y& rhs)
+{
+    return !operator==(lhs, Optional<Y>(rhs));
+}
+
+template<typename T, typename Y>
+inline bool operator<(const Optional<T>& lhs, const Y& rhs)
+{
+    return operator<(lhs, Optional<Y>(rhs));
+}
+
+template<typename T, typename Y>
+inline bool operator<=(const Optional<T>& lhs, const Y& rhs)
+{
+    return operator<=(lhs, Optional<Y>(rhs));
+}
+
+template<typename T, typename Y>
+inline bool operator>(const Optional<T>& lhs, const Y& rhs)
+{
+    return operator>(lhs, Optional<Y>(rhs));
+}
+
+template<typename T, typename Y>
+inline bool operator>=(const Optional<T>& lhs, const Y& rhs)
+{
+    return operator>=(lhs, Optional<Y>(rhs));
+}
+
+// Y vs Optional<T>
+
+template<typename T, typename Y>
+inline bool operator==(const Y& lhs, const Optional<Y>& rhs)
+{
+    return operator==(Optional<Y>(lhs), rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator!=(const Y& lhs, const Optional<Y>& rhs)
+{
+    return !operator==(Optional<Y>(lhs), rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator<(const Y& lhs, const Optional<Y>& rhs)
+{
+    return operator<(Optional<Y>(lhs), rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator<=(const Y& lhs, const Optional<Y>& rhs)
+{
+    return operator<=(Optional<Y>(lhs), rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator>(const Y& lhs, const Optional<Y>& rhs)
+{
+    return operator>(Optional<Y>(lhs), rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator>=(const Y& lhs, const Optional<Y>& rhs)
+{
+    return operator>=(Optional<Y>(lhs), rhs);
+}
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/ScopedArray.h b/cpp/include/IceUtil/ScopedArray.h
index b5001ea96ff..8e1d0d0ddf0 100644
--- a/cpp/include/IceUtil/ScopedArray.h
+++ b/cpp/include/IceUtil/ScopedArray.h
@@ -16,7 +16,7 @@ namespace IceUtil
 {
 
 template<typename T>
-class ScopedArray : private IceUtil::noncopyable
+class ScopedArray
 {
 public:
 
@@ -49,6 +49,18 @@ public:
         _ptr = ptr;
     }
 
+    const ScopedArray& operator=(const ScopedArray& other)
+    {
+        if(_ptr != 0)
+        {
+            delete[] _ptr;
+        }
+        _ptr = other._ptr;
+        const_cast<ScopedArray&>(other)._ptr = 0;
+        return *this;
+    }
+
+
     T& operator[](size_t i) const
     {
         assert(_ptr != 0);
diff --git a/cpp/include/Slice/CPlusPlusUtil.h b/cpp/include/Slice/CPlusPlusUtil.h
index 641ad1f6098..f8aeb5f19b3 100644
--- a/cpp/include/Slice/CPlusPlusUtil.h
+++ b/cpp/include/Slice/CPlusPlusUtil.h
@@ -35,36 +35,31 @@ const int TypeContextAMICallPrivateEnd = 8;
 const int TypeContextUseWstring = 16;
 
 SLICE_API std::string typeToString(const TypePtr&, const StringList& = StringList(), int = 0);
-SLICE_API std::string returnTypeToString(const TypePtr&, const StringList& = StringList(), int = 0);
-SLICE_API std::string inputTypeToString(const TypePtr&, const StringList& = StringList(), int = 0);
-SLICE_API std::string outputTypeToString(const TypePtr&, const StringList& = StringList(), int = 0);
+SLICE_API std::string typeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string returnTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string inputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string outputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
 SLICE_API std::string operationModeToString(Operation::Mode);
 SLICE_API std::string formatTypeToString(FormatType);
 
 SLICE_API std::string fixKwd(const std::string&);
 
-SLICE_API void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, const std::string&, bool,
-                                         const std::string& = "", bool = true, const StringList& = StringList(),
-                                         int = 0);
+SLICE_API void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, bool, int, const std::string&,
+                                         bool, const StringList& = StringList(), int = 0, const std::string& = "",
+                                         bool = true);
                                              
-SLICE_API void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const TypePtr&, 
-                                const StringList&, int = 0);
-SLICE_API void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const TypePtr&,
-                                  const StringList&, int = 0);
-
-SLICE_API void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const TypePtr&,
-                                 const StringList&, int = 0);
-
-SLICE_API void writeStreamMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, const std::string&, bool,
-                                               const std::string& = "", const StringList& = StringList(), int = 0);
+SLICE_API void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
+SLICE_API void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
+SLICE_API void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
 
 SLICE_API std::string getEndArg(const TypePtr&, const StringList&, const std::string&);
-SLICE_API void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const TypePtr&, const StringList&);
+SLICE_API void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&);
 
 SLICE_API std::string findMetaData(const SequencePtr&, const StringList&, bool&, int = 0);
 SLICE_API std::string findMetaData(const StringList&, int = 0);
 SLICE_API bool inWstringModule(const SequencePtr&);
 
+SLICE_API std::string getDataMemberRef(const DataMemberPtr&);
 }
 
 #endif
diff --git a/cpp/include/Slice/Parser.h b/cpp/include/Slice/Parser.h
index 0705639a0b0..261a106bb38 100644
--- a/cpp/include/Slice/Parser.h
+++ b/cpp/include/Slice/Parser.h
@@ -157,7 +157,7 @@ struct ConstDef
     std::string valueAsLiteral;
 };
 
-struct DataMemberDef
+struct OptionalDef
 {
     TypePtr type;
     std::string name;
@@ -588,9 +588,11 @@ public:
     };
 
     TypePtr returnType() const;
+    bool returnIsOptional() const;
+    int returnTag() const;
     Mode mode() const;
     Mode sendMode() const;
-    ParamDeclPtr createParamDecl(const std::string&, const TypePtr&, bool);
+    ParamDeclPtr createParamDecl(const std::string&, const TypePtr&, bool, bool, int);
     ParamDeclList parameters() const;
     ExceptionList throws() const;
     void setExceptionList(const ExceptionList&);
@@ -606,10 +608,12 @@ public:
 
 protected:
 
-    Operation(const ContainerPtr&, const std::string&, const TypePtr&, Mode);
+    Operation(const ContainerPtr&, const std::string&, const TypePtr&, bool, int, Mode);
     friend class ClassDef;
 
     TypePtr _returnType;
+    bool _returnIsOptional;
+    int _returnTag;
     ExceptionList _throws;
     Mode _mode;
 };
@@ -630,7 +634,7 @@ class SLICE_API ClassDef : virtual public Container, virtual public Contained
 public:
 
     virtual void destroy();
-    OperationPtr createOperation(const std::string&, const TypePtr&, Operation::Mode = Operation::Normal);
+    OperationPtr createOperation(const std::string&, const TypePtr&, bool, int, Operation::Mode = Operation::Normal);
     DataMemberPtr createDataMember(const std::string&, const TypePtr&, bool, int, const SyntaxTreeBasePtr&,
                                    const std::string&, const std::string&);
     ClassDeclPtr declaration() const;
@@ -639,6 +643,7 @@ public:
     OperationList operations() const;
     OperationList allOperations() const;
     DataMemberList dataMembers() const;
+    DataMemberList orderedOptionalDataMembers() const;
     DataMemberList allDataMembers() const;
     DataMemberList classDataMembers() const;
     DataMemberList allClassDataMembers() const;
@@ -705,6 +710,7 @@ public:
     DataMemberPtr createDataMember(const std::string&, const TypePtr&, bool, int, const SyntaxTreeBasePtr&,
                                    const std::string&, const std::string&);
     DataMemberList dataMembers() const;
+    DataMemberList orderedOptionalDataMembers() const;
     DataMemberList allDataMembers() const;
     DataMemberList classDataMembers() const;
     DataMemberList allClassDataMembers() const;
@@ -911,6 +917,8 @@ public:
 
     TypePtr type() const;
     bool isOutParam() const;
+    bool optional() const;
+    int tag() const;
     virtual ContainedType containedType() const;
     virtual bool uses(const ContainedPtr&) const;
     virtual std::string kindOf() const;
@@ -918,11 +926,13 @@ public:
 
 protected:
 
-    ParamDecl(const ContainerPtr&, const std::string&, const TypePtr&, bool isOutParam);
+    ParamDecl(const ContainerPtr&, const std::string&, const TypePtr&, bool, bool, int);
     friend class Operation;
 
     TypePtr _type;
     bool _isOutParam;
+    bool _optional;
+    int _tag;
 };
 
 // ----------------------------------------------------------------------
diff --git a/cpp/include/Slice/Util.h b/cpp/include/Slice/Util.h
index 3807647d59f..340f3eb6caa 100644
--- a/cpp/include/Slice/Util.h
+++ b/cpp/include/Slice/Util.h
@@ -27,6 +27,7 @@ SLICE_API void emitWarning(const std::string&, const std::string&, const std::st
 SLICE_API void emitRaw(const char*);
 SLICE_API std::vector<std::string> filterMcppWarnings(const std::string&);
 SLICE_API void printGeneratedHeader(IceUtilInternal::Output& out, const std::string&, const std::string& commentStyle = "//");
+
 }
 
 #endif
diff --git a/cpp/src/Ice/BasicStream.cpp b/cpp/src/Ice/BasicStream.cpp
index 0d8ea17953d..e08d7ad9b49 100755
--- a/cpp/src/Ice/BasicStream.cpp
+++ b/cpp/src/Ice/BasicStream.cpp
@@ -154,12 +154,12 @@ IceInternal::BasicStream::swap(BasicStream& other)
     std::swap(_closure, other._closure);
 
     //
-    // Swap is never called for BasicStreams that have encapsulations being read/write.
+    // Swap is never called for BasicStreams that have encapsulations being read/write. However,
+    // encapsulations might still be set in case marhsalling or un-marhsalling failed. We just
+    // reset the encapsulations if there are still some set.
     //
-    assert(!_currentReadEncaps);
-    assert(!_currentWriteEncaps);
-    assert(!other._currentReadEncaps);
-    assert(!other._currentWriteEncaps);
+    resetEncaps();
+    other.resetEncaps();
 
     std::swap(_unlimited, other._unlimited);
     std::swap(_startSeq, other._startSeq);
@@ -168,6 +168,28 @@ IceInternal::BasicStream::swap(BasicStream& other)
 }
 
 void
+IceInternal::BasicStream::resetEncaps()
+{
+    while(_currentReadEncaps && _currentReadEncaps != &_preAllocatedReadEncaps)
+    {
+        ReadEncaps* oldEncaps = _currentReadEncaps;
+        _currentReadEncaps = _currentReadEncaps->previous;
+        delete oldEncaps;
+    }
+
+    while(_currentWriteEncaps && _currentWriteEncaps != &_preAllocatedWriteEncaps)
+    {
+        WriteEncaps* oldEncaps = _currentWriteEncaps;
+        _currentWriteEncaps = _currentWriteEncaps->previous;
+        delete oldEncaps;
+    }
+
+    _preAllocatedReadEncaps.reset();
+    _preAllocatedWriteEncaps.reset();
+}
+
+
+void
 IceInternal::BasicStream::format(Ice::FormatType format)
 {
     if(format != DefaultFormat)
@@ -242,14 +264,14 @@ IceInternal::BasicStream::skipEncaps()
     return encoding;
 }
 
-void
-IceInternal::BasicStream::readAndCheckSeqSize(int minSize, Int& sz)
+Int
+IceInternal::BasicStream::readAndCheckSeqSize(int minSize)
 {
-    readSize(sz);
+    Int sz = readSize();
 
     if(sz == 0)
     {
-        return;
+        return sz;
     }
 
     //
@@ -288,6 +310,8 @@ IceInternal::BasicStream::readAndCheckSeqSize(int minSize, Int& sz)
     {
         throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
+    
+    return sz;
 }
 
 void
@@ -319,15 +343,6 @@ IceInternal::BasicStream::readBlob(vector<Byte>& v, Int sz)
     }
 }
 
-void IceInternal::BasicStream::write(Byte v, int end)
-{
-    if(v >= end)
-    {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
-    }
-    write(v);
-}
-
 void
 IceInternal::BasicStream::write(const Byte* begin, const Byte* end)
 {
@@ -342,20 +357,25 @@ IceInternal::BasicStream::write(const Byte* begin, const Byte* end)
 }
 
 void
-IceInternal::BasicStream::read(Byte& b, int end)
+IceInternal::BasicStream::read(std::vector<Ice::Byte>& v)
 {
-    read(b);
-    if(b >= end)
+    std::pair<const Ice::Byte*, const Ice::Byte*> p;
+    read(p);
+    if(p.first != p.second)
+    {
+        v.resize(static_cast<Ice::Int>(p.second - p.first));
+        copy(p.first, p.second, v.begin());
+    }
+    else
     {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
+        v.clear();
     }
 }
 
 void
 IceInternal::BasicStream::read(pair<const Byte*, const Byte*>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(1, sz);
+    Int sz = readAndCheckSeqSize(1);
     if(sz > 0)
     {
         v.first = i;
@@ -423,8 +443,7 @@ IceInternal::BasicStream::write(const bool* begin, const bool* end)
 void
 IceInternal::BasicStream::read(vector<bool>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(1, sz);
+    Int sz = readAndCheckSeqSize(1);
     if(sz > 0)
     {
         v.resize(sz);
@@ -473,8 +492,7 @@ bool*
 IceInternal::BasicStream::read(pair<const bool*, const bool*>& v)
 {
     bool* result = 0;
-    Int sz;
-    readAndCheckSeqSize(1, sz);
+    Int sz = readAndCheckSeqSize(1);
     if(sz > 0)
     {
         result = BasicStreamReadBoolHelper<sizeof(bool)>::read(v, sz, i);
@@ -505,16 +523,6 @@ IceInternal::BasicStream::write(Short v)
 }
 
 void
-IceInternal::BasicStream::write(Short v, int end)
-{
-    if(v < 0 || v >= end)
-    {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
-    }
-    write(v);
-}
-
-void
 IceInternal::BasicStream::write(const Short* begin, const Short* end)
 {
     Int sz = static_cast<Int>(end - begin);
@@ -559,20 +567,9 @@ IceInternal::BasicStream::read(Short& v)
 }
 
 void
-IceInternal::BasicStream::read(Short& v, int end)
-{
-    read(v);
-    if(v < 0 || v >= end)
-    {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
-    }
-}
-
-void
 IceInternal::BasicStream::read(vector<Short>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Short)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Short)));
     if(sz > 0)
     {
         Container::iterator begin = i;
@@ -601,8 +598,7 @@ Short*
 IceInternal::BasicStream::read(pair<const Short*, const Short*>& v)
 {
     Short* result = 0;
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Short)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Short)));
     if(sz > 0)
     {
 #if defined(__i386) || defined(_M_IX86)
@@ -638,26 +634,6 @@ IceInternal::BasicStream::read(pair<const Short*, const Short*>& v)
 }
 
 void
-IceInternal::BasicStream::read(Int& v, int end)
-{
-    read(v);
-    if(v < 0 || v >= end)
-    {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
-    }
-}
-
-void
-IceInternal::BasicStream::write(Int v, int end)
-{
-    if(v < 0 || v >= end)
-    {
-        throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
-    }
-    write(v);
-}
-
-void
 IceInternal::BasicStream::write(const Int* begin, const Int* end)
 {
     Int sz = static_cast<Int>(end - begin);
@@ -686,8 +662,7 @@ IceInternal::BasicStream::write(const Int* begin, const Int* end)
 void
 IceInternal::BasicStream::read(vector<Int>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Int)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Int)));
     if(sz > 0)
     {
         Container::iterator begin = i;
@@ -718,8 +693,7 @@ Int*
 IceInternal::BasicStream::read(pair<const Int*, const Int*>& v)
 {
     Int* result = 0;
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Int)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Int)));
     if(sz > 0)
     {
 #if defined(__i386) || defined(_M_IX86)
@@ -850,8 +824,7 @@ IceInternal::BasicStream::read(Long& v)
 void
 IceInternal::BasicStream::read(vector<Long>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Long)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Long)));
     if(sz > 0)
     {
         Container::iterator begin = i;
@@ -886,8 +859,7 @@ Long*
 IceInternal::BasicStream::read(pair<const Long*, const Long*>& v)
 {
     Long* result = 0;
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Long)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Long)));
     if(sz > 0)
     {
 #if defined(__i386) || defined(_M_IX86)
@@ -1002,8 +974,7 @@ IceInternal::BasicStream::read(Float& v)
 void
 IceInternal::BasicStream::read(vector<Float>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Float)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Float)));
     if(sz > 0)
     {
         Container::iterator begin = i;
@@ -1034,8 +1005,7 @@ Float*
 IceInternal::BasicStream::read(pair<const Float*, const Float*>& v)
 {
     Float* result = 0;
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Float)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Float)));
     if(sz > 0)
     {
 #if defined(__i386) || defined(_M_IX86)
@@ -1203,8 +1173,7 @@ IceInternal::BasicStream::read(Double& v)
 void
 IceInternal::BasicStream::read(vector<Double>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Double)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Double)));
     if(sz > 0)
     {
         Container::iterator begin = i;
@@ -1254,8 +1223,7 @@ Double*
 IceInternal::BasicStream::read(pair<const Double*, const Double*>& v)
 {
     Double* result = 0;
-    Int sz;
-    readAndCheckSeqSize(static_cast<int>(sizeof(Double)), sz);
+    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Double)));
     if(sz > 0)
     {
 #if defined(__i386) || defined(_M_IX86)
@@ -1407,8 +1375,7 @@ IceInternal::BasicStream::readConverted(string& v, int sz)
 void
 IceInternal::BasicStream::read(vector<string>& v, bool convert)
 {
-    Int sz;
-    readAndCheckSeqSize(1, sz);
+    Int sz = readAndCheckSeqSize(1);
     if(sz > 0)
     {
         v.resize(sz);
@@ -1504,8 +1471,7 @@ IceInternal::BasicStream::write(const wstring* begin, const wstring* end)
 void
 IceInternal::BasicStream::read(wstring& v)
 {
-    Int sz;
-    readSize(sz);
+    Int sz = readSize();
     if(sz > 0)
     {
         if(b.end() - i < sz)
@@ -1525,8 +1491,7 @@ IceInternal::BasicStream::read(wstring& v)
 void
 IceInternal::BasicStream::read(vector<wstring>& v)
 {
-    Int sz;
-    readAndCheckSeqSize(1, sz);
+    Int sz = readAndCheckSeqSize(1);
     if(sz > 0)
     {
         v.resize(sz);
@@ -1553,12 +1518,209 @@ IceInternal::BasicStream::read(ObjectPrx& v)
     v = _instance->proxyFactory()->streamToProxy(this);
 }
 
+Int
+IceInternal::BasicStream::readEnum(Int limit)
+{
+    if(getReadEncoding() == Encoding_1_0)
+    {
+        if(limit <= 127)
+        {
+            Byte value;
+            read(value);
+            return value;
+        }
+        else if(limit <= 32767)
+        {
+            Short value;
+            read(value);
+            return value;
+        }
+        else 
+        {
+            Int value;
+            read(value);
+            return value;
+        }
+    }
+    else
+    {
+        return readSize();
+    }
+}
+
+void 
+IceInternal::BasicStream::writeEnum(Int v, Int limit)
+{
+    if(getWriteEncoding() == Encoding_1_0)
+    {
+        if(limit <= 127)
+        {
+            write(static_cast<Byte>(v));
+        }
+        else if(limit <= 32767)
+        {
+            write(static_cast<Short>(v));
+        }
+        else 
+        {
+            write(v);
+        }
+    }
+    else
+    {
+        writeSize(v);
+    }
+}
+
 void
 IceInternal::BasicStream::sliceObjects(bool doSlice)
 {
     _sliceObjects = doSlice;
 }
 
+
+bool
+IceInternal::BasicStream::readOptImpl(Int readTag, OptionalType expectedType)
+{
+    Int tag = 0;
+    OptionalType type;
+    do
+    {
+        if(i >= b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
+        {
+            return false; // End of encapsulation also indicates end of optionals.
+        }
+
+        Byte v;
+        read(v);
+        type = static_cast<OptionalType>(v & 0x07); // First 3 bits.
+        tag = static_cast<Int>(v >> 3);
+        if(tag == 31)
+        {
+            tag = readSize();
+        }
+    }
+    while(type != OptionalTypeEndMarker && tag < readTag && skipOpt(type)); // Skip optional data members
+    
+    if(type == OptionalTypeEndMarker || tag > readTag)
+    {
+        //
+        // Rewind the stream to correctly read the next optional data
+        // member tag & type next time.
+        //
+        i -= tag < 31 ? 1 : (tag < 255 ? 2 : 6);
+        return false; // No optional data members with the requested tag.
+    } 
+    
+    assert(readTag == tag);
+    if(type != expectedType)
+    {
+        ostringstream os;
+        os << "invalid optional data member `" << tag << "': unexpected type";
+        throw MarshalException(__FILE__, __LINE__, os.str());
+    }
+
+    //
+    // We have an optional data member with the requested tag and
+    // type.
+    // 
+    return true;
+}
+
+void
+IceInternal::BasicStream::writeOptImpl(Int tag, OptionalType type)
+{
+    Byte v = static_cast<Byte>(type);
+    if(tag < 31)
+    {
+        v |= tag << 3;
+        write(v);
+    }
+    else
+    {
+        v |= 0x0F8; // tag = 31
+        write(v);
+        writeSize(tag);
+    }
+}
+
+bool
+IceInternal::BasicStream::skipOpt(OptionalType type)
+{
+    int sz;
+    switch(type)
+    {
+    case Ice::OptionalTypeF1:
+    {
+        sz = 1;
+        break;
+    }
+    case Ice::OptionalTypeF2:
+    {
+        sz = 2;
+        break;
+    }
+    case Ice::OptionalTypeF4:
+    {
+        sz = 4;
+        break;
+    }
+    case Ice::OptionalTypeF8:
+    {
+        sz = 8;
+        break;
+    }
+    case Ice::OptionalTypeSize:
+    {
+        skipSize();
+        return true;
+    }
+    case Ice::OptionalTypeVSize:
+    {
+        sz = readSize();
+        break;
+    }
+    case Ice::OptionalTypeFSize:
+    {
+        read(sz);
+        break;
+    }
+    default:
+    {
+        return false;
+    }
+    }
+    skip(sz);
+    return true;
+}
+
+bool
+BasicStream::skipOpts()
+{
+    //
+    // Skip remaining un-read optional members.
+    // 
+    OptionalType type;
+    do
+    {
+        if(i >= b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
+        {
+            return false; // End of encapsulation also indicates end of optionals.
+        }
+
+        Byte v;
+        read(v);
+        type = static_cast<OptionalType>(v & 0x07); // Read first 3 bits.
+        if(static_cast<Int>(v >> 3) == 31)
+        {
+            skipSize();
+        }
+    }
+    while(skipOpt(type));
+    assert(type == OptionalTypeEndMarker);
+    return true;
+}
+
 void
 IceInternal::BasicStream::throwUnmarshalOutOfBoundsException(const char* file, int line)
 {
@@ -1577,6 +1739,7 @@ IceInternal::BasicStream::initReadEncaps()
     if(!_currentReadEncaps) // Lazy initialization.
     {
         _currentReadEncaps = &_preAllocatedReadEncaps;
+        _currentReadEncaps->sz = b.size();
     }
 
     if(!_currentReadEncaps->decoder) // Lazy initialization.
@@ -1812,7 +1975,7 @@ IceInternal::BasicStream::EncapsEncoder::endSlice()
     //
     if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
-        _stream->write(static_cast<Byte>(MemberTypeEndMarker));
+        _stream->write(static_cast<Byte>(OptionalTypeEndMarker));
     }
 
     //
@@ -1861,30 +2024,12 @@ IceInternal::BasicStream::EncapsEncoder::endSlice()
 }
 
 void
-IceInternal::BasicStream::EncapsEncoder::writeOpt(int tag, MemberType type)
-{
-    assert(_sliceType != NoSlice);
-    _sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
-    Byte v = static_cast<Byte>(type);
-    if(tag < 31)
-    {
-        v |= tag << 3;
-    }
-    else
-    {
-        v |= 0x0F8; // tag = 31
-        _stream->writeSize(tag);
-    }
-}
-
-void
 IceInternal::BasicStream::EncapsEncoder::writePendingObjects()
 {
     //
-    // With the 1.0 encoding, only write pending objects if nil or
-    // non-nil references were written (_usesClasses =
-    // true). Otherwise, write pending objects only if some non-nil
-    // references were written.
+    // With the 1.0 encoding, write pending objects if nil or non-nil
+    // references were written (_usesClasses = true). Otherwise, write
+    // pending objects only if some non-nil references were written.
     //
     if(_encaps->encoding == Encoding_1_0)
     {
@@ -1898,6 +2043,14 @@ IceInternal::BasicStream::EncapsEncoder::writePendingObjects()
     {
         return;
     }
+    else 
+    {
+        //
+        // Write end marker for encapsulation optionals before encoding 
+        // the pending objects.
+        //
+        _stream->write(static_cast<Byte>(OptionalTypeEndMarker));
+    }
 
     while(!_toBeMarshaledMap.empty())
     {
@@ -1973,6 +2126,11 @@ IceInternal::BasicStream::EncapsEncoder::writeSlicedData(const SlicedDataPtr& sl
         //
         _stream->writeBlob((*p)->bytes);
         
+        if((*p)->hasOptionalMembers)
+        {
+            _sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+        }
+
         //
         // Assemble and write the indirection table. The table must have the same order
         // as the list of objects.
@@ -2041,7 +2199,7 @@ IceInternal::BasicStream::EncapsDecoder::read(PatchFunc patchFunc, void* patchAd
         //
         // Later versions use a size.
         //
-        _stream->readSize(index);
+        index = _stream->readSize();
         if(index < 0)
         {
             throw MarshalException(__FILE__, __LINE__, "invalid object id");
@@ -2141,8 +2299,8 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
         }
 
         //
-        // Performance sensitive, so we use lazy initialization
-        // for tracing.
+        // Performance sensitive, so we use lazy initialization for
+        // tracing.
         //
         if(_traceSlicing == -1)
         {
@@ -2156,8 +2314,7 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
 
         if(_sliceFlags & FLAG_IS_LAST_SLICE)
         {
-            // TODO: Consider adding a new exception, such as NoExceptionFactory?
-            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__, "unknown exception type `" + mostDerivedId + "'");
+            throw NoExceptionFactoryException(__FILE__, __LINE__, "", "unknown exception type `" + mostDerivedId + "'");
         }
 
         skipSlice(); // Slice off what we don't understand.
@@ -2203,8 +2360,7 @@ IceInternal::BasicStream::EncapsDecoder::endObject(bool preserve)
         //
         // For compatibility with the old AFM.
         //
-        Int sz;
-        _stream->readSize(sz);
+        Int sz = _stream->readSize();
         if(sz != 0)
         {
             throw MarshalException(__FILE__, __LINE__, "invalid Object slice");
@@ -2287,8 +2443,7 @@ IceInternal::BasicStream::EncapsDecoder::startSlice()
     {
         if(_sliceFlags & FLAG_HAS_TYPE_ID_INDEX)
         {
-            Int index;
-            _stream->readSize(index);
+            Int index = _stream->readSize();
             TypeIdReadMap::const_iterator k = _typeIdMap.find(index);
             if(k == _typeIdMap.end())
             {
@@ -2341,15 +2496,7 @@ IceInternal::BasicStream::EncapsDecoder::endSlice()
 {
     if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
-        //
-        // Read remaining un-read optional members.
-        // 
-        Byte v;
-        do
-        {
-            _stream->read(v);
-        }
-        while(skipOpt(static_cast<MemberType>(v & 0x07)));
+        _stream->skipOpts();
     }
 
     //
@@ -2365,13 +2512,15 @@ IceInternal::BasicStream::EncapsDecoder::endSlice()
         _stream->readSizeSeq(indirectionTable);
 
         //
-        // Sanity checks.
+        // Sanity checks. If there are optional members, it's possible
+        // that not all object references were read if they are from
+        // unknown optional data members.
         //
         if(indirectionTable.empty() && !_indirectPatchList.empty())
         {
             throw MarshalException(__FILE__, __LINE__, "empty indirection table");
         }
-        else if(!indirectionTable.empty() && _indirectPatchList.empty())
+        else if(!indirectionTable.empty() && _indirectPatchList.empty() && !(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
         {
             throw MarshalException(__FILE__, __LINE__, "no references to indirection table");
         }
@@ -2399,73 +2548,13 @@ IceInternal::BasicStream::EncapsDecoder::endSlice()
     }
 }            
 
-bool
-IceInternal::BasicStream::EncapsDecoder::readOpt(int readTag, MemberType expectedType)
-{
-    assert(_sliceType != NoSlice);
-    if(!(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
-    {
-        return false; // No optional data members
-    }
-
-    int tag;
-    MemberType type;
-    do
-    {
-        Byte v;
-        _stream->read(v);
-        
-        type = static_cast<MemberType>(v & 0x07); // Read first 3 bits.
-        tag = static_cast<int>(v >> 3);
-        if(tag == 31)
-        {
-            _stream->readSize(tag);
-        }
-    } 
-    while(tag < readTag && skipOpt(type)); // Skip optional data members with lower tag values.
-    
-    if(type == MemberTypeEndMarker)
-    {
-        //
-        // Clear the optional members flag since we've reach the end. We clear
-        // the flag to prevent endSlice to skip un-read optional members and
-        // to prevent other optional members from being read.
-        //
-        _sliceFlags &= ~FLAG_HAS_OPTIONAL_MEMBERS; 
-        return false;
-    } 
-    else if(tag > readTag)
-    {
-        //
-        // Rewind the stream so that we correctly read the next
-        // optional data member tag & type.
-        //
-        _stream->i -= tag < 31 ? 1 : (tag < 255 ? 2 : 6);
-        return false; // No optional data members with the requested tag.
-    }
-    
-    assert(readTag == tag);
-    if(type != expectedType)
-    {
-        ostringstream os;
-        os << "invalid optional data member `" << tag << "' in `" << _typeId << "': unexpected type";
-        throw MarshalException(__FILE__, __LINE__, os.str());
-    }
-
-    //
-    // We have an optional data member with the requested tag and
-    // type.
-    // 
-    return true;
-}
-
 void
 IceInternal::BasicStream::EncapsDecoder::readPendingObjects()
 {
     //
-    // With the 1.0 encoding, only read pending objects if nil or
-    // non-nil references were read (_usesClasses == true). Otherwise,
-    // read pending objects only if some non-nil references were read.
+    // With the 1.0 encoding, read pending objects if nil or non-nil
+    // references were read (_usesClasses == true). Otherwise, read
+    // pending objects only if some non-nil references were read.
     //
     if(_encaps->encoding == Encoding_1_0)
     {        
@@ -2479,12 +2568,20 @@ IceInternal::BasicStream::EncapsDecoder::readPendingObjects()
     {
         return;
     }
+    else
+    {
+        //
+        // Read unread encapsulation optionals before reading the
+        // pending objects.
+        //
+        _stream->skipOpts();
+    }
 
     Int num;
     ObjectList objectList;
     do
     {
-        _stream->readSize(num);
+        num = _stream->readSize();
         for(Int k = num; k > 0; --k)
         {
             objectList.push_back(readInstance());
@@ -2536,7 +2633,7 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
     }
     else
     {
-        _stream->readSize(index);
+        index = _stream->readSize();
     }
 
     ObjectPtr v;
@@ -2727,11 +2824,7 @@ IceInternal::BasicStream::EncapsDecoder::skipSlice()
     if(_sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
         assert(_sliceSize >= 4);
-        _stream->i += _sliceSize - sizeof(Int);
-        if(_stream->i > _stream->b.end())
-        {
-            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
-        }
+        _stream->skip(_sliceSize - sizeof(Int));
     }
     else
     {
@@ -2745,7 +2838,17 @@ IceInternal::BasicStream::EncapsDecoder::skipSlice()
         //
         SliceInfoPtr info = new SliceInfo;
         info->typeId = _typeId;
-        vector<Byte>(start, _stream->i).swap(info->bytes);
+        info->hasOptionalMembers = _sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS;
+        if(info->hasOptionalMembers)
+        {
+            // Don't include the optional member end marker. It will be re-written by
+            // endSlice when the sliced data is re-written.
+            vector<Byte>(start, _stream->i - 1).swap(info->bytes);
+        }
+        else
+        {
+            vector<Byte>(start, _stream->i).swap(info->bytes);
+        }
         _slices.push_back(info);
 
         _indirectionTables.push_back(IndexList());
@@ -2796,7 +2899,7 @@ IceInternal::BasicStream::EncapsDecoder::readSlicedData()
             {
                 throw MarshalException(__FILE__, __LINE__, "invalid id in object indirection table");
             }
-            addPatchEntry(id, __patch__ObjectPtr, &_slices[n]->objects[j++]);
+            addPatchEntry(id, &patchHandle<Ice::Object>, &_slices[n]->objects[j++]);
         }
     }
 
diff --git a/cpp/src/Ice/Exception.cpp b/cpp/src/Ice/Exception.cpp
index a5b2aafa246..002851f917d 100644
--- a/cpp/src/Ice/Exception.cpp
+++ b/cpp/src/Ice/Exception.cpp
@@ -26,11 +26,11 @@ namespace Ex
 {
 
 void
-throwUOE(const string& expectedType, const string& actualType)
+throwUOE(const string& expectedType, const string& type)
 {
     throw Ice::UnexpectedObjectException(__FILE__, __LINE__,
-                                         "expected element of type `" + expectedType + "' but received '" + actualType,
-                                         actualType, expectedType);
+                                         "expected element of type `" + expectedType + "' but received '" +
+                                         type, type, expectedType);
 }
 
 void
@@ -591,6 +591,17 @@ Ice::NoObjectFactoryException::ice_print(ostream& out) const
 }       
 
 void
+Ice::NoExceptionFactoryException::ice_print(ostream& out) const
+{
+    Exception::ice_print(out);
+    out << ":\nprotocol error: no suitable exception factory found for `" << type << "'";
+    if(!reason.empty())
+    {
+        out << ":\n" << reason;
+    }
+}       
+
+void
 Ice::UnexpectedObjectException::ice_print(ostream& out) const
 {
     Exception::ice_print(out);
diff --git a/cpp/src/Ice/ImplicitContextI.cpp b/cpp/src/Ice/ImplicitContextI.cpp
index a14c7cc01f3..ce5b2cb7d95 100644
--- a/cpp/src/Ice/ImplicitContextI.cpp
+++ b/cpp/src/Ice/ImplicitContextI.cpp
@@ -215,19 +215,19 @@ SharedImplicitContext::write(const Context& proxyCtx, ::IceInternal::BasicStream
     IceUtil::Mutex::Lock lock(_mutex);
     if(proxyCtx.size() == 0)
     {
-        __writeContext(s, _context);
+        s->write(_context);
     }
     else if(_context.size() == 0)
     {
         lock.release();
-        __writeContext(s, proxyCtx);
+        s->write(proxyCtx);
     }
     else
     {
         Context combined = proxyCtx;
         combined.insert(_context.begin(), _context.end());
         lock.release();
-        __writeContext(s, combined);
+        s->write(combined);
     }
 }
 
@@ -596,17 +596,17 @@ PerThreadImplicitContext::write(const Context& proxyCtx, ::IceInternal::BasicStr
 
     if(threadCtx == 0 || threadCtx->size() == 0)
     {
-        __writeContext(s, proxyCtx);
+        s->write(proxyCtx);
     }
     else if(proxyCtx.size() == 0)
     {
-        __writeContext(s, *threadCtx);
+        s->write(*threadCtx);
     }
     else
     {
         Context combined = proxyCtx;
         combined.insert(threadCtx->begin(), threadCtx->end());
-        __writeContext(s, combined);
+        s->write(combined);
     }
 }
 
diff --git a/cpp/src/Ice/Incoming.cpp b/cpp/src/Ice/Incoming.cpp
index 4d95113c5f7..15e49a61608 100644
--- a/cpp/src/Ice/Incoming.cpp
+++ b/cpp/src/Ice/Incoming.cpp
@@ -528,8 +528,7 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStre
     _is->read(b);
     _current.mode = static_cast<OperationMode>(b);
 
-    Int sz;
-    _is->readSize(sz);
+    Int sz = _is->readSize();
     while(sz--)
     {
         pair<const string, string> pr;
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index 8cce4a577a0..875c58ed78d 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -20,7 +20,13 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* Ice::upCast(Object* p) { return p; }
+Object* Ice::upCast(Object* p) { return p; }
+
+void 
+Ice::__patch(ObjectPtr& obj, ObjectPtr& v)
+{
+    obj = v;
+}
 
 bool
 Ice::Object::operator==(const Object& r) const
@@ -242,13 +248,6 @@ Ice::Object::__collocDispatch(IceInternal::Direct& request)
     return request.run(this);
 }
 
-void
-Ice::__patch__ObjectPtr(void* __addr, ObjectPtr& v)
-{
-    ObjectPtr* p = static_cast<ObjectPtr*>(__addr);
-    *p = v;
-}
-
 namespace
 {
 
diff --git a/cpp/src/Ice/Outgoing.cpp b/cpp/src/Ice/Outgoing.cpp
index 1056b6628c5..e922fb30486 100644
--- a/cpp/src/Ice/Outgoing.cpp
+++ b/cpp/src/Ice/Outgoing.cpp
@@ -133,7 +133,7 @@ IceInternal::Outgoing::Outgoing(RequestHandler* handler, const string& operation
             //
             // Explicit context
             //
-            __writeContext(&_os, *context);
+            _os.write(*context);
         }
         else
         {
@@ -144,7 +144,7 @@ IceInternal::Outgoing::Outgoing(RequestHandler* handler, const string& operation
             const Context& prxContext = _handler->getReference()->getContext()->getValue();
             if(implicitContext == 0)
             {
-                __writeContext(&_os, prxContext);
+                _os.write(prxContext);
             }
             else
             {
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index f4aa8b63f20..c68c271cefc 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -460,7 +460,7 @@ IceInternal::OutgoingAsync::__prepare(const std::string& operation, OperationMod
         //
         // Explicit context
         //
-        __writeContext(&_os, *context);
+        _os.write(*context);
     }
     else
     {
@@ -471,7 +471,7 @@ IceInternal::OutgoingAsync::__prepare(const std::string& operation, OperationMod
         const Context& prxContext = ref->getContext()->getValue();
         if(implicitContext == 0)
         {
-            __writeContext(&_os, prxContext);
+            _os.write(prxContext);
         }
         else
         {
diff --git a/cpp/src/Ice/ReferenceFactory.cpp b/cpp/src/Ice/ReferenceFactory.cpp
index 016078785ca..4c0c716811b 100644
--- a/cpp/src/Ice/ReferenceFactory.cpp
+++ b/cpp/src/Ice/ReferenceFactory.cpp
@@ -583,8 +583,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s)
     vector<EndpointIPtr> endpoints;
     string adapterId;
 
-    Ice::Int sz;
-    s->readSize(sz);
+    Ice::Int sz = s->readSize();
     
     if(sz > 0)
     {
diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp
index b25856f58ad..1db13f0f33c 100644
--- a/cpp/src/Ice/StreamI.cpp
+++ b/cpp/src/Ice/StreamI.cpp
@@ -37,7 +37,7 @@ class UserExceptionFactoryI : public IceInternal::UserExceptionFactory
 {
 public:
 
-    UserExceptionFactoryI(const Ice::UserExceptionReaderFactoryPtr& factory) :
+    UserExceptionFactoryI(const UserExceptionReaderFactoryPtr& factory) :
         _factory(factory)
     {
     }
@@ -49,7 +49,7 @@ public:
 
 private:
 
-    const Ice::UserExceptionReaderFactoryPtr _factory;
+    const UserExceptionReaderFactoryPtr _factory;
 };
 
 }
@@ -57,23 +57,23 @@ private:
 //
 // UserExceptionReader
 //
-Ice::UserExceptionReader::UserExceptionReader(const Ice::CommunicatorPtr& communicator) :
+UserExceptionReader::UserExceptionReader(const CommunicatorPtr& communicator) :
     _communicator(communicator)
 {
 }
 
-Ice::UserExceptionReader::~UserExceptionReader() throw()
+UserExceptionReader::~UserExceptionReader() throw()
 {
 }
 
 void
-Ice::UserExceptionReader::__write(BasicStream*) const
+UserExceptionReader::__write(BasicStream*) const
 {
     assert(false);
 }
 
 void
-Ice::UserExceptionReader::__read(BasicStream* is)
+UserExceptionReader::__read(BasicStream* is)
 {
     InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure());
     assert(stream);
@@ -81,13 +81,13 @@ Ice::UserExceptionReader::__read(BasicStream* is)
 }
 
 bool
-Ice::UserExceptionReader::__usesClasses() const
+UserExceptionReader::__usesClasses() const
 {
     return usesClasses();
 }
 
 void
-Ice::UserExceptionReader::__usesClasses(bool b)
+UserExceptionReader::__usesClasses(bool b)
 {
     usesClasses(b);
 }
@@ -95,7 +95,7 @@ Ice::UserExceptionReader::__usesClasses(bool b)
 //
 // InputStreamI
 //
-Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const vector<Byte>& data) :
+InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const vector<Byte>& data) :
     _communicator(communicator),
     _closure(0)
 {
@@ -106,7 +106,7 @@ Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const
     _is->i = _is->b.begin();
 }
 
-Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) :
+InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) :
     _communicator(communicator),
     _closure(0)
 {
@@ -117,230 +117,39 @@ Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const
     _is->i = _is->b.begin();
 }
 
-Ice::InputStreamI::~InputStreamI()
+InputStreamI::~InputStreamI()
 {
     delete _is;
 }
 
 CommunicatorPtr
-Ice::InputStreamI::communicator() const
+InputStreamI::communicator() const
 {
     return _communicator;
 }
 
 void
-Ice::InputStreamI::sliceObjects(bool b)
+InputStreamI::sliceObjects(bool b)
 {
     _is->sliceObjects(b);
 }
 
-bool
-Ice::InputStreamI::readBool()
-{
-    bool v;
-    _is->read(v);
-    return v;
-}
-
-vector<bool>
-Ice::InputStreamI::readBoolSeq()
-{
-    vector<bool> v;
-    _is->read(v);
-    return v;
-}
-
-bool*
-Ice::InputStreamI::readBoolSeq(pair<const bool*, const bool*>& p)
-{
-    return _is->read(p);
-}
-
-Byte
-Ice::InputStreamI::readByte()
-{
-    Byte v;
-    _is->read(v);
-    return v;
-}
-
-vector<Byte>
-Ice::InputStreamI::readByteSeq()
-{
-    pair<const Byte*, const Byte*> p;
-    _is->read(p);
-    vector<Byte> v(p.first, p.second);
-    return v;
-}
-
-void
-Ice::InputStreamI::readByteSeq(pair<const Byte*, const Byte*>& p)
-{
-    _is->read(p);
-}
-
-Short
-Ice::InputStreamI::readShort()
-{
-    Short v;
-    _is->read(v);
-    return v;
-}
-
-vector<Short>
-Ice::InputStreamI::readShortSeq()
-{
-    vector<Short> v;
-    _is->read(v);
-    return v;
-}
-
-Short*
-Ice::InputStreamI::readShortSeq(pair<const Short*, const Short*>& p)
-{
-    return _is->read(p);
-}
-
-Int
-Ice::InputStreamI::readInt()
-{
-    Int v;
-    _is->read(v);
-    return v;
-}
-
-vector<Int>
-Ice::InputStreamI::readIntSeq()
-{
-    vector<Int> v;
-    _is->read(v);
-    return v;
-}
-
-Int*
-Ice::InputStreamI::readIntSeq(pair<const Int*, const Int*>& p)
-{
-    return _is->read(p);
-}
-
-Long
-Ice::InputStreamI::readLong()
-{
-    Long v;
-    _is->read(v);
-    return v;
-}
-
-vector<Long>
-Ice::InputStreamI::readLongSeq()
-{
-    vector<Long> v;
-    _is->read(v);
-    return v;
-}
-
-Long*
-Ice::InputStreamI::readLongSeq(pair<const Long*, const Long*>& p)
-{
-    return _is->read(p);
-}
-
-Float
-Ice::InputStreamI::readFloat()
-{
-    Float v;
-    _is->read(v);
-    return v;
-}
-
-vector<Float>
-Ice::InputStreamI::readFloatSeq()
-{
-    vector<Float> v;
-    _is->read(v);
-    return v;
-}
-
-Float*
-Ice::InputStreamI::readFloatSeq(pair<const Float*, const Float*>& p)
-{
-    return _is->read(p);
-}
-
-Double
-Ice::InputStreamI::readDouble()
-{
-    Double v;
-    _is->read(v);
-    return v;
-}
-
-vector<Double>
-Ice::InputStreamI::readDoubleSeq()
-{
-    vector<Double> v;
-    _is->read(v);
-    return v;
-}
-
-Double*
-Ice::InputStreamI::readDoubleSeq(pair<const Double*, const Double*>& p)
-{
-    return _is->read(p);
-}
-
-string
-Ice::InputStreamI::readString(bool convert)
-{
-    string v;
-    _is->read(v, convert);
-    return v;
-}
-
-vector<string>
-Ice::InputStreamI::readStringSeq(bool convert)
-{
-    vector<string> v;
-    _is->read(v, convert);
-    return v;
-}
-
-wstring
-Ice::InputStreamI::readWstring()
-{
-    wstring v;
-    _is->read(v);
-    return v;
-}
-
-vector<wstring>
-Ice::InputStreamI::readWstringSeq()
-{
-    vector<wstring> v;
-    _is->read(v);
-    return v;
-}
-
 Int
-Ice::InputStreamI::readSize()
+InputStreamI::readSize()
 {
-    Int sz;
-    _is->readSize(sz);
-    return sz;
+    return _is->readSize();
 }
 
 Int
-Ice::InputStreamI::readAndCheckSeqSize(int minSize)
+InputStreamI::readAndCheckSeqSize(int minSize)
 {
-    Int sz;
-    _is->readAndCheckSeqSize(minSize, sz);
-    return sz;
+    return _is->readAndCheckSeqSize(minSize);
 }
 
 ObjectPrx
-Ice::InputStreamI::readProxy()
+InputStreamI::readProxy()
 {
-    Ice::ObjectPrx v;
+    ObjectPrx v;
     _is->read(v);
     return v;
 }
@@ -359,208 +168,232 @@ patchObject(void* addr, ObjectPtr& v)
 }
 
 void
-Ice::InputStreamI::readObject(const ReadObjectCallbackPtr& cb)
+InputStreamI::readObject(const ReadObjectCallbackPtr& cb)
 {
     _callbacks.push_back(cb); // Keep reference to callback.
     _is->read(patchObject, cb.get());
 }
 
 void
-Ice::InputStreamI::read(bool& v)
+InputStreamI::read(bool& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(::Ice::Byte& v)
+InputStreamI::read(Byte& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(::Ice::Short& v)
+InputStreamI::read(Short& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(Ice::Int& v)
+InputStreamI::read(Int& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(Ice::Long& v)
+InputStreamI::read(Long& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(Ice::Float& v)
+InputStreamI::read(Float& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(Ice::Double& v)
+InputStreamI::read(Double& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(string& v, bool convert)
+InputStreamI::read(string& v, bool convert)
 {
     _is->read(v, convert);
 }
 
 void
-Ice::InputStreamI::read(vector<string>& v, bool convert)
+InputStreamI::read(vector<string>& v, bool convert)
 {
     _is->read(v, convert);
 }
 
 void
-Ice::InputStreamI::read(wstring& v)
+InputStreamI::read(wstring& v)
 {
     _is->read(v);
 }
 
 void
-Ice::InputStreamI::read(pair<const bool*, const bool*>& p, ::IceUtil::ScopedArray<bool>& result)
+InputStreamI::read(pair<const bool*, const bool*>& p, ::IceUtil::ScopedArray<bool>& result)
 {
     result.reset(_is->read(p));
 }
 
 void
-Ice::InputStreamI::read(pair<const Ice::Byte*, const Ice::Byte*>& p)
+InputStreamI::read(pair<const Byte*, const Byte*>& p)
 {
     _is->read(p);
 }
 void
-Ice::InputStreamI::read(pair<const Ice::Short*, const Ice::Short*>& p, ::IceUtil::ScopedArray<Ice::Short>& result)
+InputStreamI::read(pair<const Short*, const Short*>& p, ::IceUtil::ScopedArray<Short>& result)
 {
     result.reset(_is->read(p));
 }
 
 void
-Ice::InputStreamI::read(pair<const Ice::Int*, const Ice::Int*>& p, ::IceUtil::ScopedArray<Ice::Int>& result)
+InputStreamI::read(pair<const Int*, const Int*>& p, ::IceUtil::ScopedArray<Int>& result)
 {
     result.reset(_is->read(p));
 }
 
 void
-Ice::InputStreamI::read(pair<const Ice::Long*, const Ice::Long*>& p, ::IceUtil::ScopedArray<Ice::Long>& result)
+InputStreamI::read(pair<const Long*, const Long*>& p, ::IceUtil::ScopedArray<Long>& result)
 {
     result.reset(_is->read(p));
 }
 
 void
-Ice::InputStreamI::read(pair<const Ice::Float*, const Ice::Float*>& p, ::IceUtil::ScopedArray<Ice::Float>& result)
+InputStreamI::read(pair<const Float*, const Float*>& p, ::IceUtil::ScopedArray<Float>& result)
 {
     result.reset(_is->read(p));
 }
 
 void
-Ice::InputStreamI::read(pair<const Ice::Double*, const Ice::Double*>& p, 
-                        ::IceUtil::ScopedArray<Ice::Double>& result)
+InputStreamI::read(pair<const Double*, const Double*>& p, 
+                        ::IceUtil::ScopedArray<Double>& result)
 {
     result.reset(_is->read(p));
 }
 
+bool
+InputStreamI::readOptional(Int tag, OptionalType type)
+{
+    return _is->readOpt(tag, type);
+}
+
 void
-Ice::InputStreamI::throwException()
+InputStreamI::throwException()
 {
     _is->throwException();
 }
 
 void
-Ice::InputStreamI::throwException(const UserExceptionReaderFactoryPtr& factory)
+InputStreamI::throwException(const UserExceptionReaderFactoryPtr& factory)
 {
     UserExceptionFactoryPtr del = new UserExceptionFactoryI(factory);
     _is->throwException(del);
 }
 
 void
-Ice::InputStreamI::startObject()
+InputStreamI::startObject()
 {
     _is->startReadObject();
 }
 
 SlicedDataPtr
-Ice::InputStreamI::endObject(bool preserve)
+InputStreamI::endObject(bool preserve)
 {
     return _is->endReadObject(preserve);
 }
 
 void
-Ice::InputStreamI::startException()
+InputStreamI::startException()
 {
     _is->startReadException();
 }
 
 SlicedDataPtr
-Ice::InputStreamI::endException(bool preserve)
+InputStreamI::endException(bool preserve)
 {
     return _is->endReadException(preserve);
 }
 
 string
-Ice::InputStreamI::startSlice()
+InputStreamI::startSlice()
 {
     return _is->startReadSlice();
 }
 
 void
-Ice::InputStreamI::endSlice()
+InputStreamI::endSlice()
 {
     _is->endReadSlice();
 }
 
-Ice::EncodingVersion
-Ice::InputStreamI::startEncapsulation()
+void
+InputStreamI::skipSlice()
+{
+    _is->skipSlice();
+}
+
+EncodingVersion
+InputStreamI::startEncapsulation()
 {
     return _is->startReadEncaps();
 }
 
 void
-Ice::InputStreamI::endEncapsulation()
+InputStreamI::endEncapsulation()
 {
     _is->endReadEncapsChecked();
 }
 
-Ice::EncodingVersion
-Ice::InputStreamI::skipEncapsulation()
+EncodingVersion
+InputStreamI::skipEncapsulation()
 {
     return _is->skipEncaps();
 }
 
-void
-Ice::InputStreamI::skipSlice()
+EncodingVersion
+InputStreamI::getEncoding()
 {
-    _is->skipSlice();
+    return _is->getReadEncoding();
 }
 
 void
-Ice::InputStreamI::readPendingObjects()
+InputStreamI::readPendingObjects()
 {
     _is->readPendingObjects();
 }
 
 void
-Ice::InputStreamI::rewind()
+InputStreamI::rewind()
 {
     _is->clear();
     _is->i = _is->b.begin();
 }
 
 void
-Ice::InputStreamI::closure(void* p)
+InputStreamI::skip(Int sz)
+{
+    _is->skip(sz);
+}
+
+void
+InputStreamI::skipSize()
+{
+    _is->skipSize();
+}
+
+void
+InputStreamI::closure(void* p)
 {
     _closure = p;
 }
 
 void*
-Ice::InputStreamI::closure() const
+InputStreamI::closure() const
 {
     return _closure;
 }
@@ -568,7 +401,7 @@ Ice::InputStreamI::closure() const
 //
 // OutputStreamI
 //
-Ice::OutputStreamI::OutputStreamI(const Ice::CommunicatorPtr& communicator, BasicStream* os) :
+OutputStreamI::OutputStreamI(const CommunicatorPtr& communicator, BasicStream* os) :
     _communicator(communicator), _os(os), _own(!os)
 {
     if(!_os)
@@ -579,7 +412,7 @@ Ice::OutputStreamI::OutputStreamI(const Ice::CommunicatorPtr& communicator, Basi
     _os->closure(this);
 }
 
-Ice::OutputStreamI::~OutputStreamI()
+OutputStreamI::~OutputStreamI()
 {
     if(_own)
     {
@@ -588,31 +421,31 @@ Ice::OutputStreamI::~OutputStreamI()
 }
 
 CommunicatorPtr
-Ice::OutputStreamI::communicator() const
+OutputStreamI::communicator() const
 {
     return _communicator;
 }
 
 void
-Ice::OutputStreamI::writeObject(const ObjectPtr& v)
+OutputStreamI::writeObject(const ObjectPtr& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::writeException(const UserException& v)
+OutputStreamI::writeException(const UserException& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::writeProxy(const ObjectPrx& v)
+OutputStreamI::writeProxy(const ObjectPrx& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::writeSize(Int sz)
+OutputStreamI::writeSize(Int sz)
 {
     if(sz < 0)
     {
@@ -623,61 +456,61 @@ Ice::OutputStreamI::writeSize(Int sz)
 }
 
 void
-Ice::OutputStreamI::write(bool v)
+OutputStreamI::write(bool v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Byte v)
+OutputStreamI::write(Byte v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Short v)
+OutputStreamI::write(Short v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Int v)
+OutputStreamI::write(Int v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Long v)
+OutputStreamI::write(Long v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Float v)
+OutputStreamI::write(Float v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(Double v)
+OutputStreamI::write(Double v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(const string& v, bool convert)
+OutputStreamI::write(const string& v, bool convert)
 {
     _os->write(v, convert);
 }
 
 void
-Ice::OutputStreamI::write(const char* v, bool convert)
+OutputStreamI::write(const char* v, bool convert)
 {
     _os->write(v, convert);
 }
 
 void
-Ice::OutputStreamI::write(const vector<string>& v, bool convert)
+OutputStreamI::write(const vector<string>& v, bool convert)
 {
     if(v.size() == 0)
     {
@@ -690,121 +523,139 @@ Ice::OutputStreamI::write(const vector<string>& v, bool convert)
 }
 
 void
-Ice::OutputStreamI::write(const wstring& v)
+OutputStreamI::write(const wstring& v)
 {
     _os->write(v);
 }
 
 void
-Ice::OutputStreamI::write(const bool* begin, const bool* end)
+OutputStreamI::write(const bool* begin, const bool* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::write(const Byte* begin, const Byte* end)
+OutputStreamI::write(const Byte* begin, const Byte* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::write(const Int* begin, const Int* end)
+OutputStreamI::write(const Short* begin, const Short* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::write(const Long* begin, const Long* end)
+OutputStreamI::write(const Int* begin, const Int* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::write(const Float* begin, const Float* end)
+OutputStreamI::write(const Long* begin, const Long* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::write(const Double* begin, const Double* end)
+OutputStreamI::write(const Float* begin, const Float* end)
 {
     _os->write(begin, end);
 }
 
 void
-Ice::OutputStreamI::format(FormatType format)
+OutputStreamI::write(const Double* begin, const Double* end)
+{
+    _os->write(begin, end);
+}
+
+void
+OutputStreamI::writeOptional(Int tag, OptionalType type)
+{
+    _os->writeOpt(tag, type);
+}
+
+void
+OutputStreamI::format(FormatType format)
 {
     _os->format(format);
 }
 
 void
-Ice::OutputStreamI::startObject(const SlicedDataPtr& slicedData)
+OutputStreamI::startObject(const SlicedDataPtr& slicedData)
 {
     _os->startWriteObject(slicedData);
 }
 
 void
-Ice::OutputStreamI::endObject()
+OutputStreamI::endObject()
 {
     _os->endWriteObject();
 }
 
 void
-Ice::OutputStreamI::startException(const SlicedDataPtr& slicedData)
+OutputStreamI::startException(const SlicedDataPtr& slicedData)
 {
     _os->startWriteException(slicedData);
 }
 
 void
-Ice::OutputStreamI::endException()
+OutputStreamI::endException()
 {
     _os->endWriteException();
 }
 
 void
-Ice::OutputStreamI::startSlice(const string& typeId, bool lastSlice)
+OutputStreamI::startSlice(const string& typeId, bool lastSlice)
 {
     _os->startWriteSlice(typeId, lastSlice);
 }
 
 void
-Ice::OutputStreamI::endSlice()
+OutputStreamI::endSlice()
 {
     _os->endWriteSlice();
 }
 
 void
-Ice::OutputStreamI::startEncapsulation(const Ice::EncodingVersion& version)
+OutputStreamI::startEncapsulation(const EncodingVersion& version)
 {
     _os->startWriteEncaps(version);
 }
 
 void
-Ice::OutputStreamI::startEncapsulation()
+OutputStreamI::startEncapsulation()
 {
     _os->startWriteEncaps();
 }
 
 void
-Ice::OutputStreamI::endEncapsulation()
+OutputStreamI::endEncapsulation()
 {
     _os->endWriteEncapsChecked();
 }
 
+EncodingVersion
+OutputStreamI::getEncoding()
+{
+    return _os->getWriteEncoding();
+}
+
 void
-Ice::OutputStreamI::writePendingObjects()
+OutputStreamI::writePendingObjects()
 {
     _os->writePendingObjects();
 }
 
 void
-Ice::OutputStreamI::finished(vector<Byte>& bytes)
+OutputStreamI::finished(vector<Byte>& bytes)
 {
     vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes);
 }
 
 void
-Ice::OutputStreamI::reset(bool clearBuffer)
+OutputStreamI::reset(bool clearBuffer)
 {
     _os->clear();
     
@@ -820,229 +671,29 @@ Ice::OutputStreamI::reset(bool clearBuffer)
     _os->i = _os->b.begin();
 }
 
-void
-Ice::OutputStreamI::writeBool(bool v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeBoolSeq(const vector<bool>& v)
-{
-    _os->write(v);
-}
-
-void
-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)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeByteSeq(const Ice::Byte* begin, const Ice::Byte* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeShort(Short v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeShortSeq(const vector<Short>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeShortSeq(const Ice::Short* begin, const Ice::Short* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeInt(Int v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeIntSeq(const vector<Int>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-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::writeLongSeq(const vector<Long>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeLongSeq(const Ice::Long* begin, const Ice::Long* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeFloat(Float v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeFloatSeq(const vector<Float>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeFloatSeq(const Ice::Float* begin, const Ice::Float* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeDouble(Double v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeDoubleSeq(const vector<Double>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeDoubleSeq(const Ice::Double* begin, const Ice::Double* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::write(const Short* begin, const Short* end)
-{
-    _os->write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeString(const string& v, bool convert)
+OutputStream::size_type
+OutputStreamI::pos()
 {
-    _os->write(v, convert);
+    return _os->pos();
 }
 
 void
-Ice::OutputStreamI::writeStringSeq(const vector<string>& v, bool convert)
+OutputStreamI::rewrite(size_type p, Int sz)
 {
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size(), convert);
-    }
-}
-
-void
-Ice::OutputStreamI::writeWstring(const wstring& v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeWstringSeq(const vector<wstring>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
+    _os->rewrite(p, sz);
 }
 
 //
 // ObjectReader
 //
 void
-Ice::ObjectReader::__write(BasicStream*) const
+ObjectReader::__write(BasicStream*) const
 {
     assert(false);
 }
 
 void
-Ice::ObjectReader::__read(BasicStream* is)
+ObjectReader::__read(BasicStream* is)
 {
     InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure());
     assert(stream);
@@ -1050,13 +701,13 @@ Ice::ObjectReader::__read(BasicStream* is)
 }
 
 void
-Ice::ObjectReader::__write(const Ice::OutputStreamPtr&) const
+ObjectReader::__write(const OutputStreamPtr&) const
 {
     assert(false);
 }
 
 void
-Ice::ObjectReader::__read(const Ice::InputStreamPtr&)
+ObjectReader::__read(const InputStreamPtr&)
 {
     assert(false);
 }
@@ -1065,7 +716,7 @@ Ice::ObjectReader::__read(const Ice::InputStreamPtr&)
 // ObjectWriter
 //
 void
-Ice::ObjectWriter::__write(BasicStream* os) const
+ObjectWriter::__write(BasicStream* os) const
 {
     OutputStreamI* stream = reinterpret_cast<OutputStreamI*>(os->closure());
     assert(stream);
@@ -1073,19 +724,19 @@ Ice::ObjectWriter::__write(BasicStream* os) const
 }
 
 void
-Ice::ObjectWriter::__read(BasicStream*)
+ObjectWriter::__read(BasicStream*)
 {
     assert(false);
 }
 
 void
-Ice::ObjectWriter::__write(const Ice::OutputStreamPtr&) const
+ObjectWriter::__write(const OutputStreamPtr&) const
 {
     assert(false);
 }
 
 void
-Ice::ObjectWriter::__read(const Ice::InputStreamPtr&)
+ObjectWriter::__read(const InputStreamPtr&)
 {
     assert(false);
 }
@@ -1093,17 +744,17 @@ Ice::ObjectWriter::__read(const Ice::InputStreamPtr&)
 //
 // UserExceptionWriter
 //
-Ice::UserExceptionWriter::UserExceptionWriter(const Ice::CommunicatorPtr& communicator) :
+UserExceptionWriter::UserExceptionWriter(const CommunicatorPtr& communicator) :
     _communicator(communicator)
 {
 }
 
-Ice::UserExceptionWriter::~UserExceptionWriter() throw()
+UserExceptionWriter::~UserExceptionWriter() throw()
 {
 }
 
 void
-Ice::UserExceptionWriter::__write(BasicStream* os) const
+UserExceptionWriter::__write(BasicStream* os) const
 {
     OutputStreamI* stream = reinterpret_cast<OutputStreamI*>(os->closure());
     if(!stream)
@@ -1117,13 +768,13 @@ Ice::UserExceptionWriter::__write(BasicStream* os) const
 }
 
 void
-Ice::UserExceptionWriter::__read(BasicStream*)
+UserExceptionWriter::__read(BasicStream*)
 {
     assert(false);
 }
 
 bool
-Ice::UserExceptionWriter::__usesClasses() const
+UserExceptionWriter::__usesClasses() const
 {
     return usesClasses();
 }
diff --git a/cpp/src/Ice/StreamI.h b/cpp/src/Ice/StreamI.h
index 947fb7ee681..4041d126efd 100644
--- a/cpp/src/Ice/StreamI.h
+++ b/cpp/src/Ice/StreamI.h
@@ -38,43 +38,6 @@ public:
 
     virtual void sliceObjects(bool);
 
-    //
-    // 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);
 
@@ -98,9 +61,14 @@ public:
     virtual void endEncapsulation();
     virtual Ice::EncodingVersion skipEncapsulation();
 
+    virtual Ice::EncodingVersion getEncoding();
+
     virtual void readPendingObjects();
 
     virtual void rewind();
+
+    virtual void skip(Ice::Int);
+    virtual void skipSize();
     
     virtual void read(bool& v);
     virtual void read(Byte& v);
@@ -120,6 +88,8 @@ public:
     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 bool readOptional(Int, OptionalType);
+
     virtual void closure(void*);
     virtual void* closure() const;
 
@@ -143,43 +113,6 @@ public:
 
     virtual CommunicatorPtr communicator() const;
 
-    //
-    // 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&);
-    
-    //
-    // 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 >&);
-
-    //
-    // 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&);
@@ -206,6 +139,8 @@ public:
     virtual void write(const Float*, const Float*);
     virtual void write(const Double*, const Double*);
 
+    virtual void writeOptional(Int, OptionalType);
+
     virtual void format(FormatType);
 
     virtual void startObject(const SlicedDataPtr&);
@@ -221,12 +156,17 @@ public:
     virtual void startEncapsulation();
     virtual void endEncapsulation();
 
+    virtual Ice::EncodingVersion getEncoding();
+
     virtual void writePendingObjects();
 
     virtual void finished(std::vector< Byte >&);
 
     virtual void reset(bool);
 
+    virtual size_type pos();
+    virtual void rewrite(size_type, Int);
+
 private:
 
     const CommunicatorPtr _communicator;
diff --git a/cpp/src/Ice/TraceUtil.cpp b/cpp/src/Ice/TraceUtil.cpp
index 2f377159042..3dcd019b209 100644
--- a/cpp/src/Ice/TraceUtil.cpp
+++ b/cpp/src/Ice/TraceUtil.cpp
@@ -100,8 +100,7 @@ printRequestHeader(ostream& s, BasicStream& stream)
         }
     }
 
-    Int sz;
-    stream.readSize(sz);
+    Int sz = stream.readSize();
     s << "\ncontext = ";
     while(sz--)
     {
diff --git a/cpp/src/IceUtil/Exception.cpp b/cpp/src/IceUtil/Exception.cpp
index 350df152b29..399cecd678b 100644
--- a/cpp/src/IceUtil/Exception.cpp
+++ b/cpp/src/IceUtil/Exception.cpp
@@ -450,3 +450,37 @@ IceUtil::FileLockException::error() const
 {
     return _error;
 }
+
+IceUtil::OptionalNotSetException::OptionalNotSetException(const char* file, int line) :
+    Exception(file, line)
+{
+    if(IceUtilInternal::nullHandleAbort)
+    {
+        abort();
+    }
+}
+
+IceUtil::OptionalNotSetException::~OptionalNotSetException() throw()
+{
+}
+
+const char* IceUtil::OptionalNotSetException::_name = "IceUtil::OptionalNotSetException";
+
+string
+IceUtil::OptionalNotSetException::ice_name() const
+{
+    return _name;
+}
+
+IceUtil::Exception*
+IceUtil::OptionalNotSetException::ice_clone() const
+{
+    return new OptionalNotSetException(*this);
+}
+
+void
+IceUtil::OptionalNotSetException::ice_throw() const
+{
+    throw *this;
+}
+
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 98d2aa98510..9b9cf36490c 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -20,6 +20,299 @@ using namespace Slice;
 using namespace IceUtil;
 using namespace IceUtilInternal;
 
+namespace
+{
+
+string toTemplateArg(const string& arg)
+{
+    if(arg.empty())
+    {
+        return arg;
+    }
+    string fixed = arg;
+    if(arg[0] == ':')
+    {
+        fixed = " " + fixed;
+    }
+    if(fixed[fixed.length() - 1] == '>')
+    {
+        fixed = fixed + " ";
+    }
+    return fixed;
+}
+
+string
+sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typeCtx)
+{
+    string seqType = findMetaData(metaData, typeCtx);
+    if(!seqType.empty())
+    {
+        if(seqType == "array" || seqType == "range:array")
+        {
+            BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
+            if(typeCtx & TypeContextAMIPrivateEnd)
+            {
+                if(builtin && builtin->kind() == Builtin::KindByte)
+                {
+                    string s = typeToString(seq->type());
+                    return "::std::pair<const " + s + "*, const " + s + "*>";
+                }
+                else if(builtin && 
+                        builtin->kind() != Builtin::KindString && 
+                        builtin->kind() != Builtin::KindObject &&
+                        builtin->kind() != Builtin::KindObjectProxy)
+                {
+                    string s = toTemplateArg(typeToString(builtin));
+                    return "::std::pair< ::IceUtil::ScopedArray<" + s + ">, " +
+                        "::std::pair<const " + s + "*, const " + s + "*> >";
+                }
+                else
+                {
+                    string s = toTemplateArg(typeToString(seq->type(), seq->typeMetaData(), 
+                                                          inWstringModule(seq) ? TypeContextUseWstring : 0));
+                    return "::std::vector<" + s + '>';
+                }
+            }
+            string s = typeToString(seq->type(), seq->typeMetaData(), inWstringModule(seq) ? TypeContextUseWstring : 0);
+            return "::std::pair<const " + s + "*, const " + s + "*>";
+        }
+        else if(seqType.find("range") == 0)
+        {
+            string s;
+            if(seqType.find("range:") == 0)
+            {
+                s = seqType.substr(strlen("range:"));
+            }
+            else
+            {
+                s = fixKwd(seq->scoped());
+            }
+            if(typeCtx & TypeContextAMIPrivateEnd)
+            {
+                return s;
+            }
+            if(s[0] == ':')
+            {
+                s = " " + s;
+            }
+            return "::std::pair<" + s + "::const_iterator, " + s + "::const_iterator>";
+        }
+        else
+        {
+            return seqType;
+        }
+    }
+    else
+    {
+        // Get the metadata associated at the point of definition.
+        bool protobuf;
+        seqType = findMetaData(seq, seq->getMetaData(), protobuf, typeCtx);
+        if(protobuf && !seqType.empty())
+        {
+            return seqType;
+        }
+        return fixKwd(seq->scoped());
+    }
+}
+
+void
+writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const string& fixedName,
+                       const StringList& metaData, int typeCtx)
+{
+    string s = typeToString(type, metaData, typeCtx);
+    if(optional)
+    {
+        s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+    }
+    out << nl << s << ' ' << fixedName << ';';
+
+    if(!(typeCtx & TypeContextInParam))
+    {
+        return; // We're done.
+    }
+
+    //
+    // If using a range or array we need to allocate the range container, or 
+    // array as well now to ensure they are always in the same scope.
+    //
+    SequencePtr seq = SequencePtr::dynamicCast(type);
+    if(seq)
+    {
+        bool protobuf;
+        string seqType = findMetaData(seq, metaData, protobuf, typeCtx);
+        if(!protobuf && seqType.empty())
+        {
+            seqType = findMetaData(seq, seq->getMetaData(), protobuf, typeCtx);
+        }
+        if(protobuf)
+        {
+            return;
+        }
+
+        string s;
+        if(seqType == "array" || seqType == "range:array")
+        {
+            s = typeToString(seq, metaData, TypeContextAMIPrivateEnd);
+        }
+        else if(seqType.find("range") == 0)
+        {
+            StringList md;
+            if(seqType.find("range:") == 0)
+            {
+                md.push_back("cpp:type:" + seqType.substr(strlen("range:")));
+            }
+            s = typeToString(seq, md);
+        }
+        
+        if(!s.empty())
+        {
+            if(optional)
+            {
+                s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+            }
+            out << nl << s << " ___" << fixedName << ";";
+        }
+    }
+}
+
+void
+writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& fixedName, const StringList& metaData)
+{
+    SequencePtr seq = SequencePtr::dynamicCast(type);
+    if(seq)
+    {
+        bool protobuf;
+        string seqType = findMetaData(seq, metaData, protobuf, TypeContextInParam);
+        if(!protobuf && seqType.empty())
+        {
+            seqType = findMetaData(seq, seq->getMetaData(), protobuf, TypeContextInParam);
+        }
+        if(!protobuf)
+        {
+            if(seqType == "array" || seqType == "range:array")
+            {
+                BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
+                if(builtin && 
+                   builtin->kind() != Builtin::KindByte &&
+                   builtin->kind() != Builtin::KindString &&
+                   builtin->kind() != Builtin::KindObject &&
+                   builtin->kind() != Builtin::KindObjectProxy)
+                {
+                    if(optional)
+                    {
+                        out << nl << "if(___" << fixedName << ")";
+                        out << sb;
+                        out << nl << fixedName << " = ___" << fixedName << "->second;";
+                        out << eb;
+                    }
+                    else
+                    {
+                        out << nl << fixedName << " = ___" << fixedName << ".second;";
+                    }
+                }
+                else if(!builtin || 
+                        builtin->kind() == Builtin::KindString || 
+                        builtin->kind() == Builtin::KindObject ||
+                        builtin->kind() == Builtin::KindObjectProxy)
+                {
+                    if(optional)
+                    {
+                        out << nl << "if(___" << fixedName << ")";
+                        out << sb;
+                        out << nl << fixedName << ".__setIsSet();";
+                        out << nl << fixedName << "->first" << " = &(*___" << fixedName << ")[0];";
+                        out << nl << fixedName << "->second" << " = " << fixedName << "->first + " << "___" 
+                            << fixedName << "->size();";
+                        out << eb;
+                    }
+                    else
+                    {
+                        out << nl << fixedName << ".first" << " = &___" << fixedName << "[0];";
+                        out << nl << fixedName << ".second" << " = " << fixedName << ".first + " << "___" 
+                            << fixedName << ".size();";
+                    }
+                }
+            }
+            else if(seqType.find("range") == 0)
+            {
+                if(optional)
+                {
+                    out << nl << "if(___" << fixedName << ")";
+                    out << sb;
+                    out << nl << fixedName << ".__setIsSet();";
+                    out << nl << fixedName << "->first = (*___" << fixedName << ").begin();";
+                    out << nl << fixedName << "->second = (*___" << fixedName << ").end();";
+                    out << eb;
+                }
+                else
+                {
+                    out << nl << fixedName << ".first = ___" << fixedName << ".begin();";
+                    out << nl << fixedName << ".second = ___" << fixedName << ".end();";
+                }
+            }
+        }
+    }
+}
+
+void
+writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const OperationPtr& op, bool marshal, int typeCtx)
+{
+    //
+    // Marshal non optional parameters.
+    //
+    ParamDeclList optionals;
+    for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
+    {
+        if((*p)->optional())
+        {
+            optionals.push_back(*p);
+        }
+        else
+        {
+            writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd((*p)->name()), marshal, (*p)->getMetaData(), 
+                                      typeCtx);
+        }
+    }
+    if(op && op->returnType())
+    {
+        if(!op->returnIsOptional())
+        {
+            writeMarshalUnmarshalCode(out, op->returnType(), false, 0, "__ret", marshal, op->getMetaData(), typeCtx);
+        }
+    }
+
+    //
+    // Sort optional parameters by tag.
+    //
+    class SortFn
+    {
+    public:
+        static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+        {
+            return lhs->tag() < rhs->tag();
+        }
+    };
+    optionals.sort(SortFn::compare);
+
+    //
+    // Marshal optional parameters.
+    //
+    bool checkReturnType = op && op->returnIsOptional();
+    for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+    {
+        if(checkReturnType && op->returnTag() < (*p)->tag())
+        {
+            writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), "__ret", marshal, 
+                                      op->getMetaData(), typeCtx);
+            checkReturnType = false;
+        }
+        writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd((*p)->name()), marshal,
+                                  (*p)->getMetaData(), typeCtx);
+    }
+}
+
+}
+
 Slice::FeatureProfile Slice::featureProfile = Slice::Ice;
 
 char
@@ -107,100 +400,6 @@ Slice::printDllExportStuff(Output& out, const string& dllExport)
     }
 }
 
-namespace
-{
-
-string
-sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typeCtx)
-{
-    string seqType = findMetaData(metaData, typeCtx);
-    if(!seqType.empty())
-    {
-        if(seqType == "array" || seqType == "range:array")
-        {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
-            if(typeCtx & TypeContextAMIPrivateEnd)
-            {
-                if(!builtin || builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    seqType = findMetaData(seq->getMetaData());
-                    if(seqType.empty())
-                    {
-                        return typeToString(seq);
-                    }
-                    else
-                    {
-                        return "::std::vector< " + typeToString(seq->type()) + ">";
-                    }
-                }
-                else if(builtin->kind() == Builtin::KindByte)
-                {
-                    string s = typeToString(seq->type());
-                    return "::std::pair<const " + s + "*, const " + s + "*>";
-                }
-                else if(builtin->kind() != Builtin::KindString &&
-                        builtin->kind() != Builtin::KindObject &&
-                        builtin->kind() != Builtin::KindObjectProxy)
-                {
-                    string s = typeToString(builtin);
-                    if(s[0] == ':')
-                    {
-                        s = " " + s;
-                    }
-                    return "::std::pair< ::IceUtil::ScopedArray<" + s + ">," +
-                        " ::std::pair<const " + s + "*, const " + s + "*> >";
-                }
-                else
-                {
-                    return "::std::vector< " + typeToString(seq->type(), 
-                                                            seq->typeMetaData(), 
-                                                            inWstringModule(seq) ? TypeContextUseWstring : 0) + ">";
-                }
-            }
-            string s = typeToString(seq->type(), seq->typeMetaData(), inWstringModule(seq) ? TypeContextUseWstring : 0);
-            return "::std::pair<const " + s + "*, const " + s + "*>";
-        }
-        else if(seqType.find("range") == 0)
-        {
-            string s;
-            if(seqType.find("range:") == 0)
-            {
-                s = seqType.substr(strlen("range:"));
-            }
-            else
-            {
-                s = fixKwd(seq->scoped());
-            }
-            if(typeCtx & TypeContextAMIPrivateEnd)
-            {
-                return s;
-            }
-            if(s[0] == ':')
-            {
-                s = " " + s;
-            }
-            return "::std::pair<" + s + "::const_iterator, " + s + "::const_iterator>";
-        }
-        else
-        {
-            return seqType;
-        }
-    }
-    else
-    {
-        // Get the metadata associated at the point of definition.
-        bool protobuf;
-        seqType = findMetaData(seq, seq->getMetaData(), protobuf, typeCtx);
-        if(protobuf && !seqType.empty())
-        {
-            return seqType;
-        }
-        return fixKwd(seq->scoped());
-    }
-}
-
-}
-
 string
 Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
 {
@@ -284,18 +483,36 @@ Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx
 }
 
 string
-Slice::returnTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+Slice::typeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
+{
+    if(optional)
+    {
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+    }
+    else
+    {
+        return typeToString(type, metaData, typeCtx);
+    }
+}
+
+string
+Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
     if(!type)
     {
         return "void";
     }
 
+    if(optional)
+    {
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+    }
+
     return typeToString(type, metaData, typeCtx);
 }
 
 string
-Slice::inputTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
     static const char* inputBuiltinTable[] =
     {
@@ -314,6 +531,11 @@ Slice::inputTypeToString(const TypePtr& type, const StringList& metaData, int ty
 
     typeCtx |= TypeContextInParam;
 
+    if(optional)
+    {
+        return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+    }
+
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if(builtin)
     {
@@ -379,7 +601,7 @@ Slice::inputTypeToString(const TypePtr& type, const StringList& metaData, int ty
 }
 
 string
-Slice::outputTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
     static const char* outputBuiltinTable[] =
     {
@@ -395,6 +617,11 @@ Slice::outputTypeToString(const TypePtr& type, const StringList& metaData, int t
         "::Ice::ObjectPrx&",
         "::Ice::LocalObjectPtr&"
     };
+
+    if(optional)
+    {
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+    }
     
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if(builtin)
@@ -595,560 +822,97 @@ Slice::fixKwd(const string& name)
 }
 
 void
-Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, const string& fixedParam, bool marshal,
-                                 const string& str, bool pointer, const StringList& metaData, int typeCtx)
+Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional, int tag, const string& param, 
+                                 bool marshal, const StringList& metaData, int typeCtx, const string& str, bool pointer)
 {
-    string stream;
+    ostringstream os;
     if(str.empty())
     {
-        stream = marshal ? "__os" : "__is";
+        os << (marshal ? "__os" : "__is");
     }
     else
     {
-        stream = str;
+        os << str;
     }
     
     string deref;
     if(pointer)
     {
-        deref = "->";
+        os << "->";
     }
     else
     {
-        deref = '.';
+        os << '.';
     }
-    
-    string func = marshal ? "write(" : "read(";
 
-    BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-    if(builtin)
+    if(marshal)
     {
-        if(builtin->kind() == Builtin::KindObject)
-        {
-            if(marshal)
-            {
-                out << nl << stream << deref << func << fixedParam << ");";
-            }
-            else
-            {
-                out << nl << stream << deref << func << "::Ice::__patch__ObjectPtr, &" << fixedParam << ");";
-            }
-            return;
-        }
-        else
-        {
-            out << nl << stream << deref << func << fixedParam << ");";
-            return;
-        }
+        os << "write(";
     }
-    
-    ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
-    if(cl)
+    else
     {
-        string scope = fixKwd(cl->scope());
-        if(marshal)
-        {
-            out << nl << stream << deref << "write(::Ice::ObjectPtr(" << scope << "upCast(" << fixedParam 
-                << ".get())));";
-        }
-        else
-        {
-            out << nl << stream << deref << "read(" << scope << "__patch__" << cl->name() << "Ptr, &" << fixedParam
-                << ");";
-        }
-
-        return;
+        os << "read(";
     }
 
-    ProxyPtr px = ProxyPtr::dynamicCast(type);
-    if(px)
-    {
-        string scope = fixKwd(px->_class()->scope());
-        if(marshal)
-        {
-            out << nl << stream << deref << "write(::Ice::ObjectPrx(::IceProxy" << scope << "upCast(" << fixedParam 
-                << ".get())));";
-        }
-        else
-        {
-            out << nl << scope << "__read(" << (pointer ? "" : "&") << stream << ", " << fixedParam << ");";
-        }
-        return;
-    }
-    
-    StructPtr st = StructPtr::dynamicCast(type);
-    if(st)
+    if(optional)
     {
-        string deref;
-        if(findMetaData(st->getMetaData()) == "class")
-        {
-            if(!marshal)
-            {
-                out << nl << fixedParam << " = new " << fixKwd(st->scoped()) << ";";
-            }
-            out << nl << fixedParam << "->__" << func << (pointer ? "" : "&") << stream << ");";
-        }
-        else
-        {
-            out << nl << fixedParam << ".__" << func << (pointer ? "" : "&") << stream << ");";
-        }
-        return;
+        os << tag << ", ";
     }
-    
-    SequencePtr seq = SequencePtr::dynamicCast(type);
-    if(seq)
-    {
-        builtin = BuiltinPtr::dynamicCast(seq->type());
-        string funcSeq = (marshal ? "write" : "read") + fixKwd(seq->name()) + "(";
-
-        if(marshal)
-        {
-            string seqType = findMetaData(metaData, typeCtx);
-            string scope = fixKwd(seq->scope());
 
-            if(seqType == "array" || seqType == "range:array")
-            {
-                //
-                // Use array (pair<const TYPE*, const TYPE*>). In parameters only.
-                //
-                if(!builtin || builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    //
-                    // Sequence type in not handled by BasicStream functions. If the sequence is the
-                    // default vector than we can use the sequences generated write function. Otherwise
-                    // we need to generate marshal code to write each element.
-                    //
-                    seqType = findMetaData(seq->getMetaData());
-                    if(seqType.empty())
-                    {
-                        out << nl << scope << "__" << funcSeq << (pointer ? "" : "&") << stream << ", "
-                            << fixedParam << ".first, " << fixedParam << ".second);";
-                    }
-                    else
-                    {
-                        out << nl << "::Ice::Int __sz_" << fixedParam << " = static_cast< ::Ice::Int>(" << fixedParam
-                            << ".second - " << fixedParam << ".first);";
-                        out << nl << stream << deref << "writeSize(__sz_" << fixedParam << ");";
-                        out << nl << "for(int __i_" << fixedParam << " = 0; __i_" << fixedParam << " < __sz_" 
-                            << fixedParam << "; ++__i_" << fixedParam << ")";
-                        out << sb;
-                        writeMarshalUnmarshalCode(out, seq->type(), fixedParam + ".first[__i_" + fixedParam + "]",
-                                                  true);
-                        out << eb;
-                    }
-                }
-                else
-                {
-                    //
-                    // Use BasicStream write functions.
-                    //
-                    out << nl << stream << deref << func << fixedParam << ".first, " << fixedParam << ".second);";
-                }
-            }
-            else if(seqType.find("range") == 0)
-            {
-                //
-                // Use range (pair<TYPE::const_iterator, TYPE::const_iterator). Only for in paramaters.
-                // Need to check if the range defines an iterator type other than the actual sequence
-                // type.
-                //
-                StringList l;
-                if(seqType.find("range:") == 0)
-                {
-                    seqType = seqType.substr(strlen("range:"));
-                    l.push_back("cpp:" + seqType);
-                }
-                else
-                {
-                    seqType = fixKwd(seq->scoped());
-                }
-                out << nl << stream << deref << "writeSize(static_cast< ::Ice::Int>(IceUtilInternal::distance(" 
-                    << fixedParam << ".first, " << fixedParam << ".second)));"; 
-                out << nl << "for(" << seqType << "::const_iterator ___" << fixedParam << " = "
-                    << fixedParam << ".first; ___" << fixedParam << " != " << fixedParam << ".second; ++___"
-                    << fixedParam << ")";
-                out << sb;
-                writeMarshalUnmarshalCode(out, seq->type(), "(*___" + fixedParam + ")", true, "", true, l);
-                out << eb;
-            }
-            else if(!seqType.empty())
-            {
-                out << nl << stream << deref << "writeSize(static_cast< ::Ice::Int>(" << fixedParam << ".size()));";
-                out << nl << seqType << "::const_iterator __p_" << fixedParam << ";";
-                out << nl << "for(__p_" << fixedParam << " = " << fixedParam << ".begin(); __p_" << fixedParam 
-                    << " != " << fixedParam << ".end(); ++__p_" << fixedParam << ")";
-                out << sb;
-                writeMarshalUnmarshalCode(out, seq->type(), "(*__p_" + fixedParam + ")", true);
-                out << eb;
-            }
-            else
-            {
-                //
-                // No modifying metadata specified. Use appropriate write methods for type.
-                //
-                bool protobuf;
-                seqType = findMetaData(seq, seq->getMetaData(), protobuf);
-                if(protobuf || !seqType.empty())
-                {
-                    out << nl << scope << "__" << funcSeq << (pointer ? "" : "&") << stream << ", " << fixedParam 
-                        << ");";
-                }
-                else if(!builtin || 
-                        builtin->kind() == Builtin::KindObject ||
-                        builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    out << nl << "if(" << fixedParam << ".size() == 0)";
-                    out << sb;
-                    out << nl << stream << deref << "writeSize(0);";
-                    out << eb;
-                    out << nl << "else";
-                    out << sb;
-                    out << nl << scope << "__" << funcSeq << (pointer ? "" : "&") << stream << ", &"
-                        << fixedParam << "[0], &" << fixedParam << "[0] + " << fixedParam << ".size());";
-                    out << eb;
-                }
-                else if(builtin->kind() == Builtin::KindBool)
-                {
-                    out << nl << stream << deref << func << fixedParam << ");";
-                }
-                else
-                {
-                    out << nl << "if(" << fixedParam << ".size() == 0)";
-                    out << sb;
-                    out << nl << stream << deref << "writeSize(0);";
-                    out << eb;
-                    out << nl << "else";
-                    out << sb;
-                    out << nl << stream << deref << func << "&" << fixedParam << "[0], &" << fixedParam 
-                        << "[0] + " << fixedParam << ".size());";
-                    out << eb;
-                }
-            }
-        }
-        else
+    string func = os.str();
+    if(!marshal)
+    {
+        SequencePtr seq = SequencePtr::dynamicCast(type);
+        if(seq && !(typeCtx & TypeContextAMIPrivateEnd))
         {
             string seqType = findMetaData(metaData, typeCtx);
-            string scope = fixKwd(seq->scope());
             if(seqType == "array" || seqType == "range:array")
             {
-                //
-                // Use array (pair<const TYPE*, const TYPE*>). In parameters only.
-                //
-                if(!builtin || builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    seqType = findMetaData(seq->getMetaData());
-                    if(seqType.empty())
-                    {
-                        out << nl << typeToString(type) << " ___" << fixedParam << ";";
-                        out << nl << scope << "__" << funcSeq << (pointer ? "" : "&") << stream << ", ___"
-                            << fixedParam << ");";
-                    }
-                    else
-                    {
-                        seqType = "::std::vector< " + typeToString(seq->type()) + ">";
-                        StringList l;
-                        l.push_back("cpp:type:" + seqType);
-                        out << nl << seqType << " ___" << fixedParam << ";";
-                        writeMarshalUnmarshalCode(out, seq, "___" + fixedParam, false, "", true, l);
-                    }
-                }
-                else if(builtin->kind() == Builtin::KindByte)
-                {
-                    out << nl << stream << deref << func << fixedParam << ");";
-                }
-                else if(builtin->kind() != Builtin::KindString && builtin->kind() != Builtin::KindObject &&
-                        builtin->kind() != Builtin::KindObjectProxy)
-                {
-                    string s = typeToString(builtin);
-                    if(s[0] == ':')
-                    {
-                       s = " " + s;
-                    }
-
-                    if(typeCtx & TypeContextAMIPrivateEnd)
-                    {
-                        out << nl << fixedParam << ".first.reset(" << stream << deref << func << fixedParam
-                            << ".second));";
-                    }
-                    else
-                    {
-                        out << nl << "::IceUtil::ScopedArray<" << s << "> ___" << fixedParam << '('
-                            << stream << deref << func << fixedParam << "));";
-                    }
-                }
-                else
+                BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
+                if(builtin && builtin->kind() == Builtin::KindByte)
                 {
-                    out << nl << "::std::vector< " 
-                        << typeToString(seq->type(), seq->typeMetaData(), 
-                                        inWstringModule(seq) ? TypeContextUseWstring : 0) << "> ___" 
-                        << fixedParam << ";";
-                    out << nl << stream << deref << func << "___" << fixedParam << ");";
+                    out << nl << func << param << ");";
+                    return;
                 }
 
-                if(!builtin || builtin->kind() == Builtin::KindString || builtin->kind() == Builtin::KindObject ||
-                        builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    if(typeCtx & TypeContextAMIPrivateEnd)
-                    {
-                        out << nl << fixedParam << ".swap(" << "___" << fixedParam << ");";
-                    }
-                    else
-                    {
-                        out << nl << fixedParam << ".first" << " = &___" << fixedParam << "[0];";
-                        out << nl << fixedParam << ".second" << " = " << fixedParam << ".first + " << "___" 
-                            << fixedParam << ".size();";
-                    }
-                }
+                out << nl << func << "___" << param << ");";
+                writeParamEndCode(out, seq, optional, param, metaData);
+                return;
             }
             else if(seqType.find("range") == 0)
             {
-                //
-                // Use range (pair<TYPE::const_iterator, TYPE::const_iterator>). In paramters only.
-                // Need to check if iterator type other than default is specified.
-                //
-                StringList md;
-                if(seqType.find("range:") == 0)
-                {
-                    md.push_back("cpp:type:" + seqType.substr(strlen("range:")));
-                }
-                if(typeCtx & TypeContextAMIPrivateEnd)
-                {
-                    writeMarshalUnmarshalCode(out, seq, fixedParam, false, "", true, md);
-                }
-                else
-                {
-                    writeMarshalUnmarshalCode(out, seq, "___" + fixedParam, false, "", true, md);
-                    out << nl << fixedParam << ".first = ___" << fixedParam << ".begin();";
-                    out << nl << fixedParam << ".second = ___" << fixedParam << ".end();";
-                }
-            }
-            else if(!seqType.empty())
-            {
-                //
-                // Using alternate sequence type. 
-                //
-                out << nl << "::Ice::Int __sz_" << fixedParam << ";";
-                out << nl << stream << deref << "readAndCheckSeqSize(" << seq->type()->minWireSize() << ", __sz_" 
-                    << fixedParam << ");";
-                out << nl << seqType << "(__sz_" << fixedParam << ").swap(" << fixedParam << ");";
-                out << nl << seqType << "::iterator __p_" << fixedParam << ";";
-                out << nl << "for(__p_" << fixedParam << " = " << fixedParam << ".begin(); __p_" << fixedParam 
-                   << " != " << fixedParam << ".end(); ++__p_" << fixedParam << ")";
-                out << sb;
-                writeMarshalUnmarshalCode(out, seq->type(), "(*__p_" + fixedParam + ")", false);
-                out << eb;
-            }
-            else
-            {
-                //
-                // No modifying metadata supplied. Just use
-                // appropriate read function.
-                //
-                bool protobuf;
-                seqType = findMetaData(seq, seq->getMetaData(), protobuf);
-                if(protobuf || 
-                   !seqType.empty() ||
-                   !builtin || 
-                   builtin->kind() == Builtin::KindObject ||
-                   builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    out << nl << scope << "__" << funcSeq << (pointer ? "" : "&") << stream << ", "
-                        << fixedParam << ");";
-                }
-                else if(builtin->kind() == Builtin::KindByte)
-                {
-                    StringList md;
-                    md.push_back("cpp:array");
-                    string tmpParam = "___";
-
-                    //
-                    // Catch some case in which it is not possible to just prepend
-                    // underscores to param to use as temporary variable.
-                    //
-                    if(fixedParam.find("(*") == 0)
-                    {
-                        tmpParam += fixedParam.substr(2, fixedParam.length() - 3);
-                    }
-                    else if(fixedParam.find("[i]") != string::npos)
-                    {
-                        tmpParam += fixedParam.substr(0, fixedParam.length() - 3);
-                    }
-                    else if(fixedParam.find("->second") != string::npos)
-                    {
-                        tmpParam += fixedParam.substr(0, fixedParam.length() - 8);
-                    }
-                    else
-                    {
-                        tmpParam += fixedParam;
-                    }
-                    out << nl << typeToString(type, md, TypeContextInParam) << " " << tmpParam << ";";
-                    out << nl << stream << deref << func << tmpParam << ");";
-                    out << nl << "::std::vector< ::Ice::Byte>(" << tmpParam << ".first, " << tmpParam 
-                        << ".second).swap(" << fixedParam << ");";
-                }
-                else
-                {
-                    out << nl << stream << deref << func << fixedParam << ");";
-                }
+                out << nl << func << "___" << param << ");";
+                writeParamEndCode(out, seq, optional, param, metaData);
+                return;
             }
         }
-        return;
     }
-    
-    DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
-    if(dict)
-    {
-        string scope = fixKwd(dict->scope());
-        string funcDict = (marshal ? "write" : "read") + fixKwd(dict->name()) + "(";
-        out << nl << scope << "__" << funcDict << (pointer ? "" : "&") << stream << ", " << fixedParam << ");";
-        return;
-    }
-    
-    ConstructedPtr constructed = ConstructedPtr::dynamicCast(type);
-    assert(constructed);
 
-    out << nl << fixKwd(constructed->scope()) << "__" << func << (pointer ? "" : "&") << stream << ", "
-        << fixedParam << ");";
+    out << nl << func << param << ");";
 }
 
 void
-Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const TypePtr& ret, const StringList& metaData,
-                        int typeCtx)
+Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, int typeCtx)
 {
-    for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
-    {
-        writeMarshalUnmarshalCode(out, (*p)->type(), fixKwd((*p)->name()), true, "", true, (*p)->getMetaData(),
-                                  typeCtx);
-    }
-    if(ret)
-    {
-        writeMarshalUnmarshalCode(out, ret, "__ret", true, "", true, metaData);
-    }
+    writeMarshalUnmarshalParams(out, params, op, true, typeCtx);
 }
 
 void
-Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const TypePtr& ret, const StringList& metaData,
-                          int typeCtx)
-{
-    for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
-    {
-        writeMarshalUnmarshalCode(out, (*p)->type(), fixKwd((*p)->name()), false, "", true, (*p)->getMetaData(), 
-                                  typeCtx);
-    }
-    if(ret)
-    {
-        writeMarshalUnmarshalCode(out, ret, "__ret", false, "", true, metaData, typeCtx);
-    }
-}
-
-namespace
-{
-
-void
-writeParamAllocateCode(Output& out, const TypePtr& type, const string& fixedName, const StringList& metaData,
-                       int typeCtx)
+Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, int typeCtx)
 {
-    out << nl << typeToString(type, metaData, typeCtx) << ' ' << fixedName;
-    StructPtr st = StructPtr::dynamicCast(type);
-    if(st && findMetaData(st->getMetaData()) == "class")
-    {
-        out << " = new " << fixKwd(st->scoped());
-    }
-    out << ';';
-
-    if(!(typeCtx & TypeContextInParam))
-    {
-        return; // We're done.
-    }
-
-    //
-    // If using a range or array we need to allocate the range container, or 
-    // array as well now to ensure they are always in the same scope.
-    //
-    SequencePtr seq = SequencePtr::dynamicCast(type);
-    if(seq)
-    {
-        bool protobuf;
-        string seqType = findMetaData(seq, metaData, protobuf, typeCtx);
-        if(!protobuf && seqType.empty())
-        {
-            seqType = findMetaData(seq, seq->getMetaData(), protobuf, typeCtx);
-        }
-        if(protobuf)
-        {
-            return;
-        }
-        if(seqType == "array" || seqType == "range:array")
-        {
-            if(typeCtx & TypeContextAMICallPrivateEnd)
-            {
-                out << nl << typeToString(seq, metaData, TypeContextAMIPrivateEnd) << " ___" << fixedName << ";";
-//                 BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
-//                 if(builtin && 
-//                    builtin->kind() != Builtin::KindByte &&
-//                    builtin->kind() != Builtin::KindString &&
-//                    builtin->kind() != Builtin::KindObject &&
-//                    builtin->kind() != Builtin::KindObjectProxy)
-//                 {
-//                     out << nl << typeToString(seq, metaData, TypeContextAMIPrivateEnd) << " ___" << fixedName << ";";
-//                 }
-//                 else if(!builtin || builtin->kind() != Builtin::KindByte)
-//                 {
-//                     out << nl << typeToString(seq, metaData) << " ___" << fixedName << ";";
-//                 }
-            }
-        }
-        else if(seqType.find("range") == 0)
-        {
-            StringList md;
-            if(seqType.find("range:") == 0)
-            {
-                md.push_back("cpp:type:" + seqType.substr(strlen("range:")));
-            }
-            out << nl << typeToString(seq, md) << " ___" << fixedName << ";";
-        }
-    }
-}
-
+    writeMarshalUnmarshalParams(out, params, op, false, typeCtx);
 }
 
 void
-Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const TypePtr& ret, const StringList& metaData, 
-                         int typeCtx)
+Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, int typeCtx)
 {
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
-        writeParamAllocateCode(out, (*p)->type(), fixKwd((*p)->name()), (*p)->getMetaData(), typeCtx);
-    }
-    if(ret)
-    {
-        writeParamAllocateCode(out, ret, "__ret", metaData, typeCtx);
-    }
-}
-
-void
-Slice::writeStreamMarshalUnmarshalCode(Output& out, const TypePtr& type, const string& param, bool marshal,
-                                       const string& str, const StringList& metaData, int typeCtx)
-{
-    string fixedParam = fixKwd(param);
-
-    string stream;
-    if(str.empty())
-    {
-        stream = marshal ? "__outS" : "__inS";
-    }
-    else
-    {
-        stream = str;
+        writeParamAllocateCode(out, (*p)->type(), (*p)->optional(), fixKwd((*p)->name()), (*p)->getMetaData(), typeCtx);
     }
-
-    if(marshal)
-    {
-        out << nl << stream << "->write(" << fixedParam << ");";
-    }
-    else
+    if(op && op->returnType())
     {
-        out << nl << stream << "->read(" << fixedParam << ");";
+        writeParamAllocateCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData(), typeCtx);
     }
 }
 
@@ -1197,63 +961,16 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string&
     return endArg;
 }
 
-namespace
-{
-
-void
-writeParamEndCode(Output& out, const TypePtr& type, const string& fixedName, const StringList& metaData)
-{
-    SequencePtr seq = SequencePtr::dynamicCast(type);
-    if(seq)
-    {
-        bool protobuf;
-        string seqType = findMetaData(seq, metaData, protobuf, TypeContextInParam);
-        if(!protobuf && seqType.empty())
-        {
-            seqType = findMetaData(seq, seq->getMetaData(), protobuf, TypeContextInParam);
-        }
-        if(!protobuf)
-        {
-            if(seqType == "array" || seqType == "range:array")
-            {
-                BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
-                if(builtin && 
-                   builtin->kind() != Builtin::KindByte &&
-                   builtin->kind() != Builtin::KindString &&
-                   builtin->kind() != Builtin::KindObject &&
-                   builtin->kind() != Builtin::KindObjectProxy)
-                {
-                    out << nl << fixedName << " = ___" << fixedName << ".second;";
-                }
-                else if(!builtin || builtin->kind() == Builtin::KindString || builtin->kind() == Builtin::KindObject ||
-                        builtin->kind() == Builtin::KindObjectProxy)
-                {
-                    out << nl << fixedName << ".first" << " = &___" << fixedName << "[0];";
-                    out << nl << fixedName << ".second" << " = " << fixedName << ".first + " << "___" 
-                        << fixedName << ".size();";
-                }
-            }
-            else if(seqType.find("range") == 0)
-            {
-                out << nl << fixedName << ".first = ___" << fixedName << ".begin();";
-                out << nl << fixedName << ".second = ___" << fixedName << ".end();";
-            }
-        }
-    }
-}
-
-}
-
 void
-Slice::writeEndCode(Output& out, const ParamDeclList& params, const TypePtr& ret, const StringList& metaData)
+Slice::writeEndCode(Output& out, const ParamDeclList& params, const OperationPtr& op)
 {
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
-        writeParamEndCode(out, (*p)->type(), fixKwd((*p)->name()), (*p)->getMetaData());
+        writeParamEndCode(out, (*p)->type(), (*p)->optional(), fixKwd((*p)->name()), (*p)->getMetaData());
     }
-    if(ret)
+    if(op && op->returnType())
     {
-        writeParamEndCode(out, ret, "__ret", metaData);
+        writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData());
     }
 }
 
@@ -1307,7 +1024,7 @@ Slice::findMetaData(const SequencePtr& seq, const StringList& metaData, bool& is
                     }
                     return "";
                 }
-                else if((typeCtx & (TypeContextInParam  | TypeContextAMIPrivateEnd)) &&
+                else if((typeCtx & (TypeContextInParam | TypeContextAMIPrivateEnd)) &&
                         !(typeCtx & TypeContextAMIEnd) && ss.find("range:") == 0)
                 {
                     return str.substr(prefix.size());
@@ -1434,3 +1151,23 @@ Slice::inWstringModule(const SequencePtr& seq)
     }
     return false;
 }
+
+
+string
+Slice::getDataMemberRef(const DataMemberPtr& p)
+{
+    string name = fixKwd(p->name());
+    if(!p->optional())
+    {
+        return name;
+    }
+
+    if(BuiltinPtr::dynamicCast(p->type()))
+    {
+        return "*" + name;
+    }
+    else
+    {
+        return "(*" + name + ")";
+    }
+}
diff --git a/cpp/src/Slice/Grammar.cpp b/cpp/src/Slice/Grammar.cpp
index 97aef00aed5..d5c742768f2 100644
--- a/cpp/src/Slice/Grammar.cpp
+++ b/cpp/src/Slice/Grammar.cpp
@@ -1,23 +1,24 @@
-
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
 /* Skeleton implementation for Bison's Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
+
+   This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -28,7 +29,7 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-   
+
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
@@ -46,7 +47,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.4.1"
+#define YYBISON_VERSION "2.3"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -54,28 +55,117 @@
 /* Pure parsers.  */
 #define YYPURE 1
 
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
-
 /* Using locations.  */
 #define YYLSP_NEEDED 0
 
 /* Substitute the variable and function names.  */
-#define yyparse         slice_parse
-#define yylex           slice_lex
-#define yyerror         slice_error
-#define yylval          slice_lval
-#define yychar          slice_char
-#define yydebug         slice_debug
-#define yynerrs         slice_nerrs
+#define yyparse slice_parse
+#define yylex   slice_lex
+#define yyerror slice_error
+#define yylval  slice_lval
+#define yychar  slice_char
+#define yydebug slice_debug
+#define yynerrs slice_nerrs
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     ICE_MODULE = 258,
+     ICE_CLASS = 259,
+     ICE_INTERFACE = 260,
+     ICE_EXCEPTION = 261,
+     ICE_STRUCT = 262,
+     ICE_SEQUENCE = 263,
+     ICE_DICTIONARY = 264,
+     ICE_ENUM = 265,
+     ICE_OUT = 266,
+     ICE_EXTENDS = 267,
+     ICE_IMPLEMENTS = 268,
+     ICE_THROWS = 269,
+     ICE_VOID = 270,
+     ICE_BYTE = 271,
+     ICE_BOOL = 272,
+     ICE_SHORT = 273,
+     ICE_INT = 274,
+     ICE_LONG = 275,
+     ICE_FLOAT = 276,
+     ICE_DOUBLE = 277,
+     ICE_STRING = 278,
+     ICE_OBJECT = 279,
+     ICE_LOCAL_OBJECT = 280,
+     ICE_LOCAL = 281,
+     ICE_CONST = 282,
+     ICE_FALSE = 283,
+     ICE_TRUE = 284,
+     ICE_IDEMPOTENT = 285,
+     ICE_OPTIONAL = 286,
+     ICE_SCOPE_DELIMITER = 287,
+     ICE_IDENTIFIER = 288,
+     ICE_STRING_LITERAL = 289,
+     ICE_INTEGER_LITERAL = 290,
+     ICE_FLOATING_POINT_LITERAL = 291,
+     ICE_IDENT_OP = 292,
+     ICE_KEYWORD_OP = 293,
+     ICE_OPTIONAL_OP = 294,
+     ICE_METADATA_OPEN = 295,
+     ICE_METADATA_CLOSE = 296,
+     ICE_GLOBAL_METADATA_OPEN = 297,
+     ICE_GLOBAL_METADATA_CLOSE = 298,
+     BAD_CHAR = 299
+   };
+#endif
+/* Tokens.  */
+#define ICE_MODULE 258
+#define ICE_CLASS 259
+#define ICE_INTERFACE 260
+#define ICE_EXCEPTION 261
+#define ICE_STRUCT 262
+#define ICE_SEQUENCE 263
+#define ICE_DICTIONARY 264
+#define ICE_ENUM 265
+#define ICE_OUT 266
+#define ICE_EXTENDS 267
+#define ICE_IMPLEMENTS 268
+#define ICE_THROWS 269
+#define ICE_VOID 270
+#define ICE_BYTE 271
+#define ICE_BOOL 272
+#define ICE_SHORT 273
+#define ICE_INT 274
+#define ICE_LONG 275
+#define ICE_FLOAT 276
+#define ICE_DOUBLE 277
+#define ICE_STRING 278
+#define ICE_OBJECT 279
+#define ICE_LOCAL_OBJECT 280
+#define ICE_LOCAL 281
+#define ICE_CONST 282
+#define ICE_FALSE 283
+#define ICE_TRUE 284
+#define ICE_IDEMPOTENT 285
+#define ICE_OPTIONAL 286
+#define ICE_SCOPE_DELIMITER 287
+#define ICE_IDENTIFIER 288
+#define ICE_STRING_LITERAL 289
+#define ICE_INTEGER_LITERAL 290
+#define ICE_FLOATING_POINT_LITERAL 291
+#define ICE_IDENT_OP 292
+#define ICE_KEYWORD_OP 293
+#define ICE_OPTIONAL_OP 294
+#define ICE_METADATA_OPEN 295
+#define ICE_METADATA_CLOSE 296
+#define ICE_GLOBAL_METADATA_OPEN 297
+#define ICE_GLOBAL_METADATA_CLOSE 298
+#define BAD_CHAR 299
+
 
 
-/* Copy the first part of user declarations.  */
 
-/* Line 189 of yacc.c  */
+/* Copy the first part of user declarations.  */
 #line 1 "../Slice/Grammar.y"
 
 
@@ -122,9 +212,6 @@ slice_error(const char* s)
 
 
 
-/* Line 189 of yacc.c  */
-#line 127 "Grammar.tab.c"
-
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -143,73 +230,20 @@ slice_error(const char* s)
 # define YYTOKEN_TABLE 0
 #endif
 
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     ICE_MODULE = 258,
-     ICE_CLASS = 259,
-     ICE_INTERFACE = 260,
-     ICE_EXCEPTION = 261,
-     ICE_STRUCT = 262,
-     ICE_SEQUENCE = 263,
-     ICE_DICTIONARY = 264,
-     ICE_ENUM = 265,
-     ICE_OUT = 266,
-     ICE_EXTENDS = 267,
-     ICE_IMPLEMENTS = 268,
-     ICE_THROWS = 269,
-     ICE_VOID = 270,
-     ICE_BYTE = 271,
-     ICE_BOOL = 272,
-     ICE_SHORT = 273,
-     ICE_INT = 274,
-     ICE_LONG = 275,
-     ICE_FLOAT = 276,
-     ICE_DOUBLE = 277,
-     ICE_STRING = 278,
-     ICE_OBJECT = 279,
-     ICE_LOCAL_OBJECT = 280,
-     ICE_LOCAL = 281,
-     ICE_CONST = 282,
-     ICE_FALSE = 283,
-     ICE_TRUE = 284,
-     ICE_IDEMPOTENT = 285,
-     ICE_OPTIONAL = 286,
-     ICE_SCOPE_DELIMITER = 287,
-     ICE_IDENTIFIER = 288,
-     ICE_STRING_LITERAL = 289,
-     ICE_INTEGER_LITERAL = 290,
-     ICE_FLOATING_POINT_LITERAL = 291,
-     ICE_IDENT_OP = 292,
-     ICE_KEYWORD_OP = 293,
-     ICE_OPTIONAL_OP = 294,
-     ICE_METADATA_OPEN = 295,
-     ICE_METADATA_CLOSE = 296,
-     ICE_GLOBAL_METADATA_OPEN = 297,
-     ICE_GLOBAL_METADATA_CLOSE = 298,
-     BAD_CHAR = 299
-   };
-#endif
-
-
-
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 
+
 /* Copy the second part of user declarations.  */
 
 
-/* Line 264 of yacc.c  */
-#line 213 "Grammar.tab.c"
+/* Line 216 of yacc.c.  */
+#line 247 "Grammar.tab.c"
 
 #ifdef short
 # undef short
@@ -259,7 +293,7 @@ typedef short int yytype_int16;
 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
 #ifndef YY_
-# if YYENABLE_NLS
+# if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
@@ -284,14 +318,14 @@ typedef short int yytype_int16;
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static int
-YYID (int yyi)
+YYID (int i)
 #else
 static int
-YYID (yyi)
-    int yyi;
+YYID (i)
+    int i;
 #endif
 {
-  return yyi;
+  return i;
 }
 #endif
 
@@ -372,9 +406,9 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  yytype_int16 yyss_alloc;
-  YYSTYPE yyvs_alloc;
-};
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+  };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
@@ -408,12 +442,12 @@ union yyalloc
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
+# define YYSTACK_RELOCATE(Stack)					\
     do									\
       {									\
 	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
-	Stack = &yyptr->Stack_alloc;					\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
@@ -424,16 +458,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  13
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   860
+#define YYLAST   875
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  54
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  68
+#define YYNNTS  69
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  188
+#define YYNRULES  190
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  280
+#define YYNSTATES  282
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
@@ -486,81 +520,82 @@ static const yytype_uint16 yyprhs[] =
       26,    27,    32,    35,    36,    38,    40,    42,    44,    46,
       48,    50,    52,    54,    56,    58,    60,    62,    63,    70,
       73,    76,    79,    80,    88,    91,    92,    97,   101,   104,
-     105,   108,   113,   118,   122,   125,   127,   129,   132,   135,
-     138,   139,   146,   151,   155,   158,   159,   161,   164,   167,
-     170,   171,   180,   183,   184,   187,   188,   193,   197,   200,
-     201,   203,   207,   210,   212,   214,   216,   219,   223,   226,
-     230,   231,   237,   238,   244,   246,   248,   251,   254,   257,
-     258,   266,   270,   272,   274,   277,   278,   283,   287,   290,
-     291,   293,   297,   299,   301,   303,   311,   319,   330,   341,
-     344,   347,   348,   355,   361,   365,   367,   369,   371,   372,
-     374,   375,   376,   380,   386,   391,   398,   402,   408,   411,
-     412,   414,   417,   421,   423,   425,   427,   429,   431,   433,
-     435,   437,   439,   442,   444,   446,   449,   452,   454,   458,
-     460,   462,   463,   465,   467,   469,   471,   473,   475,   482,
-     488,   490,   492,   494,   496,   498,   500,   502,   504,   506,
-     508,   510,   512,   514,   516,   518,   520,   522,   524,   526,
-     528,   530,   532,   534,   536,   538,   540,   542,   544
+     105,   108,   112,   116,   119,   121,   124,   126,   128,   131,
+     134,   137,   138,   145,   150,   154,   157,   158,   160,   163,
+     166,   169,   170,   179,   182,   183,   186,   187,   192,   196,
+     199,   200,   202,   206,   209,   211,   214,   216,   218,   221,
+     225,   228,   232,   233,   239,   240,   246,   248,   250,   253,
+     256,   259,   260,   268,   272,   274,   276,   279,   280,   285,
+     289,   292,   293,   295,   299,   301,   303,   305,   313,   321,
+     332,   343,   346,   349,   350,   357,   363,   367,   369,   371,
+     373,   374,   376,   377,   378,   382,   388,   393,   400,   404,
+     410,   413,   414,   416,   419,   423,   425,   427,   429,   431,
+     433,   435,   437,   439,   441,   444,   446,   448,   451,   454,
+     456,   460,   462,   464,   465,   467,   469,   471,   473,   475,
+     477,   484,   490,   492,   494,   496,   498,   500,   502,   504,
+     506,   508,   510,   512,   514,   516,   518,   520,   522,   524,
+     526,   528,   530,   532,   534,   536,   538,   540,   542,   544,
+     546
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      55,     0,    -1,    58,    -1,    42,   117,    43,    -1,    40,
-     117,    41,    -1,    -1,    -1,    56,    59,    58,    -1,    -1,
+      55,     0,    -1,    58,    -1,    42,   118,    43,    -1,    40,
+     118,    41,    -1,    -1,    -1,    56,    59,    58,    -1,    -1,
       57,    62,    60,    45,    58,    -1,    -1,     1,    45,    61,
-      58,    -1,    57,    62,    -1,    -1,    63,    -1,    81,    -1,
-      82,    -1,    95,    -1,    96,    -1,    66,    -1,    67,    -1,
-      75,    -1,    76,    -1,   104,    -1,   105,    -1,   107,    -1,
-     120,    -1,    -1,     3,    33,    64,    46,    58,    47,    -1,
-       6,    33,    -1,     6,   121,    -1,   118,    65,    -1,    -1,
-     118,    65,    69,    68,    46,    70,    47,    -1,    12,   114,
-      -1,    -1,    57,    73,    45,    70,    -1,     1,    45,    70,
-      -1,    57,    73,    -1,    -1,   115,    33,    -1,    39,    35,
-      48,    71,    -1,    39,   114,    48,    71,    -1,    39,    48,
-      71,    -1,    31,    71,    -1,    71,    -1,    87,    -1,     7,
-      33,    -1,     7,   121,    -1,   118,    74,    -1,    -1,   118,
-      74,    77,    46,    78,    47,    -1,    57,    79,    45,    78,
-      -1,     1,    45,    78,    -1,    57,    79,    -1,    -1,    87,
-      -1,     4,    33,    -1,     4,   121,    -1,   118,    80,    -1,
-      -1,   118,    80,    84,    85,    83,    46,    86,    47,    -1,
-      12,   114,    -1,    -1,    13,    98,    -1,    -1,    57,    93,
-      45,    86,    -1,     1,    45,    86,    -1,    57,    93,    -1,
-      -1,    72,    -1,    72,    49,   119,    -1,   115,   121,    -1,
-     115,    -1,   115,    -1,    15,    -1,    88,    37,    -1,    30,
-      88,    37,    -1,    88,    38,    -1,    30,    88,    38,    -1,
-      -1,    89,   112,    48,    91,   113,    -1,    -1,    89,     1,
-      48,    92,   113,    -1,    87,    -1,    90,    -1,     5,    33,
-      -1,     5,   121,    -1,   118,    94,    -1,    -1,   118,    94,
-      99,    97,    46,   100,    47,    -1,   114,    50,    98,    -1,
-     114,    -1,    24,    -1,    12,    98,    -1,    -1,    57,   101,
-      45,   100,    -1,     1,    45,   100,    -1,    57,   101,    -1,
-      -1,    90,    -1,   103,    50,   102,    -1,   103,    -1,   114,
-      -1,   121,    -1,   118,     8,    51,    57,   115,    52,    33,
-      -1,   118,     8,    51,    57,   115,    52,   121,    -1,   118,
-       9,    51,    57,   115,    50,    57,   115,    52,    33,    -1,
-     118,     9,    51,    57,   115,    50,    57,   115,    52,   121,
-      -1,    10,    33,    -1,    10,   121,    -1,    -1,   118,   106,
-     108,    46,   109,    47,    -1,   118,    10,    46,   109,    47,
-      -1,   110,    50,   109,    -1,   110,    -1,    33,    -1,   121,
-      -1,    -1,    11,    -1,    -1,    -1,   111,    57,    71,    -1,
-     112,    50,   111,    57,    71,    -1,   111,    57,   115,   121,
-      -1,   112,    50,   111,    57,   115,   121,    -1,   111,    57,
-     115,    -1,   112,    50,   111,    57,   115,    -1,    14,   102,
-      -1,    -1,    33,    -1,    32,    33,    -1,   114,    32,    33,
-      -1,    16,    -1,    17,    -1,    18,    -1,    19,    -1,    20,
-      -1,    21,    -1,    22,    -1,    23,    -1,    24,    -1,    24,
-      53,    -1,    25,    -1,   114,    -1,   114,    53,    -1,    34,
-     116,    -1,    34,    -1,   117,    50,   116,    -1,   116,    -1,
-      26,    -1,    -1,    35,    -1,    36,    -1,   114,    -1,    34,
-      -1,    28,    -1,    29,    -1,    27,    57,   115,    33,    49,
-     119,    -1,    27,    57,   115,    49,   119,    -1,     3,    -1,
-       4,    -1,     5,    -1,     6,    -1,     7,    -1,     8,    -1,
-       9,    -1,    10,    -1,    11,    -1,    12,    -1,    13,    -1,
-      14,    -1,    15,    -1,    16,    -1,    17,    -1,    18,    -1,
-      19,    -1,    20,    -1,    21,    -1,    22,    -1,    23,    -1,
-      24,    -1,    25,    -1,    26,    -1,    27,    -1,    28,    -1,
-      29,    -1,    30,    -1,    31,    -1
+      58,    -1,    57,    62,    -1,    -1,    63,    -1,    82,    -1,
+      83,    -1,    96,    -1,    97,    -1,    66,    -1,    67,    -1,
+      76,    -1,    77,    -1,   105,    -1,   106,    -1,   108,    -1,
+     121,    -1,    -1,     3,    33,    64,    46,    58,    47,    -1,
+       6,    33,    -1,     6,   122,    -1,   119,    65,    -1,    -1,
+     119,    65,    69,    68,    46,    70,    47,    -1,    12,   115,
+      -1,    -1,    57,    74,    45,    70,    -1,     1,    45,    70,
+      -1,    57,    74,    -1,    -1,   116,    33,    -1,    39,    35,
+      48,    -1,    39,   115,    48,    -1,    39,    48,    -1,    31,
+      -1,    72,    71,    -1,    71,    -1,    88,    -1,     7,    33,
+      -1,     7,   122,    -1,   119,    75,    -1,    -1,   119,    75,
+      78,    46,    79,    47,    -1,    57,    80,    45,    79,    -1,
+       1,    45,    79,    -1,    57,    80,    -1,    -1,    88,    -1,
+       4,    33,    -1,     4,   122,    -1,   119,    81,    -1,    -1,
+     119,    81,    85,    86,    84,    46,    87,    47,    -1,    12,
+     115,    -1,    -1,    13,    99,    -1,    -1,    57,    94,    45,
+      87,    -1,     1,    45,    87,    -1,    57,    94,    -1,    -1,
+      73,    -1,    73,    49,   120,    -1,   116,   122,    -1,   116,
+      -1,    72,   116,    -1,   116,    -1,    15,    -1,    89,    37,
+      -1,    30,    89,    37,    -1,    89,    38,    -1,    30,    89,
+      38,    -1,    -1,    90,   113,    48,    92,   114,    -1,    -1,
+      90,     1,    48,    93,   114,    -1,    88,    -1,    91,    -1,
+       5,    33,    -1,     5,   122,    -1,   119,    95,    -1,    -1,
+     119,    95,   100,    98,    46,   101,    47,    -1,   115,    50,
+      99,    -1,   115,    -1,    24,    -1,    12,    99,    -1,    -1,
+      57,   102,    45,   101,    -1,     1,    45,   101,    -1,    57,
+     102,    -1,    -1,    91,    -1,   104,    50,   103,    -1,   104,
+      -1,   115,    -1,   122,    -1,   119,     8,    51,    57,   116,
+      52,    33,    -1,   119,     8,    51,    57,   116,    52,   122,
+      -1,   119,     9,    51,    57,   116,    50,    57,   116,    52,
+      33,    -1,   119,     9,    51,    57,   116,    50,    57,   116,
+      52,   122,    -1,    10,    33,    -1,    10,   122,    -1,    -1,
+     119,   107,   109,    46,   110,    47,    -1,   119,    10,    46,
+     110,    47,    -1,   111,    50,   110,    -1,   111,    -1,    33,
+      -1,   122,    -1,    -1,    11,    -1,    -1,    -1,   112,    57,
+      73,    -1,   113,    50,   112,    57,    73,    -1,   112,    57,
+     116,   122,    -1,   113,    50,   112,    57,   116,   122,    -1,
+     112,    57,   116,    -1,   113,    50,   112,    57,   116,    -1,
+      14,   103,    -1,    -1,    33,    -1,    32,    33,    -1,   115,
+      32,    33,    -1,    16,    -1,    17,    -1,    18,    -1,    19,
+      -1,    20,    -1,    21,    -1,    22,    -1,    23,    -1,    24,
+      -1,    24,    53,    -1,    25,    -1,   115,    -1,   115,    53,
+      -1,    34,   117,    -1,    34,    -1,   118,    50,   117,    -1,
+     117,    -1,    26,    -1,    -1,    35,    -1,    36,    -1,   115,
+      -1,    34,    -1,    28,    -1,    29,    -1,    27,    57,   116,
+      33,    49,   120,    -1,    27,    57,   116,    49,   120,    -1,
+       3,    -1,     4,    -1,     5,    -1,     6,    -1,     7,    -1,
+       8,    -1,     9,    -1,    10,    -1,    11,    -1,    12,    -1,
+      13,    -1,    14,    -1,    15,    -1,    16,    -1,    17,    -1,
+      18,    -1,    19,    -1,    20,    -1,    21,    -1,    22,    -1,
+      23,    -1,    24,    -1,    25,    -1,    26,    -1,    27,    -1,
+      28,    -1,    29,    -1,    30,    -1,    31,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
@@ -570,21 +605,22 @@ static const yytype_uint16 yyrline[] =
      157,   156,   161,   166,   173,   177,   181,   185,   189,   193,
      197,   201,   205,   209,   213,   217,   221,   231,   230,   264,
      268,   279,   290,   289,   316,   325,   333,   342,   345,   350,
-     357,   370,   393,   466,   477,   488,   503,   509,   513,   524,
-     535,   534,   570,   579,   582,   587,   594,   600,   604,   615,
-     629,   628,   668,   703,   711,   716,   724,   733,   736,   741,
-     748,   770,   797,   819,   845,   846,   855,   879,   903,   927,
-     957,   956,   979,   978,  1001,  1002,  1008,  1012,  1023,  1038,
-    1037,  1072,  1107,  1142,  1152,  1157,  1165,  1174,  1177,  1182,
-    1189,  1195,  1202,  1214,  1226,  1237,  1246,  1261,  1272,  1289,
-    1293,  1305,  1304,  1328,  1343,  1349,  1357,  1369,  1377,  1386,
-    1393,  1404,  1406,  1424,  1442,  1454,  1466,  1477,  1493,  1498,
-    1506,  1509,  1515,  1528,  1532,  1536,  1540,  1544,  1548,  1552,
-    1556,  1560,  1564,  1568,  1572,  1591,  1632,  1638,  1646,  1653,
-    1665,  1672,  1682,  1695,  1708,  1754,  1765,  1776,  1792,  1801,
-    1815,  1818,  1821,  1824,  1827,  1830,  1833,  1836,  1839,  1842,
-    1845,  1848,  1851,  1854,  1857,  1860,  1863,  1866,  1869,  1872,
-    1875,  1878,  1881,  1884,  1887,  1890,  1893,  1896,  1899
+     357,   370,   390,   460,   468,   481,   489,   504,   510,   514,
+     525,   536,   535,   571,   580,   583,   588,   595,   601,   605,
+     616,   630,   629,   669,   704,   712,   717,   725,   734,   737,
+     742,   749,   771,   798,   820,   846,   852,   860,   872,   896,
+     921,   945,   976,   975,   998,   997,  1020,  1021,  1027,  1031,
+    1042,  1057,  1056,  1091,  1126,  1161,  1171,  1176,  1184,  1193,
+    1196,  1201,  1208,  1214,  1221,  1233,  1245,  1256,  1265,  1280,
+    1291,  1308,  1312,  1324,  1323,  1347,  1362,  1368,  1376,  1388,
+    1396,  1405,  1412,  1423,  1425,  1441,  1457,  1469,  1481,  1492,
+    1508,  1513,  1521,  1524,  1530,  1543,  1547,  1551,  1555,  1559,
+    1563,  1567,  1571,  1575,  1579,  1583,  1587,  1606,  1647,  1653,
+    1661,  1668,  1680,  1687,  1697,  1710,  1723,  1769,  1780,  1791,
+    1807,  1816,  1830,  1833,  1836,  1839,  1842,  1845,  1848,  1851,
+    1854,  1857,  1860,  1863,  1866,  1869,  1872,  1875,  1878,  1881,
+    1884,  1887,  1890,  1893,  1896,  1899,  1902,  1905,  1908,  1911,
+    1914
 };
 #endif
 
@@ -605,13 +641,13 @@ static const char *const yytname[] =
   "ICE_OPTIONAL_OP", "ICE_METADATA_OPEN", "ICE_METADATA_CLOSE",
   "ICE_GLOBAL_METADATA_OPEN", "ICE_GLOBAL_METADATA_CLOSE", "BAD_CHAR",
   "';'", "'{'", "'}'", "')'", "'='", "','", "'<'", "'>'", "'*'", "$accept",
-  "start", "global_meta_data", "meta_data", "definitions", "$@1", "$@2",
-  "$@3", "definition", "module_def", "@4", "exception_id",
-  "exception_decl", "exception_def", "@5", "exception_extends",
-  "exception_exports", "type_id", "data_member_type_id",
-  "exception_export", "struct_id", "struct_decl", "struct_def", "@6",
-  "struct_exports", "struct_export", "class_id", "class_decl", "class_def",
-  "@7", "class_extends", "implements", "class_exports", "data_member",
+  "start", "global_meta_data", "meta_data", "definitions", "@1", "@2",
+  "@3", "definition", "module_def", "@4", "exception_id", "exception_decl",
+  "exception_def", "@5", "exception_extends", "exception_exports",
+  "type_id", "optional", "optional_type_id", "exception_export",
+  "struct_id", "struct_decl", "struct_def", "@6", "struct_exports",
+  "struct_export", "class_id", "class_decl", "class_def", "@7",
+  "class_extends", "implements", "class_exports", "data_member",
   "return_type", "operation_preamble", "operation", "@8", "@9",
   "class_export", "interface_id", "interface_decl", "interface_def", "@10",
   "interface_list", "interface_extends", "interface_exports",
@@ -644,21 +680,22 @@ static const yytype_uint8 yyr1[] =
       61,    58,    58,    58,    62,    62,    62,    62,    62,    62,
       62,    62,    62,    62,    62,    62,    62,    64,    63,    65,
       65,    66,    68,    67,    69,    69,    70,    70,    70,    70,
-      71,    72,    72,    72,    72,    72,    73,    74,    74,    75,
-      77,    76,    78,    78,    78,    78,    79,    80,    80,    81,
-      83,    82,    84,    84,    85,    85,    86,    86,    86,    86,
-      87,    87,    87,    87,    88,    88,    89,    89,    89,    89,
-      91,    90,    92,    90,    93,    93,    94,    94,    95,    97,
-      96,    98,    98,    98,    99,    99,   100,   100,   100,   100,
-     101,   102,   102,   103,   103,   104,   104,   105,   105,   106,
-     106,   108,   107,   107,   109,   109,   110,   110,   110,   111,
-     111,   112,   112,   112,   112,   112,   112,   112,   113,   113,
-     114,   114,   114,   115,   115,   115,   115,   115,   115,   115,
-     115,   115,   115,   115,   115,   115,   116,   116,   117,   117,
-     118,   118,   119,   119,   119,   119,   119,   119,   120,   120,
-     121,   121,   121,   121,   121,   121,   121,   121,   121,   121,
-     121,   121,   121,   121,   121,   121,   121,   121,   121,   121,
-     121,   121,   121,   121,   121,   121,   121,   121,   121
+      71,    72,    72,    72,    72,    73,    73,    74,    75,    75,
+      76,    78,    77,    79,    79,    79,    79,    80,    81,    81,
+      82,    84,    83,    85,    85,    86,    86,    87,    87,    87,
+      87,    88,    88,    88,    88,    89,    89,    89,    90,    90,
+      90,    90,    92,    91,    93,    91,    94,    94,    95,    95,
+      96,    98,    97,    99,    99,    99,   100,   100,   101,   101,
+     101,   101,   102,   103,   103,   104,   104,   105,   105,   106,
+     106,   107,   107,   109,   108,   108,   110,   110,   111,   111,
+     111,   112,   112,   113,   113,   113,   113,   113,   113,   113,
+     114,   114,   115,   115,   115,   116,   116,   116,   116,   116,
+     116,   116,   116,   116,   116,   116,   116,   116,   117,   117,
+     118,   118,   119,   119,   120,   120,   120,   120,   120,   120,
+     121,   121,   122,   122,   122,   122,   122,   122,   122,   122,
+     122,   122,   122,   122,   122,   122,   122,   122,   122,   122,
+     122,   122,   122,   122,   122,   122,   122,   122,   122,   122,
+     122
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -668,21 +705,22 @@ static const yytype_uint8 yyr2[] =
        0,     4,     2,     0,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     0,     6,     2,
        2,     2,     0,     7,     2,     0,     4,     3,     2,     0,
-       2,     4,     4,     3,     2,     1,     1,     2,     2,     2,
-       0,     6,     4,     3,     2,     0,     1,     2,     2,     2,
-       0,     8,     2,     0,     2,     0,     4,     3,     2,     0,
-       1,     3,     2,     1,     1,     1,     2,     3,     2,     3,
-       0,     5,     0,     5,     1,     1,     2,     2,     2,     0,
-       7,     3,     1,     1,     2,     0,     4,     3,     2,     0,
-       1,     3,     1,     1,     1,     7,     7,    10,    10,     2,
-       2,     0,     6,     5,     3,     1,     1,     1,     0,     1,
-       0,     0,     3,     5,     4,     6,     3,     5,     2,     0,
-       1,     2,     3,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     2,     1,     1,     2,     2,     1,     3,     1,
-       1,     0,     1,     1,     1,     1,     1,     1,     6,     5,
+       2,     3,     3,     2,     1,     2,     1,     1,     2,     2,
+       2,     0,     6,     4,     3,     2,     0,     1,     2,     2,
+       2,     0,     8,     2,     0,     2,     0,     4,     3,     2,
+       0,     1,     3,     2,     1,     2,     1,     1,     2,     3,
+       2,     3,     0,     5,     0,     5,     1,     1,     2,     2,
+       2,     0,     7,     3,     1,     1,     2,     0,     4,     3,
+       2,     0,     1,     3,     1,     1,     1,     7,     7,    10,
+      10,     2,     2,     0,     6,     5,     3,     1,     1,     1,
+       0,     1,     0,     0,     3,     5,     4,     6,     3,     5,
+       2,     0,     1,     2,     3,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     2,     1,     1,     2,     2,     1,
+       3,     1,     1,     0,     1,     1,     1,     1,     1,     1,
+       6,     5,     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
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -690,250 +728,257 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       0,     0,     0,     0,     0,     6,   151,     2,    10,   147,
-     149,     0,     0,     1,     0,     0,   150,     5,    12,    14,
+       0,     0,     0,     0,     0,     6,   153,     2,    10,   149,
+     151,     0,     0,     1,     0,     0,   152,     5,    12,    14,
       19,    20,    21,    22,    15,    16,    17,    18,    23,    24,
-      25,     0,    26,     0,   146,     4,     0,     3,     7,    27,
+      25,     0,    26,     0,   148,     4,     0,     3,     7,    27,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    31,
-      49,    59,    88,   111,    11,   148,     0,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   143,     0,   130,   144,
-       0,     0,   160,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,    57,    58,    86,    87,    29,    30,    47,    48,     5,
-       5,   109,   118,   110,     0,    32,     0,     0,    65,     0,
-      89,     0,     0,   142,   131,     0,   145,     0,     0,     9,
-       0,     0,   116,     0,   115,   117,    34,     0,     0,    62,
-       0,    60,    93,    94,    92,     0,   118,     0,   132,     0,
-     156,   157,   155,   152,   153,   154,   159,     0,     0,   113,
-     118,     0,     0,     0,     0,    64,     0,     0,     0,     0,
-      28,   158,     0,     5,   114,     0,     0,     0,     0,     0,
-       0,    45,    70,    54,    56,    73,    51,     0,    91,     0,
-       0,     0,   112,   105,   106,     0,     0,    38,    46,    33,
-      53,    44,     0,     0,     0,     0,     0,     0,    40,    72,
-       0,     0,     0,     0,    75,     0,     0,     0,   100,    98,
-      74,    90,     0,    37,     0,     0,    43,     0,    71,    52,
-       0,    84,    85,    68,    73,    61,    97,     0,    76,    78,
-       0,   119,     5,     0,     0,     0,    36,    41,    42,    67,
-       0,    77,    79,    82,     0,    80,   120,    96,   107,   108,
-      66,   129,   122,   126,   129,     5,     0,    83,   124,    81,
-       0,   128,   102,   103,   104,   123,   127,     0,   125,   101
+      50,    60,    90,   113,    11,   150,     0,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   145,     0,   132,   146,
+       0,     0,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+     190,    58,    59,    88,    89,    29,    30,    48,    49,     5,
+       5,   111,   120,   112,     0,    32,     0,     0,    66,     0,
+      91,     0,     0,   144,   133,     0,   147,     0,     0,     9,
+       0,     0,   118,     0,   117,   119,    34,     0,     0,    63,
+       0,    61,    95,    96,    94,     0,   120,     0,   134,     0,
+     158,   159,   157,   154,   155,   156,   161,     0,     0,   115,
+     120,     0,     0,     0,     0,    65,     0,     0,     0,     0,
+      28,   160,     0,     5,   116,     0,     0,     0,     0,    44,
+       0,    46,     0,    71,    55,    57,    74,    52,     0,    93,
+       0,     0,     0,   114,   107,   108,     0,     0,    38,    47,
+      33,    54,     0,    43,     0,    45,     0,     0,     0,    40,
+      73,     0,     0,     0,     0,    77,     0,     0,     0,     0,
+     102,   100,    76,    92,     0,    37,     0,    41,    42,    72,
+      53,     0,     0,    86,    87,    69,    74,    62,    99,     0,
+      75,    78,    80,     0,   121,     5,     0,     0,     0,    36,
+      68,    75,     0,    79,    81,    84,     0,    82,   122,    98,
+     109,   110,    67,   131,   124,   128,   131,     5,     0,    85,
+     126,    83,     0,   130,   104,   105,   106,   125,   129,     0,
+     127,   103
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
       -1,     4,     5,     6,     7,    14,    41,    33,    18,    19,
-      56,    49,    20,    21,   137,   115,   177,   181,   182,   197,
-      50,    22,    23,   116,   164,   183,    51,    24,    25,   166,
-     118,   141,   212,   184,   216,   217,   218,   264,   261,   233,
-      52,    26,    27,   145,   143,   120,   191,   219,   271,   272,
-      28,    29,    53,    30,   121,   133,   134,   242,   243,   267,
-      69,   202,    10,    11,    31,   156,    32,   135
+      56,    49,    20,    21,   137,   115,   177,   181,   182,   183,
+     198,    50,    22,    23,   116,   164,   184,    51,    24,    25,
+     166,   118,   141,   213,   185,   218,   219,   220,   266,   263,
+     235,    52,    26,    27,   145,   143,   120,   192,   221,   273,
+     274,    28,    29,    53,    30,   121,   133,   134,   245,   246,
+     269,    69,   186,    10,    11,    31,   156,    32,   135
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -189
+#define YYPACT_NINF -195
 static const yytype_int16 yypact[] =
 {
-     423,    33,    -6,    -6,    74,  -189,    62,  -189,  -189,    -6,
-    -189,   -23,   -19,  -189,   246,    49,  -189,    46,    52,  -189,
-    -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,
-    -189,   130,  -189,   246,  -189,  -189,    -6,  -189,  -189,  -189,
-     827,    54,   530,   561,   592,   623,    75,    78,   389,    11,
-      85,     9,    17,  -189,  -189,  -189,    96,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -189,    77,  -189,   114,  -189,   -15,
-     -14,   246,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,  -189,    46,
-      46,  -189,   654,  -189,     1,  -189,   103,     1,   137,    90,
-    -189,   106,   101,  -189,  -189,   120,  -189,   105,    84,  -189,
-     827,   827,  -189,   108,   107,  -189,   127,   116,   278,   127,
-      90,  -189,  -189,  -189,    35,   117,   654,   119,  -189,    84,
-    -189,  -189,  -189,  -189,  -189,   127,  -189,   112,   118,  -189,
-     654,   311,   122,   765,   124,  -189,   126,    90,   344,   128,
-    -189,  -189,   685,    46,  -189,   129,   765,   131,   278,   827,
-      48,  -189,   133,   132,  -189,   716,  -189,   244,  -189,   135,
-     790,   136,  -189,  -189,  -189,   827,   311,   139,  -189,  -189,
-    -189,  -189,   140,   138,   827,    36,    84,   278,  -189,  -189,
-     142,   421,   141,   344,  -189,   809,    57,    29,  -189,   144,
-    -189,  -189,   143,  -189,   311,   827,  -189,   827,  -189,  -189,
-     244,  -189,  -189,   146,   463,  -189,  -189,    87,  -189,  -189,
-     145,  -189,    46,    25,   344,   747,  -189,  -189,  -189,  -189,
-     244,  -189,  -189,  -189,   827,  -189,   165,  -189,  -189,  -189,
-    -189,   178,  -189,   716,   178,    46,   499,  -189,  -189,  -189,
-     827,  -189,   147,   127,  -189,  -189,   716,   499,  -189,  -189
+     494,   -19,     0,     0,    89,  -195,    33,  -195,  -195,     0,
+    -195,   -18,   -21,  -195,    38,    61,  -195,    56,    65,  -195,
+    -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,
+    -195,   118,  -195,    38,  -195,  -195,     0,  -195,  -195,  -195,
+     116,    68,   601,   632,   663,   694,    64,    66,   460,     5,
+      70,     3,     6,  -195,  -195,  -195,    72,  -195,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,    76,  -195,    86,  -195,    30,
+      41,    38,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,  -195,    56,
+      56,  -195,   725,  -195,    37,  -195,    84,    37,   107,    67,
+    -195,    96,   415,  -195,  -195,   110,  -195,    97,    73,  -195,
+     116,   116,  -195,   100,   102,  -195,   121,   104,   337,   121,
+      67,  -195,  -195,  -195,    36,   108,   725,   111,  -195,    73,
+    -195,  -195,  -195,  -195,  -195,   121,  -195,   105,   112,  -195,
+     725,   370,   115,   836,   119,  -195,   117,    67,   271,   120,
+    -195,  -195,   756,    56,  -195,   123,   836,   125,   337,  -195,
+      40,  -195,   116,   124,   129,  -195,   787,  -195,   304,  -195,
+     130,   413,   131,  -195,  -195,  -195,   116,   370,   132,  -195,
+    -195,  -195,   128,  -195,    47,  -195,   146,    73,   337,  -195,
+    -195,   136,   413,   135,   271,  -195,   492,   116,    39,   235,
+    -195,   138,  -195,  -195,   113,  -195,   370,  -195,  -195,  -195,
+    -195,   304,   116,  -195,  -195,   139,   534,  -195,  -195,    74,
+    -195,  -195,  -195,   140,  -195,    56,    34,   271,   818,  -195,
+    -195,   146,   304,  -195,  -195,  -195,   836,  -195,   175,  -195,
+    -195,  -195,  -195,   173,  -195,   787,   173,    56,   570,  -195,
+    -195,  -195,   836,  -195,   142,   121,  -195,  -195,   787,   570,
+    -195,  -195
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -189,  -189,  -189,   -17,    -7,  -189,  -189,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -189,  -189,  -180,  -167,  -189,  -189,
-    -189,  -189,  -189,  -189,  -164,  -189,  -189,  -189,  -189,  -189,
-    -189,  -189,  -159,  -175,   -16,  -189,   -13,  -189,  -189,  -189,
-    -189,  -189,  -189,  -189,  -125,  -189,  -188,  -189,   -77,  -189,
-    -189,  -189,  -189,  -189,  -189,   -70,  -189,   -55,  -189,   -62,
-    -108,   -30,    30,   200,  -189,  -136,  -189,   -40
+    -195,  -195,  -195,   -17,    -8,  -195,  -195,  -195,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,  -195,  -170,  -171,  -179,  -175,
+    -195,  -195,  -195,  -195,  -195,  -154,  -195,  -195,  -195,  -195,
+    -195,  -195,  -195,  -165,  -162,   -23,  -195,   -16,  -195,  -195,
+    -195,  -195,  -195,  -195,  -195,  -112,  -195,  -194,  -195,   -85,
+    -195,  -195,  -195,  -195,  -195,  -195,  -125,  -195,   -60,  -195,
+     -67,  -109,   -27,    21,   197,  -195,  -140,  -195,   -41
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -122
+#define YYTABLE_NINF -124
 static const yytype_int16 yytable[] =
 {
-      40,   198,   102,   104,   106,   108,   136,    38,   113,   139,
-      70,   144,   201,   171,   200,   165,   223,   125,    35,   127,
-     155,   117,   -63,   114,    37,   236,    54,    36,     9,   119,
-     240,    36,   144,    67,    68,   128,   231,   226,   126,    34,
-     241,   155,   188,   229,   246,  -120,  -120,  -120,  -120,  -120,
-    -120,  -120,  -120,  -120,  -120,   -63,   257,   -35,   247,   144,
-     248,  -120,  -120,   -95,   129,    15,    55,   125,   125,  -120,
-     228,   249,   205,   255,    13,   256,   169,  -121,     8,  -121,
-      67,    68,    39,   203,   227,   167,     2,   262,    16,    17,
-     174,   260,   130,   131,   238,   239,   204,    -8,   155,    71,
-     157,   158,     1,   275,    -5,    -5,    -5,    -5,    -5,    -5,
-      -5,    -5,   150,   151,   142,   147,    67,    68,   152,   153,
-     154,   163,    67,    68,   251,   252,   109,    -5,    -5,   110,
-     123,   -50,   194,   185,    42,    43,    44,    45,    46,    47,
-      48,     2,   122,     3,   176,   209,   185,   124,   -13,   138,
-     140,   190,   146,   148,   149,   159,   195,   160,   273,   125,
-     220,   163,   161,   168,   172,   222,   170,   178,   173,   273,
-     211,   186,   187,   208,   196,   192,   241,   207,   199,   176,
-     213,   234,   206,   221,   224,   220,   225,   230,   235,   244,
-     163,   250,   266,   253,   209,   245,   190,   277,   232,   237,
-     279,   265,   269,    12,     0,   259,     0,   176,     0,     0,
-       0,     0,     0,   211,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   268,   263,   254,   274,   190,     0,     0,
-       0,     0,     0,   211,     0,     0,   278,   274,     0,     0,
-     276,     0,     0,     0,     0,   210,   -13,     1,   270,    -5,
-      -5,    -5,    -5,    -5,    -5,    -5,    -5,     0,     0,    -5,
-      -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,
-       0,     0,    -5,    -5,    -5,    -5,    -5,    -5,     0,   162,
-       0,     0,     0,    -5,     2,     0,     2,     0,     3,     0,
-       0,   -69,     0,   -13,    -5,    -5,    -5,    -5,    -5,    -5,
-      -5,    -5,    -5,    -5,     0,     0,     0,     0,     0,    -5,
-      -5,    -5,   175,     0,     0,     0,     0,    -5,     2,     0,
-       0,     0,     0,     0,     0,   -55,     0,    -5,    -5,    -5,
+      40,   102,   104,   106,   108,   136,    38,   113,   139,   171,
+     144,   205,   217,    70,   199,   117,   -64,   114,   119,   155,
+     238,   169,    37,    35,   201,    54,     8,   225,   165,    36,
+      34,   144,    36,   232,     9,   174,    15,   217,   -13,     1,
+     155,    -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,   -64,
+     233,   -35,   -97,   259,   230,   189,   249,    55,   144,    16,
+      17,   205,   125,   129,    -5,    -5,   250,   229,   125,    67,
+      68,   204,    67,    68,   127,   202,   241,   242,     2,   125,
+       3,   264,   257,   126,   258,   -13,   167,   262,   203,    13,
+     128,   142,   130,   131,    39,   228,     2,   277,   155,    67,
+      68,   150,   151,   157,   158,    67,    68,   152,   153,   154,
+      -8,   253,   254,    71,   147,   109,   -51,   110,   122,   124,
+     140,   163,    42,    43,    44,    45,    46,    47,    48,   123,
+     138,   195,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,   146,   148,   176,   210,   149,   159,    67,    68,
+     161,   191,   160,   125,   168,   206,   196,   172,   170,   275,
+     178,   163,   173,   188,   222,   248,   187,   193,   197,   224,
+     275,   212,   200,   207,   208,   214,   227,   226,   223,   209,
+     176,   231,   237,   247,   252,   236,   244,   268,   255,   222,
+     240,   163,   279,   239,   281,   210,   234,   191,   267,   271,
+      12,     0,     0,     0,     0,   251,     0,   261,     0,   176,
+       0,     0,     0,     0,   212,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   270,     0,     0,   276,   256,   265,
+     191,     0,     0,     0,     0,   212,   243,   280,   276,     0,
+       0,     0,     0,     0,     0,   278,   244,     0,     0,     0,
+     272,  -122,  -122,  -122,  -122,  -122,  -122,  -122,  -122,  -122,
+    -122,     0,     0,     0,     0,     0,  -122,  -122,  -122,     0,
+       0,     0,   190,     0,  -122,  -122,     0,     0,     0,     0,
+       0,     0,     0,  -123,     0,  -123,    -5,    -5,    -5,    -5,
       -5,    -5,    -5,    -5,    -5,    -5,    -5,     0,     0,     0,
-       0,     0,    -5,    -5,    -5,   189,     0,     0,     0,     0,
-      -5,     2,     0,     0,     0,     0,     0,     0,   -39,    -5,
+       0,    -5,    -5,    -5,    -5,   211,     0,     0,     0,     0,
+      -5,     2,     0,     0,     0,     0,     0,     0,  -101,    -5,
       -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,    -5,
-       0,     0,     0,     0,    -5,     0,    -5,    -5,     0,     0,
-       0,     0,     0,     0,     2,     0,     0,     0,     0,     0,
-       0,   -99,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,     0,   111,   -13,     1,     0,    -5,    -5,    -5,    -5,
-      -5,    -5,    -5,    -5,     0,   112,   214,    57,    58,    59,
-      60,    61,    62,    63,    64,    65,    66,     0,     0,    -5,
-      -5,   215,   179,    67,    68,     0,     0,     0,     0,     0,
-     180,     0,     0,     2,     0,     3,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,     0,   208,     0,     0,     0,
-     -74,   -74,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,    67,    68,    72,    73,    74,    75,    76,    77,    78,
+       0,     0,     0,     0,    -5,    -5,    -5,    -5,   162,     0,
+       0,     0,     0,    -5,     2,     0,     0,     0,     0,     0,
+       0,   -70,     0,    -5,    -5,    -5,    -5,    -5,    -5,    -5,
+      -5,    -5,    -5,     0,     0,     0,     0,     0,    -5,    -5,
+      -5,   175,     0,     0,     0,     0,    -5,     2,     0,     0,
+       0,     0,     0,     0,   -56,     0,    -5,    -5,    -5,    -5,
+      -5,    -5,    -5,    -5,    -5,    -5,     0,     0,     0,     0,
+       0,    -5,    -5,    -5,     0,     0,     0,     0,     0,    -5,
+       2,     0,     0,     0,     0,     0,     1,   -39,    -5,    -5,
+      -5,    -5,    -5,    -5,    -5,    -5,     0,     0,   215,    57,
+      58,    59,    60,    61,    62,    63,    64,    65,    66,     0,
+       0,    -5,    -5,   216,   179,    67,    68,     0,     0,     0,
+       0,     0,   180,     0,     0,     2,     0,     3,     0,     0,
+       0,     0,   -13,    72,    73,    74,    75,    76,    77,    78,
       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,     0,   101,    72,    73,    74,    75,    76,    77,
+      99,   100,     0,   111,   -13,     1,     0,    -5,    -5,    -5,
+      -5,    -5,    -5,    -5,    -5,     0,   112,   215,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,     0,     0,
+      -5,    -5,     0,   179,    67,    68,     0,     0,     0,     0,
+       0,   180,     0,     0,     2,     0,     3,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,     0,   209,     0,     0,
+       0,   -76,   -76,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,    67,    68,    72,    73,    74,    75,    76,    77,
       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,     0,   103,    72,    73,    74,    75,    76,
+      98,    99,   100,     0,   101,    72,    73,    74,    75,    76,
       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,     0,   105,    72,    73,    74,    75,
+      97,    98,    99,   100,     0,   103,    72,    73,    74,    75,
       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,     0,   107,    72,    73,    74,
+      96,    97,    98,    99,   100,     0,   105,    72,    73,    74,
       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,     0,   132,    72,    73,
+      95,    96,    97,    98,    99,   100,     0,   107,    72,    73,
       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      94,    95,    96,    97,    98,    99,   100,     0,   193,    72,
+      94,    95,    96,    97,    98,    99,   100,     0,   132,    72,
       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,     0,   208,
+      93,    94,    95,    96,    97,    98,    99,   100,     0,   194,
       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
       92,    93,    94,    95,    96,    97,    98,    99,   100,     0,
-     258,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-      66,     0,     0,     0,     0,     0,   179,    67,    68,     0,
-       0,     0,     0,     0,   180,   214,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,     0,     0,     0,     0,
-     215,     0,    67,    68,   214,    57,    58,    59,    60,    61,
-      62,    63,    64,    65,    66,     0,     0,     0,     0,     0,
-       0,    67,    68,    57,    58,    59,    60,    61,    62,    63,
-      64,    65,    66,     0,     0,     0,     0,     0,     0,    67,
-      68
+     209,    72,    73,    74,    75,    76,    77,    78,    79,    80,
+      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
+      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+       0,   260,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,     0,     0,     0,     0,     0,   179,    67,    68,
+       0,     0,     0,     0,     0,   180
 };
 
 static const yytype_int16 yycheck[] =
 {
-      17,   176,    42,    43,    44,    45,   114,    14,    48,   117,
-      40,   119,   179,   149,   178,   140,   196,    32,    41,    33,
-     128,    12,    13,    12,    43,   213,    33,    50,    34,    12,
-       1,    50,   140,    32,    33,    49,   211,   204,    53,     9,
-      11,   149,   167,   207,   224,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    46,   244,    46,   225,   167,
-     227,    32,    33,    46,    71,     3,    36,    32,    32,    40,
-     206,   230,   180,    48,     0,    50,   146,    48,    45,    50,
-      32,    33,    33,    35,    48,    50,    40,   254,    26,    27,
-     160,   250,   109,   110,    37,    38,    48,    45,   206,    45,
-     130,   131,     1,   270,     3,     4,     5,     6,     7,     8,
-       9,    10,    28,    29,    24,   122,    32,    33,    34,    35,
-      36,   138,    32,    33,    37,    38,    51,    26,    27,    51,
-      53,    46,   172,   163,     4,     5,     6,     7,     8,     9,
-      10,    40,    46,    42,   161,   185,   176,    33,    47,    46,
-      13,   168,    46,    33,    49,    47,   173,    50,   266,    32,
-     190,   178,    46,    46,    52,   195,    47,    45,    50,   277,
-     187,    47,    46,    33,    45,    47,    11,    45,    47,   196,
-      45,   211,    49,    47,    45,   215,    48,    45,    47,    45,
-     207,    45,    14,    48,   234,    52,   213,    50,   211,   215,
-     277,   256,   264,     3,    -1,   245,    -1,   224,    -1,    -1,
-      -1,    -1,    -1,   230,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   263,   254,   242,   266,   244,    -1,    -1,
-      -1,    -1,    -1,   250,    -1,    -1,   276,   277,    -1,    -1,
-     270,    -1,    -1,    -1,    -1,     1,     0,     1,   265,     3,
-       4,     5,     6,     7,     8,     9,    10,    -1,    -1,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      -1,    -1,    26,    27,    30,    31,    32,    33,    -1,     1,
-      -1,    -1,    -1,    39,    40,    -1,    40,    -1,    42,    -1,
-      -1,    47,    -1,    47,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    -1,    -1,    -1,    -1,    -1,    31,
-      32,    33,     1,    -1,    -1,    -1,    -1,    39,    40,    -1,
-      -1,    -1,    -1,    -1,    -1,    47,    -1,    16,    17,    18,
+      17,    42,    43,    44,    45,   114,    14,    48,   117,   149,
+     119,   182,   191,    40,   176,    12,    13,    12,    12,   128,
+     214,   146,    43,    41,   178,    33,    45,   197,   140,    50,
+       9,   140,    50,   212,    34,   160,     3,   216,     0,     1,
+     149,     3,     4,     5,     6,     7,     8,     9,    10,    46,
+     212,    46,    46,   247,   208,   167,   226,    36,   167,    26,
+      27,   232,    32,    71,    26,    27,   231,   207,    32,    32,
+      33,   180,    32,    33,    33,    35,    37,    38,    40,    32,
+      42,   256,    48,    53,    50,    47,    50,   252,    48,     0,
+      49,    24,   109,   110,    33,    48,    40,   272,   207,    32,
+      33,    28,    29,   130,   131,    32,    33,    34,    35,    36,
+      45,    37,    38,    45,   122,    51,    46,    51,    46,    33,
+      13,   138,     4,     5,     6,     7,     8,     9,    10,    53,
+      46,   172,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    46,    33,   161,   186,    49,    47,    32,    33,
+      46,   168,    50,    32,    46,   182,   173,    52,    47,   268,
+      45,   178,    50,    46,   191,    52,    47,    47,    45,   196,
+     279,   188,    47,    49,    45,    45,    48,    45,    47,    33,
+     197,    45,    47,    45,    45,   212,    11,    14,    48,   216,
+     217,   208,    50,   216,   279,   236,   212,   214,   258,   266,
+       3,    -1,    -1,    -1,    -1,   232,    -1,   248,    -1,   226,
+      -1,    -1,    -1,    -1,   231,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   265,    -1,    -1,   268,   245,   256,
+     247,    -1,    -1,    -1,    -1,   252,     1,   278,   279,    -1,
+      -1,    -1,    -1,    -1,    -1,   272,    11,    -1,    -1,    -1,
+     267,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,    -1,
+      -1,    -1,     1,    -1,    39,    40,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    -1,    50,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    -1,    -1,    -1,
-      -1,    -1,    31,    32,    33,     1,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,     1,    -1,    -1,    -1,    -1,
       39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    47,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      -1,    -1,    -1,    -1,    30,    -1,    32,    33,    -1,    -1,
-      -1,    -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,
-      -1,    47,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    -1,    33,     0,     1,    -1,     3,     4,     5,     6,
-       7,     8,     9,    10,    -1,    46,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    -1,    -1,    26,
-      27,    30,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,
-      39,    -1,    -1,    40,    -1,    42,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    -1,    33,    -1,    -1,    -1,
-      37,    38,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,     3,     4,     5,     6,     7,     8,     9,
+      -1,    -1,    -1,    -1,    30,    31,    32,    33,     1,    -1,
+      -1,    -1,    -1,    39,    40,    -1,    -1,    -1,    -1,    -1,
+      -1,    47,    -1,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    -1,    -1,    -1,    -1,    -1,    31,    32,
+      33,     1,    -1,    -1,    -1,    -1,    39,    40,    -1,    -1,
+      -1,    -1,    -1,    -1,    47,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    31,    32,    33,    -1,    -1,    -1,    -1,    -1,    39,
+      40,    -1,    -1,    -1,    -1,    -1,     1,    47,     3,     4,
+       5,     6,     7,     8,     9,    10,    -1,    -1,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    -1,
+      -1,    26,    27,    30,    31,    32,    33,    -1,    -1,    -1,
+      -1,    -1,    39,    -1,    -1,    40,    -1,    42,    -1,    -1,
+      -1,    -1,    47,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    -1,    33,     0,     1,    -1,     3,     4,     5,
+       6,     7,     8,     9,    10,    -1,    46,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    -1,    -1,
+      26,    27,    -1,    31,    32,    33,    -1,    -1,    -1,    -1,
+      -1,    39,    -1,    -1,    40,    -1,    42,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    -1,    33,    -1,    -1,
+      -1,    37,    38,     3,     4,     5,     6,     7,     8,     9,
       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    -1,    33,     3,     4,     5,     6,     7,     8,
+      30,    31,    32,    33,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    -1,    33,     3,     4,     5,     6,     7,
@@ -955,15 +1000,12 @@ static const yytype_int16 yycheck[] =
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
-      33,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,    -1,
-      -1,    -1,    -1,    -1,    39,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      30,    -1,    32,    33,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,    -1,
-      -1,    32,    33,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    -1,    -1,    -1,    -1,    -1,    -1,    32,
-      33
+      33,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      -1,    33,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,
+      -1,    -1,    -1,    -1,    -1,    39
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -971,33 +1013,34 @@ static const yytype_int16 yycheck[] =
 static const yytype_uint8 yystos[] =
 {
        0,     1,    40,    42,    55,    56,    57,    58,    45,    34,
-     116,   117,   117,     0,    59,     3,    26,    27,    62,    63,
-      66,    67,    75,    76,    81,    82,    95,    96,   104,   105,
-     107,   118,   120,    61,   116,    41,    50,    43,    58,    33,
+     117,   118,   118,     0,    59,     3,    26,    27,    62,    63,
+      66,    67,    76,    77,    82,    83,    96,    97,   105,   106,
+     108,   119,   121,    61,   117,    41,    50,    43,    58,    33,
       57,    60,     4,     5,     6,     7,     8,     9,    10,    65,
-      74,    80,    94,   106,    58,   116,    64,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    32,    33,   114,
-     115,    45,     3,     4,     5,     6,     7,     8,     9,    10,
+      75,    81,    95,   107,    58,   117,    64,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    32,    33,   115,
+     116,    45,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    33,   121,    33,   121,    33,   121,    33,   121,    51,
-      51,    33,    46,   121,    12,    69,    77,    12,    84,    12,
-      99,   108,    46,    53,    33,    32,    53,    33,    49,    58,
-      57,    57,    33,   109,   110,   121,   114,    68,    46,   114,
-      13,    85,    24,    98,   114,    97,    46,    58,    33,    49,
-      28,    29,    34,    35,    36,   114,   119,   115,   115,    47,
-      50,    46,     1,    57,    78,    98,    83,    50,    46,   109,
-      47,   119,    52,    50,   109,     1,    57,    70,    45,    31,
-      39,    71,    72,    79,    87,   115,    47,    46,    98,     1,
-      57,   100,    47,    33,   121,    57,    45,    73,    87,    47,
-      78,    71,   115,    35,    48,   114,    49,    45,    33,   121,
-       1,    57,    86,    45,    15,    30,    88,    89,    90,   101,
-     115,    47,   115,    70,    45,    48,    71,    48,   119,    78,
-      45,    87,    90,    93,   115,    47,   100,    88,    37,    38,
-       1,    11,   111,   112,    45,    52,    70,    71,    71,    86,
-      45,    37,    38,    48,    57,    48,    50,   100,    33,   121,
-      86,    92,    71,   115,    91,   111,    14,   113,   121,   113,
-      57,   102,   103,   114,   121,    71,   115,    50,   121,   102
+      31,    33,   122,    33,   122,    33,   122,    33,   122,    51,
+      51,    33,    46,   122,    12,    69,    78,    12,    85,    12,
+     100,   109,    46,    53,    33,    32,    53,    33,    49,    58,
+      57,    57,    33,   110,   111,   122,   115,    68,    46,   115,
+      13,    86,    24,    99,   115,    98,    46,    58,    33,    49,
+      28,    29,    34,    35,    36,   115,   120,   116,   116,    47,
+      50,    46,     1,    57,    79,    99,    84,    50,    46,   110,
+      47,   120,    52,    50,   110,     1,    57,    70,    45,    31,
+      39,    71,    72,    73,    80,    88,   116,    47,    46,    99,
+       1,    57,   101,    47,    33,   122,    57,    45,    74,    88,
+      47,    79,    35,    48,   115,    71,   116,    49,    45,    33,
+     122,     1,    57,    87,    45,    15,    30,    72,    89,    90,
+      91,   102,   116,    47,   116,    70,    45,    48,    48,   120,
+      79,    45,    72,    88,    91,    94,   116,    47,   101,    89,
+     116,    37,    38,     1,    11,   112,   113,    45,    52,    70,
+      87,   116,    45,    37,    38,    48,    57,    48,    50,   101,
+      33,   122,    87,    93,    73,   116,    92,   112,    14,   114,
+     122,   114,    57,   103,   104,   115,   122,    73,   116,    50,
+     122,   103
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -1071,7 +1114,7 @@ while (YYID (0))
    we won't break user code: when these are the locations we know.  */
 
 #ifndef YY_LOCATION_PRINT
-# if YYLTYPE_IS_TRIVIAL
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 #  define YY_LOCATION_PRINT(File, Loc)			\
      fprintf (File, "%d.%d-%d.%d",			\
 	      (Loc).first_line, (Loc).first_column,	\
@@ -1182,20 +1225,17 @@ yy_symbol_print (yyoutput, yytype, yyvaluep)
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 #else
 static void
-yy_stack_print (yybottom, yytop)
-    yytype_int16 *yybottom;
-    yytype_int16 *yytop;
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
 #endif
 {
   YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
   YYFPRINTF (stderr, "\n");
 }
 
@@ -1229,11 +1269,11 @@ yy_reduce_print (yyvsp, yyrule)
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      fprintf (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 		       &(yyvsp[(yyi + 1) - (yynrhs)])
 		       		       );
-      YYFPRINTF (stderr, "\n");
+      fprintf (stderr, "\n");
     }
 }
 
@@ -1513,8 +1553,10 @@ yydestruct (yymsg, yytype, yyvaluep)
 	break;
     }
 }
+
 
 /* Prevent warnings from -Wmissing-prototypes.  */
+
 #ifdef YYPARSE_PARAM
 #if defined __STDC__ || defined __cplusplus
 int yyparse (void *YYPARSE_PARAM);
@@ -1533,9 +1575,10 @@ int yyparse ();
 
 
 
-/*-------------------------.
-| yyparse or yypush_parse.  |
-`-------------------------*/
+
+/*----------.
+| yyparse.  |
+`----------*/
 
 #ifdef YYPARSE_PARAM
 #if (defined __STDC__ || defined __C99__FUNC__ \
@@ -1559,46 +1602,22 @@ yyparse ()
 #endif
 #endif
 {
-/* The lookahead symbol.  */
+  /* The look-ahead symbol.  */
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
-    /* Number of syntax errors so far.  */
-    int yynerrs;
-
-    int yystate;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       `yyss': related to states.
-       `yyvs': related to semantic values.
-
-       Refer to the stacks thru separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* The state stack.  */
-    yytype_int16 yyssa[YYINITDEPTH];
-    yytype_int16 *yyss;
-    yytype_int16 *yyssp;
-
-    /* The semantic value stack.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
-
-    YYSIZE_T yystacksize;
+/* Number of syntax errors so far.  */
+int yynerrs;
 
+  int yystate;
   int yyn;
   int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];
@@ -1606,28 +1625,51 @@ YYSTYPE yylval;
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
 
-  yytoken = 0;
-  yyss = yyssa;
-  yyvs = yyvsa;
-  yystacksize = YYINITDEPTH;
-
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
+
   yyssp = yyss;
   yyvsp = yyvs;
 
@@ -1657,6 +1699,7 @@ YYSTYPE yylval;
 	YYSTYPE *yyvs1 = yyvs;
 	yytype_int16 *yyss1 = yyss;
 
+
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
@@ -1664,6 +1707,7 @@ YYSTYPE yylval;
 	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
+
 		    &yystacksize);
 
 	yyss = yyss1;
@@ -1686,8 +1730,9 @@ YYSTYPE yylval;
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
 	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss_alloc, yyss);
-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
 #  undef YYSTACK_RELOCATE
 	if (yyss1 != yyssa)
 	  YYSTACK_FREE (yyss1);
@@ -1698,6 +1743,7 @@ YYSTYPE yylval;
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
+
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
@@ -1707,9 +1753,6 @@ YYSTYPE yylval;
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
   goto yybackup;
 
 /*-----------.
@@ -1718,16 +1761,16 @@ YYSTYPE yylval;
 yybackup:
 
   /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
+     look-ahead token if we need one and don't already have one.  */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
@@ -1759,16 +1802,20 @@ yybackup:
       goto yyreduce;
     }
 
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
-  /* Shift the lookahead token.  */
+  /* Shift the look-ahead token.  */
   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
 
   yystate = yyn;
   *++yyvsp = yylval;
@@ -1808,16 +1855,12 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-
-/* Line 1455 of yacc.c  */
 #line 108 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 3:
-
-/* Line 1455 of yacc.c  */
 #line 116 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (3)]);
@@ -1825,8 +1868,6 @@ yyreduce:
     break;
 
   case 4:
-
-/* Line 1455 of yacc.c  */
 #line 125 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (3)]);
@@ -1834,8 +1875,6 @@ yyreduce:
     break;
 
   case 5:
-
-/* Line 1455 of yacc.c  */
 #line 129 "../Slice/Grammar.y"
     {
     (yyval) = new StringListTok;
@@ -1843,8 +1882,6 @@ yyreduce:
     break;
 
   case 6:
-
-/* Line 1455 of yacc.c  */
 #line 138 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -1856,8 +1893,6 @@ yyreduce:
     break;
 
   case 8:
-
-/* Line 1455 of yacc.c  */
 #line 147 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (2)]));
@@ -1870,8 +1905,6 @@ yyreduce:
     break;
 
   case 10:
-
-/* Line 1455 of yacc.c  */
 #line 157 "../Slice/Grammar.y"
     {
     yyerrok;
@@ -1879,8 +1912,6 @@ yyreduce:
     break;
 
   case 12:
-
-/* Line 1455 of yacc.c  */
 #line 162 "../Slice/Grammar.y"
     {
     unit->error("`;' missing after definition");
@@ -1888,16 +1919,12 @@ yyreduce:
     break;
 
   case 13:
-
-/* Line 1455 of yacc.c  */
 #line 166 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 14:
-
-/* Line 1455 of yacc.c  */
 #line 174 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ModulePtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1905,8 +1932,6 @@ yyreduce:
     break;
 
   case 15:
-
-/* Line 1455 of yacc.c  */
 #line 178 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ClassDeclPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1914,8 +1939,6 @@ yyreduce:
     break;
 
   case 16:
-
-/* Line 1455 of yacc.c  */
 #line 182 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ClassDefPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1923,8 +1946,6 @@ yyreduce:
     break;
 
   case 17:
-
-/* Line 1455 of yacc.c  */
 #line 186 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ClassDeclPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1932,8 +1953,6 @@ yyreduce:
     break;
 
   case 18:
-
-/* Line 1455 of yacc.c  */
 #line 190 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ClassDefPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1941,8 +1960,6 @@ yyreduce:
     break;
 
   case 19:
-
-/* Line 1455 of yacc.c  */
 #line 194 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0);
@@ -1950,8 +1967,6 @@ yyreduce:
     break;
 
   case 20:
-
-/* Line 1455 of yacc.c  */
 #line 198 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ExceptionPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1959,8 +1974,6 @@ yyreduce:
     break;
 
   case 21:
-
-/* Line 1455 of yacc.c  */
 #line 202 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0);
@@ -1968,8 +1981,6 @@ yyreduce:
     break;
 
   case 22:
-
-/* Line 1455 of yacc.c  */
 #line 206 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || StructPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1977,8 +1988,6 @@ yyreduce:
     break;
 
   case 23:
-
-/* Line 1455 of yacc.c  */
 #line 210 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || SequencePtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1986,8 +1995,6 @@ yyreduce:
     break;
 
   case 24:
-
-/* Line 1455 of yacc.c  */
 #line 214 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || DictionaryPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -1995,8 +2002,6 @@ yyreduce:
     break;
 
   case 25:
-
-/* Line 1455 of yacc.c  */
 #line 218 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || EnumPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -2004,8 +2009,6 @@ yyreduce:
     break;
 
   case 26:
-
-/* Line 1455 of yacc.c  */
 #line 222 "../Slice/Grammar.y"
     {
     assert((yyvsp[(1) - (1)]) == 0 || ConstPtr::dynamicCast((yyvsp[(1) - (1)])));
@@ -2013,8 +2016,6 @@ yyreduce:
     break;
 
   case 27:
-
-/* Line 1455 of yacc.c  */
 #line 231 "../Slice/Grammar.y"
     {
     unit->setSeenDefinition();
@@ -2035,8 +2036,6 @@ yyreduce:
     break;
 
   case 28:
-
-/* Line 1455 of yacc.c  */
 #line 248 "../Slice/Grammar.y"
     {
     if((yyvsp[(3) - (6)]))
@@ -2052,8 +2051,6 @@ yyreduce:
     break;
 
   case 29:
-
-/* Line 1455 of yacc.c  */
 #line 265 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
@@ -2061,8 +2058,6 @@ yyreduce:
     break;
 
   case 30:
-
-/* Line 1455 of yacc.c  */
 #line 269 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -2072,8 +2067,6 @@ yyreduce:
     break;
 
   case 31:
-
-/* Line 1455 of yacc.c  */
 #line 280 "../Slice/Grammar.y"
     {
     unit->error("exceptions cannot be forward declared");
@@ -2082,8 +2075,6 @@ yyreduce:
     break;
 
   case 32:
-
-/* Line 1455 of yacc.c  */
 #line 290 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (3)]));
@@ -2101,8 +2092,6 @@ yyreduce:
     break;
 
   case 33:
-
-/* Line 1455 of yacc.c  */
 #line 304 "../Slice/Grammar.y"
     {
     if((yyvsp[(4) - (7)]))
@@ -2114,8 +2103,6 @@ yyreduce:
     break;
 
   case 34:
-
-/* Line 1455 of yacc.c  */
 #line 317 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -2127,8 +2114,6 @@ yyreduce:
     break;
 
   case 35:
-
-/* Line 1455 of yacc.c  */
 #line 325 "../Slice/Grammar.y"
     {
     (yyval) = 0;
@@ -2136,8 +2121,6 @@ yyreduce:
     break;
 
   case 36:
-
-/* Line 1455 of yacc.c  */
 #line 334 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (4)]));
@@ -2150,16 +2133,12 @@ yyreduce:
     break;
 
   case 37:
-
-/* Line 1455 of yacc.c  */
 #line 343 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 38:
-
-/* Line 1455 of yacc.c  */
 #line 346 "../Slice/Grammar.y"
     {
     unit->error("`;' missing after definition");
@@ -2167,16 +2146,12 @@ yyreduce:
     break;
 
   case 39:
-
-/* Line 1455 of yacc.c  */
 #line 350 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 40:
-
-/* Line 1455 of yacc.c  */
 #line 358 "../Slice/Grammar.y"
     {
     TypePtr type = TypePtr::dynamicCast((yyvsp[(1) - (2)]));
@@ -2188,17 +2163,14 @@ yyreduce:
     break;
 
   case 41:
-
-/* Line 1455 of yacc.c  */
 #line 371 "../Slice/Grammar.y"
     {
-    IntegerTokPtr i = IntegerTokPtr::dynamicCast((yyvsp[(2) - (4)]));
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(4) - (4)]));
+    IntegerTokPtr i = IntegerTokPtr::dynamicCast((yyvsp[(2) - (3)]));
 
     int tag;
     if(i->v < 0 || i->v > Int32Max)
     {
-        unit->error("tag for optional member `" + ts->v.second + "' is out of range");
+        unit->error("tag for optional is out of range");
         tag = -1;
     }
     else
@@ -2206,9 +2178,7 @@ yyreduce:
         tag = static_cast<int>(i->v);
     }
 
-    DataMemberDefTokPtr m = new DataMemberDefTok;
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.optional = tag >= 0;
     m->v.tag = tag;
     (yyval) = m;
@@ -2216,12 +2186,9 @@ yyreduce:
     break;
 
   case 42:
-
-/* Line 1455 of yacc.c  */
-#line 394 "../Slice/Grammar.y"
+#line 391 "../Slice/Grammar.y"
     {
-    StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(2) - (4)]));
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(4) - (4)]));
+    StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(2) - (3)]));
 
     ContainerPtr cont = unit->currentContainer();
     assert(cont);
@@ -2250,7 +2217,7 @@ yyreduce:
                 IceUtil::Int64 l = IceUtilInternal::strToInt64(constant->value().c_str(), 0, 0);
                 if(l < 0 || l > Int32Max)
                 {
-                    unit->error("tag for optional member `" + ts->v.second + "' is out of range");
+                    unit->error("tag for optional is out of range");
                 }
                 tag = static_cast<int>(l);
                 break;
@@ -2281,12 +2248,10 @@ yyreduce:
 
     if(tag < 0)
     {
-        unit->error("invalid tag `" + scoped->v + "' for optional member `" + ts->v.second + "'");
+        unit->error("invalid tag `" + scoped->v + "' for optional");
     }
 
-    DataMemberDefTokPtr m = new DataMemberDefTok;
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.optional = tag >= 0;
     m->v.tag = tag;
     (yyval) = m;
@@ -2294,15 +2259,10 @@ yyreduce:
     break;
 
   case 43:
-
-/* Line 1455 of yacc.c  */
-#line 467 "../Slice/Grammar.y"
+#line 461 "../Slice/Grammar.y"
     {
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(3) - (3)]));
-    unit->error("missing tag for optional member `" + ts->v.second + "'");
-    DataMemberDefTokPtr m = new DataMemberDefTok; // Dummy
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    unit->error("missing tag for optional");
+    OptionalDefTokPtr m = new OptionalDefTok; // Dummy
     m->v.optional = false;
     m->v.tag = -1;
     (yyval) = m;
@@ -2310,15 +2270,10 @@ yyreduce:
     break;
 
   case 44:
-
-/* Line 1455 of yacc.c  */
-#line 478 "../Slice/Grammar.y"
+#line 469 "../Slice/Grammar.y"
     {
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
-    unit->error("missing tag for optional member `" + ts->v.second + "'");
-    DataMemberDefTokPtr m = new DataMemberDefTok; // Dummy
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    unit->error("missing tag for optional");
+    OptionalDefTokPtr m = new OptionalDefTok; // Dummy
     m->v.optional = false;
     m->v.tag = -1;
     (yyval) = m;
@@ -2326,12 +2281,21 @@ yyreduce:
     break;
 
   case 45:
+#line 482 "../Slice/Grammar.y"
+    {
+    OptionalDefTokPtr m = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (2)]));
+    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
+    m->v.type = ts->v.first;
+    m->v.name = ts->v.second;
+    (yyval) = m;
+;}
+    break;
 
-/* Line 1455 of yacc.c  */
-#line 489 "../Slice/Grammar.y"
+  case 46:
+#line 490 "../Slice/Grammar.y"
     {
     TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
-    DataMemberDefTokPtr m = new DataMemberDefTok;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.type = ts->v.first;
     m->v.name = ts->v.second;
     m->v.optional = false;
@@ -2340,19 +2304,15 @@ yyreduce:
 ;}
     break;
 
-  case 47:
-
-/* Line 1455 of yacc.c  */
-#line 510 "../Slice/Grammar.y"
+  case 48:
+#line 511 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 48:
-
-/* Line 1455 of yacc.c  */
-#line 514 "../Slice/Grammar.y"
+  case 49:
+#line 515 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     unit->error("keyword `" + ident->v + "' cannot be used as struct name");
@@ -2360,20 +2320,16 @@ yyreduce:
 ;}
     break;
 
-  case 49:
-
-/* Line 1455 of yacc.c  */
-#line 525 "../Slice/Grammar.y"
+  case 50:
+#line 526 "../Slice/Grammar.y"
     {
     unit->error("structs cannot be forward declared");
     (yyval) = 0; // Dummy
 ;}
     break;
 
-  case 50:
-
-/* Line 1455 of yacc.c  */
-#line 535 "../Slice/Grammar.y"
+  case 51:
+#line 536 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -2388,10 +2344,8 @@ yyreduce:
 ;}
     break;
 
-  case 51:
-
-/* Line 1455 of yacc.c  */
-#line 548 "../Slice/Grammar.y"
+  case 52:
+#line 549 "../Slice/Grammar.y"
     {
     if((yyvsp[(3) - (6)]))
     {
@@ -2411,10 +2365,8 @@ yyreduce:
 ;}
     break;
 
-  case 52:
-
-/* Line 1455 of yacc.c  */
-#line 571 "../Slice/Grammar.y"
+  case 53:
+#line 572 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (4)]));
     ContainedPtr contained = ContainedPtr::dynamicCast((yyvsp[(2) - (4)]));
@@ -2425,44 +2377,34 @@ yyreduce:
 ;}
     break;
 
-  case 53:
-
-/* Line 1455 of yacc.c  */
-#line 580 "../Slice/Grammar.y"
+  case 54:
+#line 581 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 54:
-
-/* Line 1455 of yacc.c  */
-#line 583 "../Slice/Grammar.y"
+  case 55:
+#line 584 "../Slice/Grammar.y"
     {
     unit->error("`;' missing after definition");
 ;}
     break;
 
-  case 55:
-
-/* Line 1455 of yacc.c  */
-#line 587 "../Slice/Grammar.y"
+  case 56:
+#line 588 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 57:
-
-/* Line 1455 of yacc.c  */
-#line 601 "../Slice/Grammar.y"
+  case 58:
+#line 602 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 58:
-
-/* Line 1455 of yacc.c  */
-#line 605 "../Slice/Grammar.y"
+  case 59:
+#line 606 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     unit->error("keyword `" + ident->v + "' cannot be used as class name");
@@ -2470,10 +2412,8 @@ yyreduce:
 ;}
     break;
 
-  case 59:
-
-/* Line 1455 of yacc.c  */
-#line 616 "../Slice/Grammar.y"
+  case 60:
+#line 617 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -2483,10 +2423,8 @@ yyreduce:
 ;}
     break;
 
-  case 60:
-
-/* Line 1455 of yacc.c  */
-#line 629 "../Slice/Grammar.y"
+  case 61:
+#line 630 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (4)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (4)]));
@@ -2511,10 +2449,8 @@ yyreduce:
 ;}
     break;
 
-  case 61:
-
-/* Line 1455 of yacc.c  */
-#line 652 "../Slice/Grammar.y"
+  case 62:
+#line 653 "../Slice/Grammar.y"
     {
     if((yyvsp[(5) - (8)]))
     {
@@ -2528,10 +2464,8 @@ yyreduce:
 ;}
     break;
 
-  case 62:
-
-/* Line 1455 of yacc.c  */
-#line 669 "../Slice/Grammar.y"
+  case 63:
+#line 670 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     ContainerPtr cont = unit->currentContainer();
@@ -2567,37 +2501,29 @@ yyreduce:
 ;}
     break;
 
-  case 63:
-
-/* Line 1455 of yacc.c  */
-#line 703 "../Slice/Grammar.y"
+  case 64:
+#line 704 "../Slice/Grammar.y"
     {
     (yyval) = 0;
 ;}
     break;
 
-  case 64:
-
-/* Line 1455 of yacc.c  */
-#line 712 "../Slice/Grammar.y"
+  case 65:
+#line 713 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 65:
-
-/* Line 1455 of yacc.c  */
-#line 716 "../Slice/Grammar.y"
+  case 66:
+#line 717 "../Slice/Grammar.y"
     {
     (yyval) = new ClassListTok;
 ;}
     break;
 
-  case 66:
-
-/* Line 1455 of yacc.c  */
-#line 725 "../Slice/Grammar.y"
+  case 67:
+#line 726 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (4)]));
     ContainedPtr contained = ContainedPtr::dynamicCast((yyvsp[(2) - (4)]));
@@ -2608,37 +2534,29 @@ yyreduce:
 ;}
     break;
 
-  case 67:
-
-/* Line 1455 of yacc.c  */
-#line 734 "../Slice/Grammar.y"
+  case 68:
+#line 735 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 68:
-
-/* Line 1455 of yacc.c  */
-#line 737 "../Slice/Grammar.y"
+  case 69:
+#line 738 "../Slice/Grammar.y"
     {
     unit->error("`;' missing after definition");
 ;}
     break;
 
-  case 69:
-
-/* Line 1455 of yacc.c  */
-#line 741 "../Slice/Grammar.y"
+  case 70:
+#line 742 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 70:
-
-/* Line 1455 of yacc.c  */
-#line 749 "../Slice/Grammar.y"
+  case 71:
+#line 750 "../Slice/Grammar.y"
     {
-    DataMemberDefTokPtr def = DataMemberDefTokPtr::dynamicCast((yyvsp[(1) - (1)]));
+    OptionalDefTokPtr def = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     DataMemberPtr dm;
     if(cl)
@@ -2660,12 +2578,10 @@ yyreduce:
 ;}
     break;
 
-  case 71:
-
-/* Line 1455 of yacc.c  */
-#line 771 "../Slice/Grammar.y"
+  case 72:
+#line 772 "../Slice/Grammar.y"
     {
-    DataMemberDefTokPtr def = DataMemberDefTokPtr::dynamicCast((yyvsp[(1) - (3)]));
+    OptionalDefTokPtr def = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (3)]));
     ConstDefTokPtr value = ConstDefTokPtr::dynamicCast((yyvsp[(3) - (3)]));
 
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
@@ -2692,10 +2608,8 @@ yyreduce:
 ;}
     break;
 
-  case 72:
-
-/* Line 1455 of yacc.c  */
-#line 798 "../Slice/Grammar.y"
+  case 73:
+#line 799 "../Slice/Grammar.y"
     {
     TypePtr type = TypePtr::dynamicCast((yyvsp[(1) - (2)]));
     string name = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]))->v;
@@ -2719,10 +2633,8 @@ yyreduce:
 ;}
     break;
 
-  case 73:
-
-/* Line 1455 of yacc.c  */
-#line 820 "../Slice/Grammar.y"
+  case 74:
+#line 821 "../Slice/Grammar.y"
     {
     TypePtr type = TypePtr::dynamicCast((yyvsp[(1) - (1)]));
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
@@ -2746,25 +2658,44 @@ yyreduce:
     break;
 
   case 75:
-
-/* Line 1455 of yacc.c  */
 #line 847 "../Slice/Grammar.y"
     {
-    (yyval) = 0;
+    OptionalDefTokPtr m = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (2)]));
+    m->v.type = TypePtr::dynamicCast((yyvsp[(2) - (2)]));
+    (yyval) = m;
 ;}
     break;
 
   case 76:
+#line 853 "../Slice/Grammar.y"
+    {
+    OptionalDefTokPtr m = new OptionalDefTok();
+    m->v.type = TypePtr::dynamicCast((yyvsp[(1) - (1)]));
+    m->v.optional = false;
+    m->v.tag = -1;
+    (yyval) = m;
+;}
+    break;
+
+  case 77:
+#line 861 "../Slice/Grammar.y"
+    {
+    OptionalDefTokPtr m = new OptionalDefTok;
+    m->v.optional = false;
+    m->v.tag = -1;
+    (yyval) = m;
+;}
+    break;
 
-/* Line 1455 of yacc.c  */
-#line 856 "../Slice/Grammar.y"
+  case 78:
+#line 873 "../Slice/Grammar.y"
     {
-    TypePtr returnType = TypePtr::dynamicCast((yyvsp[(1) - (2)]));
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     string name = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]))->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag);
 	if(op)
 	{
 	    cl->checkIntroduced(name, op);
@@ -2783,17 +2714,16 @@ yyreduce:
 ;}
     break;
 
-  case 77:
-
-/* Line 1455 of yacc.c  */
-#line 880 "../Slice/Grammar.y"
+  case 79:
+#line 897 "../Slice/Grammar.y"
     {
-    TypePtr returnType = TypePtr::dynamicCast((yyvsp[(2) - (3)]));
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast((yyvsp[(2) - (3)]));
     string name = StringTokPtr::dynamicCast((yyvsp[(3) - (3)]))->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType, Operation::Idempotent);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag,
+                                              Operation::Idempotent);
 	if(op)
 	{
 	    cl->checkIntroduced(name, op);
@@ -2812,17 +2742,15 @@ yyreduce:
 ;}
     break;
 
-  case 78:
-
-/* Line 1455 of yacc.c  */
-#line 904 "../Slice/Grammar.y"
+  case 80:
+#line 922 "../Slice/Grammar.y"
     {
-    TypePtr returnType = TypePtr::dynamicCast((yyvsp[(1) - (2)]));
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     string name = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]))->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag);
 	if(op)
 	{
 	    unit->pushContainer(op);
@@ -2841,17 +2769,16 @@ yyreduce:
 ;}
     break;
 
-  case 79:
-
-/* Line 1455 of yacc.c  */
-#line 928 "../Slice/Grammar.y"
+  case 81:
+#line 946 "../Slice/Grammar.y"
     {
-    TypePtr returnType = TypePtr::dynamicCast((yyvsp[(2) - (3)]));
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast((yyvsp[(2) - (3)]));
     string name = StringTokPtr::dynamicCast((yyvsp[(3) - (3)]))->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType, Operation::Idempotent);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag,
+                                              Operation::Idempotent);
 	if(op)
 	{
 	    unit->pushContainer(op);
@@ -2870,10 +2797,8 @@ yyreduce:
 ;}
     break;
 
-  case 80:
-
-/* Line 1455 of yacc.c  */
-#line 957 "../Slice/Grammar.y"
+  case 82:
+#line 976 "../Slice/Grammar.y"
     {
     if((yyvsp[(1) - (3)]))
     {
@@ -2887,10 +2812,8 @@ yyreduce:
 ;}
     break;
 
-  case 81:
-
-/* Line 1455 of yacc.c  */
-#line 969 "../Slice/Grammar.y"
+  case 83:
+#line 988 "../Slice/Grammar.y"
     {
     OperationPtr op = OperationPtr::dynamicCast((yyvsp[(4) - (5)]));
     ExceptionListTokPtr el = ExceptionListTokPtr::dynamicCast((yyvsp[(5) - (5)]));
@@ -2902,10 +2825,8 @@ yyreduce:
 ;}
     break;
 
-  case 82:
-
-/* Line 1455 of yacc.c  */
-#line 979 "../Slice/Grammar.y"
+  case 84:
+#line 998 "../Slice/Grammar.y"
     {
     if((yyvsp[(1) - (3)]))
     {
@@ -2915,10 +2836,8 @@ yyreduce:
 ;}
     break;
 
-  case 83:
-
-/* Line 1455 of yacc.c  */
-#line 987 "../Slice/Grammar.y"
+  case 85:
+#line 1006 "../Slice/Grammar.y"
     {
     OperationPtr op = OperationPtr::dynamicCast((yyvsp[(4) - (5)]));
     ExceptionListTokPtr el = ExceptionListTokPtr::dynamicCast((yyvsp[(5) - (5)]));
@@ -2930,19 +2849,15 @@ yyreduce:
 ;}
     break;
 
-  case 86:
-
-/* Line 1455 of yacc.c  */
-#line 1009 "../Slice/Grammar.y"
+  case 88:
+#line 1028 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 87:
-
-/* Line 1455 of yacc.c  */
-#line 1013 "../Slice/Grammar.y"
+  case 89:
+#line 1032 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     unit->error("keyword `" + ident->v + "' cannot be used as interface name");
@@ -2950,10 +2865,8 @@ yyreduce:
 ;}
     break;
 
-  case 88:
-
-/* Line 1455 of yacc.c  */
-#line 1024 "../Slice/Grammar.y"
+  case 90:
+#line 1043 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -2964,10 +2877,8 @@ yyreduce:
 ;}
     break;
 
-  case 89:
-
-/* Line 1455 of yacc.c  */
-#line 1038 "../Slice/Grammar.y"
+  case 91:
+#line 1057 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (3)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (3)]));
@@ -2987,10 +2898,8 @@ yyreduce:
 ;}
     break;
 
-  case 90:
-
-/* Line 1455 of yacc.c  */
-#line 1056 "../Slice/Grammar.y"
+  case 92:
+#line 1075 "../Slice/Grammar.y"
     {
     if((yyvsp[(4) - (7)]))
     {
@@ -3004,10 +2913,8 @@ yyreduce:
 ;}
     break;
 
-  case 91:
-
-/* Line 1455 of yacc.c  */
-#line 1073 "../Slice/Grammar.y"
+  case 93:
+#line 1092 "../Slice/Grammar.y"
     {
     ClassListTokPtr intfs = ClassListTokPtr::dynamicCast((yyvsp[(3) - (3)]));
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (3)]));
@@ -3044,10 +2951,8 @@ yyreduce:
 ;}
     break;
 
-  case 92:
-
-/* Line 1455 of yacc.c  */
-#line 1108 "../Slice/Grammar.y"
+  case 94:
+#line 1127 "../Slice/Grammar.y"
     {
     ClassListTokPtr intfs = new ClassListTok;
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3084,38 +2989,30 @@ yyreduce:
 ;}
     break;
 
-  case 93:
-
-/* Line 1455 of yacc.c  */
-#line 1143 "../Slice/Grammar.y"
+  case 95:
+#line 1162 "../Slice/Grammar.y"
     {
     unit->error("illegal inheritance from type Object");
     (yyval) = new ClassListTok; // Dummy
 ;}
     break;
 
-  case 94:
-
-/* Line 1455 of yacc.c  */
-#line 1153 "../Slice/Grammar.y"
+  case 96:
+#line 1172 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 95:
-
-/* Line 1455 of yacc.c  */
-#line 1157 "../Slice/Grammar.y"
+  case 97:
+#line 1176 "../Slice/Grammar.y"
     {
     (yyval) = new ClassListTok;
 ;}
     break;
 
-  case 96:
-
-/* Line 1455 of yacc.c  */
-#line 1166 "../Slice/Grammar.y"
+  case 98:
+#line 1185 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(1) - (4)]));
     ContainedPtr contained = ContainedPtr::dynamicCast((yyvsp[(2) - (4)]));
@@ -3126,35 +3023,27 @@ yyreduce:
 ;}
     break;
 
-  case 97:
-
-/* Line 1455 of yacc.c  */
-#line 1175 "../Slice/Grammar.y"
+  case 99:
+#line 1194 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 98:
-
-/* Line 1455 of yacc.c  */
-#line 1178 "../Slice/Grammar.y"
+  case 100:
+#line 1197 "../Slice/Grammar.y"
     {
     unit->error("`;' missing after definition");
 ;}
     break;
 
-  case 99:
-
-/* Line 1455 of yacc.c  */
-#line 1182 "../Slice/Grammar.y"
+  case 101:
+#line 1201 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 101:
-
-/* Line 1455 of yacc.c  */
-#line 1196 "../Slice/Grammar.y"
+  case 103:
+#line 1215 "../Slice/Grammar.y"
     {
     ExceptionPtr exception = ExceptionPtr::dynamicCast((yyvsp[(1) - (3)]));
     ExceptionListTokPtr exceptionList = ExceptionListTokPtr::dynamicCast((yyvsp[(3) - (3)]));
@@ -3163,10 +3052,8 @@ yyreduce:
 ;}
     break;
 
-  case 102:
-
-/* Line 1455 of yacc.c  */
-#line 1203 "../Slice/Grammar.y"
+  case 104:
+#line 1222 "../Slice/Grammar.y"
     {
     ExceptionPtr exception = ExceptionPtr::dynamicCast((yyvsp[(1) - (1)]));
     ExceptionListTokPtr exceptionList = new ExceptionListTok;
@@ -3175,10 +3062,8 @@ yyreduce:
 ;}
     break;
 
-  case 103:
-
-/* Line 1455 of yacc.c  */
-#line 1215 "../Slice/Grammar.y"
+  case 105:
+#line 1234 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     ContainerPtr cont = unit->currentContainer();
@@ -3192,10 +3077,8 @@ yyreduce:
 ;}
     break;
 
-  case 104:
-
-/* Line 1455 of yacc.c  */
-#line 1227 "../Slice/Grammar.y"
+  case 106:
+#line 1246 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     unit->error("keyword `" + ident->v + "' cannot be used as exception name");
@@ -3203,10 +3086,8 @@ yyreduce:
 ;}
     break;
 
-  case 105:
-
-/* Line 1455 of yacc.c  */
-#line 1238 "../Slice/Grammar.y"
+  case 107:
+#line 1257 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (7)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(7) - (7)]));
@@ -3217,10 +3098,8 @@ yyreduce:
 ;}
     break;
 
-  case 106:
-
-/* Line 1455 of yacc.c  */
-#line 1247 "../Slice/Grammar.y"
+  case 108:
+#line 1266 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (7)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(7) - (7)]));
@@ -3232,10 +3111,8 @@ yyreduce:
 ;}
     break;
 
-  case 107:
-
-/* Line 1455 of yacc.c  */
-#line 1262 "../Slice/Grammar.y"
+  case 109:
+#line 1281 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (10)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(10) - (10)]));
@@ -3248,10 +3125,8 @@ yyreduce:
 ;}
     break;
 
-  case 108:
-
-/* Line 1455 of yacc.c  */
-#line 1273 "../Slice/Grammar.y"
+  case 110:
+#line 1292 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (10)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(10) - (10)]));
@@ -3265,19 +3140,15 @@ yyreduce:
 ;}
     break;
 
-  case 109:
-
-/* Line 1455 of yacc.c  */
-#line 1290 "../Slice/Grammar.y"
+  case 111:
+#line 1309 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 110:
-
-/* Line 1455 of yacc.c  */
-#line 1294 "../Slice/Grammar.y"
+  case 112:
+#line 1313 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     unit->error("keyword `" + ident->v + "' cannot be used as enumeration name");
@@ -3285,10 +3156,8 @@ yyreduce:
 ;}
     break;
 
-  case 111:
-
-/* Line 1455 of yacc.c  */
-#line 1305 "../Slice/Grammar.y"
+  case 113:
+#line 1324 "../Slice/Grammar.y"
     {
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -3299,10 +3168,8 @@ yyreduce:
 ;}
     break;
 
-  case 112:
-
-/* Line 1455 of yacc.c  */
-#line 1314 "../Slice/Grammar.y"
+  case 114:
+#line 1333 "../Slice/Grammar.y"
     {
     EnumPtr en = EnumPtr::dynamicCast((yyvsp[(3) - (6)]));
     if(en)
@@ -3318,10 +3185,8 @@ yyreduce:
 ;}
     break;
 
-  case 113:
-
-/* Line 1455 of yacc.c  */
-#line 1329 "../Slice/Grammar.y"
+  case 115:
+#line 1348 "../Slice/Grammar.y"
     {
     unit->error("missing enumeration name");
     BoolTokPtr local = BoolTokPtr::dynamicCast((yyvsp[(1) - (5)]));
@@ -3333,10 +3198,8 @@ yyreduce:
 ;}
     break;
 
-  case 114:
-
-/* Line 1455 of yacc.c  */
-#line 1344 "../Slice/Grammar.y"
+  case 116:
+#line 1363 "../Slice/Grammar.y"
     {
     EnumeratorListTokPtr ens = EnumeratorListTokPtr::dynamicCast((yyvsp[(1) - (3)]));
     ens->v.splice(ens->v.end(), EnumeratorListTokPtr::dynamicCast((yyvsp[(3) - (3)]))->v);
@@ -3344,18 +3207,14 @@ yyreduce:
 ;}
     break;
 
-  case 115:
-
-/* Line 1455 of yacc.c  */
-#line 1350 "../Slice/Grammar.y"
+  case 117:
+#line 1369 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 116:
-
-/* Line 1455 of yacc.c  */
-#line 1358 "../Slice/Grammar.y"
+  case 118:
+#line 1377 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     EnumeratorListTokPtr ens = new EnumeratorListTok;
@@ -3369,10 +3228,8 @@ yyreduce:
 ;}
     break;
 
-  case 117:
-
-/* Line 1455 of yacc.c  */
-#line 1370 "../Slice/Grammar.y"
+  case 119:
+#line 1389 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     unit->error("keyword `" + ident->v + "' cannot be used as enumerator");
@@ -3381,20 +3238,16 @@ yyreduce:
 ;}
     break;
 
-  case 118:
-
-/* Line 1455 of yacc.c  */
-#line 1377 "../Slice/Grammar.y"
+  case 120:
+#line 1396 "../Slice/Grammar.y"
     {
     EnumeratorListTokPtr ens = new EnumeratorListTok;
     (yyval) = ens; // Dummy
 ;}
     break;
 
-  case 119:
-
-/* Line 1455 of yacc.c  */
-#line 1387 "../Slice/Grammar.y"
+  case 121:
+#line 1406 "../Slice/Grammar.y"
     {
     BoolTokPtr out = new BoolTok;
     out->v = true;
@@ -3402,10 +3255,8 @@ yyreduce:
 ;}
     break;
 
-  case 120:
-
-/* Line 1455 of yacc.c  */
-#line 1393 "../Slice/Grammar.y"
+  case 122:
+#line 1412 "../Slice/Grammar.y"
     {
     BoolTokPtr out = new BoolTok;
     out->v = false;
@@ -3413,28 +3264,22 @@ yyreduce:
 ;}
     break;
 
-  case 121:
-
-/* Line 1455 of yacc.c  */
-#line 1404 "../Slice/Grammar.y"
+  case 123:
+#line 1423 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 122:
-
-/* Line 1455 of yacc.c  */
-#line 1407 "../Slice/Grammar.y"
+  case 124:
+#line 1426 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(1) - (3)]));
-    TypeStringTokPtr tsp = TypeStringTokPtr::dynamicCast((yyvsp[(3) - (3)]));
-    TypePtr type = tsp->v.first;
-    string ident = tsp->v.second;
+    OptionalDefTokPtr tsp = OptionalDefTokPtr::dynamicCast((yyvsp[(3) - (3)]));
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	ParamDeclPtr pd = op->createParamDecl(ident, type, isOutParam->v);
-	unit->currentContainer()->checkIntroduced(ident, pd);
+	ParamDeclPtr pd = op->createParamDecl(tsp->v.name, tsp->v.type, isOutParam->v, tsp->v.optional, tsp->v.tag);
+	unit->currentContainer()->checkIntroduced(tsp->v.name, pd);
         StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(2) - (3)]));
         if(!metaData->v.empty())
         {
@@ -3444,20 +3289,16 @@ yyreduce:
 ;}
     break;
 
-  case 123:
-
-/* Line 1455 of yacc.c  */
-#line 1425 "../Slice/Grammar.y"
+  case 125:
+#line 1442 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(3) - (5)]));
-    TypeStringTokPtr tsp = TypeStringTokPtr::dynamicCast((yyvsp[(5) - (5)]));
-    TypePtr type = tsp->v.first;
-    string ident = tsp->v.second;
+    OptionalDefTokPtr tsp = OptionalDefTokPtr::dynamicCast((yyvsp[(5) - (5)]));
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	ParamDeclPtr pd = op->createParamDecl(ident, type, isOutParam->v);
-	unit->currentContainer()->checkIntroduced(ident, pd);
+	ParamDeclPtr pd = op->createParamDecl(tsp->v.name, tsp->v.type, isOutParam->v, tsp->v.optional, tsp->v.tag);
+	unit->currentContainer()->checkIntroduced(tsp->v.name, pd);
         StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(4) - (5)]));
         if(!metaData->v.empty())
         {
@@ -3467,10 +3308,8 @@ yyreduce:
 ;}
     break;
 
-  case 124:
-
-/* Line 1455 of yacc.c  */
-#line 1443 "../Slice/Grammar.y"
+  case 126:
+#line 1458 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(1) - (4)]));
     TypePtr type = TypePtr::dynamicCast((yyvsp[(3) - (4)]));
@@ -3478,16 +3317,14 @@ yyreduce:
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(ident->v, type, isOutParam->v); // Dummy
+	op->createParamDecl(ident->v, type, isOutParam->v, false, 0); // Dummy
 	unit->error("keyword `" + ident->v + "' cannot be used as parameter name");
     }
 ;}
     break;
 
-  case 125:
-
-/* Line 1455 of yacc.c  */
-#line 1455 "../Slice/Grammar.y"
+  case 127:
+#line 1470 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(3) - (6)]));
     TypePtr type = TypePtr::dynamicCast((yyvsp[(5) - (6)]));
@@ -3495,74 +3332,62 @@ yyreduce:
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(ident->v, type, isOutParam->v); // Dummy
+	op->createParamDecl(ident->v, type, isOutParam->v, false, 0); // Dummy
 	unit->error("keyword `" + ident->v + "' cannot be used as parameter name");
     }
 ;}
     break;
 
-  case 126:
-
-/* Line 1455 of yacc.c  */
-#line 1467 "../Slice/Grammar.y"
+  case 128:
+#line 1482 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(1) - (3)]));
     TypePtr type = TypePtr::dynamicCast((yyvsp[(3) - (3)]));
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v); // Dummy
+	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v, false, 0); // Dummy
 	unit->error("missing parameter name");
     }
 ;}
     break;
 
-  case 127:
-
-/* Line 1455 of yacc.c  */
-#line 1478 "../Slice/Grammar.y"
+  case 129:
+#line 1493 "../Slice/Grammar.y"
     {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast((yyvsp[(3) - (5)]));
     TypePtr type = TypePtr::dynamicCast((yyvsp[(5) - (5)]));
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v); // Dummy
+	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v, false, 0); // Dummy
 	unit->error("missing parameter name");
     }
 ;}
     break;
 
-  case 128:
-
-/* Line 1455 of yacc.c  */
-#line 1494 "../Slice/Grammar.y"
+  case 130:
+#line 1509 "../Slice/Grammar.y"
     {
     (yyval) = (yyvsp[(2) - (2)]);
 ;}
     break;
 
-  case 129:
-
-/* Line 1455 of yacc.c  */
-#line 1498 "../Slice/Grammar.y"
+  case 131:
+#line 1513 "../Slice/Grammar.y"
     {
     (yyval) = new ExceptionListTok;
 ;}
     break;
 
-  case 130:
-
-/* Line 1455 of yacc.c  */
-#line 1507 "../Slice/Grammar.y"
+  case 132:
+#line 1522 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 131:
-
-/* Line 1455 of yacc.c  */
-#line 1510 "../Slice/Grammar.y"
+  case 133:
+#line 1525 "../Slice/Grammar.y"
     {
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
     ident->v = "::" + ident->v;
@@ -3570,10 +3395,8 @@ yyreduce:
 ;}
     break;
 
-  case 132:
-
-/* Line 1455 of yacc.c  */
-#line 1516 "../Slice/Grammar.y"
+  case 134:
+#line 1531 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (3)]));
     StringTokPtr ident = StringTokPtr::dynamicCast((yyvsp[(3) - (3)]));
@@ -3583,109 +3406,85 @@ yyreduce:
 ;}
     break;
 
-  case 133:
-
-/* Line 1455 of yacc.c  */
-#line 1529 "../Slice/Grammar.y"
+  case 135:
+#line 1544 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindByte);
 ;}
     break;
 
-  case 134:
-
-/* Line 1455 of yacc.c  */
-#line 1533 "../Slice/Grammar.y"
+  case 136:
+#line 1548 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindBool);
 ;}
     break;
 
-  case 135:
-
-/* Line 1455 of yacc.c  */
-#line 1537 "../Slice/Grammar.y"
+  case 137:
+#line 1552 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindShort);
 ;}
     break;
 
-  case 136:
-
-/* Line 1455 of yacc.c  */
-#line 1541 "../Slice/Grammar.y"
+  case 138:
+#line 1556 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindInt);
 ;}
     break;
 
-  case 137:
-
-/* Line 1455 of yacc.c  */
-#line 1545 "../Slice/Grammar.y"
+  case 139:
+#line 1560 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindLong);
 ;}
     break;
 
-  case 138:
-
-/* Line 1455 of yacc.c  */
-#line 1549 "../Slice/Grammar.y"
+  case 140:
+#line 1564 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindFloat);
 ;}
     break;
 
-  case 139:
-
-/* Line 1455 of yacc.c  */
-#line 1553 "../Slice/Grammar.y"
+  case 141:
+#line 1568 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindDouble);
 ;}
     break;
 
-  case 140:
-
-/* Line 1455 of yacc.c  */
-#line 1557 "../Slice/Grammar.y"
+  case 142:
+#line 1572 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindString);
 ;}
     break;
 
-  case 141:
-
-/* Line 1455 of yacc.c  */
-#line 1561 "../Slice/Grammar.y"
+  case 143:
+#line 1576 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindObject);
 ;}
     break;
 
-  case 142:
-
-/* Line 1455 of yacc.c  */
-#line 1565 "../Slice/Grammar.y"
+  case 144:
+#line 1580 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindObjectProxy);
 ;}
     break;
 
-  case 143:
-
-/* Line 1455 of yacc.c  */
-#line 1569 "../Slice/Grammar.y"
+  case 145:
+#line 1584 "../Slice/Grammar.y"
     {
     (yyval) = unit->builtin(Builtin::KindLocalObject);
 ;}
     break;
 
-  case 144:
-
-/* Line 1455 of yacc.c  */
-#line 1573 "../Slice/Grammar.y"
+  case 146:
+#line 1588 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     ContainerPtr cont = unit->currentContainer();
@@ -3706,10 +3505,8 @@ yyreduce:
 ;}
     break;
 
-  case 145:
-
-/* Line 1455 of yacc.c  */
-#line 1592 "../Slice/Grammar.y"
+  case 147:
+#line 1607 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     ContainerPtr cont = unit->currentContainer();
@@ -3747,10 +3544,8 @@ yyreduce:
 ;}
     break;
 
-  case 146:
-
-/* Line 1455 of yacc.c  */
-#line 1633 "../Slice/Grammar.y"
+  case 148:
+#line 1648 "../Slice/Grammar.y"
     {
     StringTokPtr str1 = StringTokPtr::dynamicCast((yyvsp[(1) - (2)]));
     StringTokPtr str2 = StringTokPtr::dynamicCast((yyvsp[(2) - (2)]));
@@ -3758,18 +3553,14 @@ yyreduce:
 ;}
     break;
 
-  case 147:
-
-/* Line 1455 of yacc.c  */
-#line 1639 "../Slice/Grammar.y"
+  case 149:
+#line 1654 "../Slice/Grammar.y"
     {
 ;}
     break;
 
-  case 148:
-
-/* Line 1455 of yacc.c  */
-#line 1647 "../Slice/Grammar.y"
+  case 150:
+#line 1662 "../Slice/Grammar.y"
     {
     StringTokPtr str = StringTokPtr::dynamicCast((yyvsp[(3) - (3)]));
     StringListTokPtr stringList = StringListTokPtr::dynamicCast((yyvsp[(1) - (3)]));
@@ -3778,10 +3569,8 @@ yyreduce:
 ;}
     break;
 
-  case 149:
-
-/* Line 1455 of yacc.c  */
-#line 1654 "../Slice/Grammar.y"
+  case 151:
+#line 1669 "../Slice/Grammar.y"
     {
     StringTokPtr str = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     StringListTokPtr stringList = new StringListTok;
@@ -3790,10 +3579,8 @@ yyreduce:
 ;}
     break;
 
-  case 150:
-
-/* Line 1455 of yacc.c  */
-#line 1666 "../Slice/Grammar.y"
+  case 152:
+#line 1681 "../Slice/Grammar.y"
     {
     BoolTokPtr local = new BoolTok;
     local->v = true;
@@ -3801,10 +3588,8 @@ yyreduce:
 ;}
     break;
 
-  case 151:
-
-/* Line 1455 of yacc.c  */
-#line 1672 "../Slice/Grammar.y"
+  case 153:
+#line 1687 "../Slice/Grammar.y"
     {
     BoolTokPtr local = new BoolTok;
     local->v = false;
@@ -3812,10 +3597,8 @@ yyreduce:
 ;}
     break;
 
-  case 152:
-
-/* Line 1455 of yacc.c  */
-#line 1683 "../Slice/Grammar.y"
+  case 154:
+#line 1698 "../Slice/Grammar.y"
     {
     BuiltinPtr type = unit->builtin(Builtin::KindLong);
     IntegerTokPtr intVal = IntegerTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3830,10 +3613,8 @@ yyreduce:
 ;}
     break;
 
-  case 153:
-
-/* Line 1455 of yacc.c  */
-#line 1696 "../Slice/Grammar.y"
+  case 155:
+#line 1711 "../Slice/Grammar.y"
     {
     BuiltinPtr type = unit->builtin(Builtin::KindDouble);
     FloatingTokPtr floatVal = FloatingTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3848,10 +3629,8 @@ yyreduce:
 ;}
     break;
 
-  case 154:
-
-/* Line 1455 of yacc.c  */
-#line 1709 "../Slice/Grammar.y"
+  case 156:
+#line 1724 "../Slice/Grammar.y"
     {
     StringTokPtr scoped = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
     ConstDefTokPtr def = new ConstDefTok;
@@ -3899,10 +3678,8 @@ yyreduce:
 ;}
     break;
 
-  case 155:
-
-/* Line 1455 of yacc.c  */
-#line 1755 "../Slice/Grammar.y"
+  case 157:
+#line 1770 "../Slice/Grammar.y"
     {
     BuiltinPtr type = unit->builtin(Builtin::KindString);
     StringTokPtr literal = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3915,10 +3692,8 @@ yyreduce:
 ;}
     break;
 
-  case 156:
-
-/* Line 1455 of yacc.c  */
-#line 1766 "../Slice/Grammar.y"
+  case 158:
+#line 1781 "../Slice/Grammar.y"
     {
     BuiltinPtr type = unit->builtin(Builtin::KindBool);
     StringTokPtr literal = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3931,10 +3706,8 @@ yyreduce:
 ;}
     break;
 
-  case 157:
-
-/* Line 1455 of yacc.c  */
-#line 1777 "../Slice/Grammar.y"
+  case 159:
+#line 1792 "../Slice/Grammar.y"
     {
     BuiltinPtr type = unit->builtin(Builtin::KindBool);
     StringTokPtr literal = StringTokPtr::dynamicCast((yyvsp[(1) - (1)]));
@@ -3947,10 +3720,8 @@ yyreduce:
 ;}
     break;
 
-  case 158:
-
-/* Line 1455 of yacc.c  */
-#line 1793 "../Slice/Grammar.y"
+  case 160:
+#line 1808 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(2) - (6)]));
     TypePtr const_type = TypePtr::dynamicCast((yyvsp[(3) - (6)]));
@@ -3961,10 +3732,8 @@ yyreduce:
 ;}
     break;
 
-  case 159:
-
-/* Line 1455 of yacc.c  */
-#line 1802 "../Slice/Grammar.y"
+  case 161:
+#line 1817 "../Slice/Grammar.y"
     {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast((yyvsp[(2) - (5)]));
     TypePtr const_type = TypePtr::dynamicCast((yyvsp[(3) - (5)]));
@@ -3975,242 +3744,183 @@ yyreduce:
 ;}
     break;
 
-  case 160:
-
-/* Line 1455 of yacc.c  */
-#line 1816 "../Slice/Grammar.y"
-    {
-;}
-    break;
-
-  case 161:
-
-/* Line 1455 of yacc.c  */
-#line 1819 "../Slice/Grammar.y"
-    {
-;}
-    break;
-
   case 162:
-
-/* Line 1455 of yacc.c  */
-#line 1822 "../Slice/Grammar.y"
+#line 1831 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 163:
-
-/* Line 1455 of yacc.c  */
-#line 1825 "../Slice/Grammar.y"
+#line 1834 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 164:
-
-/* Line 1455 of yacc.c  */
-#line 1828 "../Slice/Grammar.y"
+#line 1837 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 165:
-
-/* Line 1455 of yacc.c  */
-#line 1831 "../Slice/Grammar.y"
+#line 1840 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 166:
-
-/* Line 1455 of yacc.c  */
-#line 1834 "../Slice/Grammar.y"
+#line 1843 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 167:
-
-/* Line 1455 of yacc.c  */
-#line 1837 "../Slice/Grammar.y"
+#line 1846 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 168:
-
-/* Line 1455 of yacc.c  */
-#line 1840 "../Slice/Grammar.y"
+#line 1849 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 169:
-
-/* Line 1455 of yacc.c  */
-#line 1843 "../Slice/Grammar.y"
+#line 1852 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 170:
-
-/* Line 1455 of yacc.c  */
-#line 1846 "../Slice/Grammar.y"
+#line 1855 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 171:
-
-/* Line 1455 of yacc.c  */
-#line 1849 "../Slice/Grammar.y"
+#line 1858 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 172:
-
-/* Line 1455 of yacc.c  */
-#line 1852 "../Slice/Grammar.y"
+#line 1861 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 173:
-
-/* Line 1455 of yacc.c  */
-#line 1855 "../Slice/Grammar.y"
+#line 1864 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 174:
-
-/* Line 1455 of yacc.c  */
-#line 1858 "../Slice/Grammar.y"
+#line 1867 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 175:
-
-/* Line 1455 of yacc.c  */
-#line 1861 "../Slice/Grammar.y"
+#line 1870 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 176:
-
-/* Line 1455 of yacc.c  */
-#line 1864 "../Slice/Grammar.y"
+#line 1873 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 177:
-
-/* Line 1455 of yacc.c  */
-#line 1867 "../Slice/Grammar.y"
+#line 1876 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 178:
-
-/* Line 1455 of yacc.c  */
-#line 1870 "../Slice/Grammar.y"
+#line 1879 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 179:
-
-/* Line 1455 of yacc.c  */
-#line 1873 "../Slice/Grammar.y"
+#line 1882 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 180:
-
-/* Line 1455 of yacc.c  */
-#line 1876 "../Slice/Grammar.y"
+#line 1885 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 181:
-
-/* Line 1455 of yacc.c  */
-#line 1879 "../Slice/Grammar.y"
+#line 1888 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 182:
-
-/* Line 1455 of yacc.c  */
-#line 1882 "../Slice/Grammar.y"
+#line 1891 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 183:
-
-/* Line 1455 of yacc.c  */
-#line 1885 "../Slice/Grammar.y"
+#line 1894 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 184:
-
-/* Line 1455 of yacc.c  */
-#line 1888 "../Slice/Grammar.y"
+#line 1897 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 185:
-
-/* Line 1455 of yacc.c  */
-#line 1891 "../Slice/Grammar.y"
+#line 1900 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 186:
-
-/* Line 1455 of yacc.c  */
-#line 1894 "../Slice/Grammar.y"
+#line 1903 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 187:
-
-/* Line 1455 of yacc.c  */
-#line 1897 "../Slice/Grammar.y"
+#line 1906 "../Slice/Grammar.y"
     {
 ;}
     break;
 
   case 188:
+#line 1909 "../Slice/Grammar.y"
+    {
+;}
+    break;
 
-/* Line 1455 of yacc.c  */
-#line 1900 "../Slice/Grammar.y"
+  case 189:
+#line 1912 "../Slice/Grammar.y"
     {
 ;}
     break;
 
+  case 190:
+#line 1915 "../Slice/Grammar.y"
+    {
+;}
+    break;
 
 
-/* Line 1455 of yacc.c  */
-#line 4214 "Grammar.tab.c"
+/* Line 1267 of yacc.c.  */
+#line 3924 "Grammar.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -4221,6 +3931,7 @@ yyreduce:
 
   *++yyvsp = yyval;
 
+
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
@@ -4285,7 +3996,7 @@ yyerrlab:
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
 	 error, discard it.  */
 
       if (yychar <= YYEOF)
@@ -4302,7 +4013,7 @@ yyerrlab:
 	}
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
   goto yyerrlab1;
 
@@ -4359,6 +4070,9 @@ yyerrlab1:
       YY_STACK_PRINT (yyss, yyssp);
     }
 
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
   *++yyvsp = yylval;
 
 
@@ -4383,7 +4097,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
-#if !defined(yyoverflow) || YYERROR_VERBOSE
+#ifndef yyoverflow
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -4394,7 +4108,7 @@ yyexhaustedlab:
 #endif
 
 yyreturn:
-  if (yychar != YYEMPTY)
+  if (yychar != YYEOF && yychar != YYEMPTY)
      yydestruct ("Cleanup: discarding lookahead",
 		 yytoken, &yylval);
   /* Do not reclaim the symbols of the rule which action triggered
@@ -4420,8 +4134,6 @@ yyreturn:
 }
 
 
-
-/* Line 1675 of yacc.c  */
-#line 1904 "../Slice/Grammar.y"
+#line 1919 "../Slice/Grammar.y"
 
 
diff --git a/cpp/src/Slice/Grammar.h b/cpp/src/Slice/Grammar.h
index 0ee3d141315..8b0f1aff09f 100644
--- a/cpp/src/Slice/Grammar.h
+++ b/cpp/src/Slice/Grammar.h
@@ -1,23 +1,24 @@
-
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
 /* Skeleton interface for Bison's Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
+
+   This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -28,11 +29,10 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-   
+
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -83,16 +83,59 @@
      BAD_CHAR = 299
    };
 #endif
+/* Tokens.  */
+#define ICE_MODULE 258
+#define ICE_CLASS 259
+#define ICE_INTERFACE 260
+#define ICE_EXCEPTION 261
+#define ICE_STRUCT 262
+#define ICE_SEQUENCE 263
+#define ICE_DICTIONARY 264
+#define ICE_ENUM 265
+#define ICE_OUT 266
+#define ICE_EXTENDS 267
+#define ICE_IMPLEMENTS 268
+#define ICE_THROWS 269
+#define ICE_VOID 270
+#define ICE_BYTE 271
+#define ICE_BOOL 272
+#define ICE_SHORT 273
+#define ICE_INT 274
+#define ICE_LONG 275
+#define ICE_FLOAT 276
+#define ICE_DOUBLE 277
+#define ICE_STRING 278
+#define ICE_OBJECT 279
+#define ICE_LOCAL_OBJECT 280
+#define ICE_LOCAL 281
+#define ICE_CONST 282
+#define ICE_FALSE 283
+#define ICE_TRUE 284
+#define ICE_IDEMPOTENT 285
+#define ICE_OPTIONAL 286
+#define ICE_SCOPE_DELIMITER 287
+#define ICE_IDENTIFIER 288
+#define ICE_STRING_LITERAL 289
+#define ICE_INTEGER_LITERAL 290
+#define ICE_FLOATING_POINT_LITERAL 291
+#define ICE_IDENT_OP 292
+#define ICE_KEYWORD_OP 293
+#define ICE_OPTIONAL_OP 294
+#define ICE_METADATA_OPEN 295
+#define ICE_METADATA_CLOSE 296
+#define ICE_GLOBAL_METADATA_OPEN 297
+#define ICE_GLOBAL_METADATA_CLOSE 298
+#define BAD_CHAR 299
+
 
 
 
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 
 
-
diff --git a/cpp/src/Slice/Grammar.y b/cpp/src/Slice/Grammar.y
index 9d127bf115b..4a57da869df 100644
--- a/cpp/src/Slice/Grammar.y
+++ b/cpp/src/Slice/Grammar.y
@@ -365,17 +365,16 @@ type_id
 ;
 
 // ----------------------------------------------------------------------
-data_member_type_id
+optional
 // ----------------------------------------------------------------------
-: ICE_OPTIONAL_OP ICE_INTEGER_LITERAL ')' type_id
+: ICE_OPTIONAL_OP ICE_INTEGER_LITERAL ')'
 {
     IntegerTokPtr i = IntegerTokPtr::dynamicCast($2);
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast($4);
 
     int tag;
     if(i->v < 0 || i->v > Int32Max)
     {
-        unit->error("tag for optional member `" + ts->v.second + "' is out of range");
+        unit->error("tag for optional is out of range");
         tag = -1;
     }
     else
@@ -383,17 +382,14 @@ data_member_type_id
         tag = static_cast<int>(i->v);
     }
 
-    DataMemberDefTokPtr m = new DataMemberDefTok;
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.optional = tag >= 0;
     m->v.tag = tag;
     $$ = m;
 }
-| ICE_OPTIONAL_OP scoped_name ')' type_id
+| ICE_OPTIONAL_OP scoped_name ')'
 {
     StringTokPtr scoped = StringTokPtr::dynamicCast($2);
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast($4);
 
     ContainerPtr cont = unit->currentContainer();
     assert(cont);
@@ -422,7 +418,7 @@ data_member_type_id
                 IceUtil::Int64 l = IceUtilInternal::strToInt64(constant->value().c_str(), 0, 0);
                 if(l < 0 || l > Int32Max)
                 {
-                    unit->error("tag for optional member `" + ts->v.second + "' is out of range");
+                    unit->error("tag for optional is out of range");
                 }
                 tag = static_cast<int>(l);
                 break;
@@ -453,42 +449,47 @@ data_member_type_id
 
     if(tag < 0)
     {
-        unit->error("invalid tag `" + scoped->v + "' for optional member `" + ts->v.second + "'");
+        unit->error("invalid tag `" + scoped->v + "' for optional");
     }
 
-    DataMemberDefTokPtr m = new DataMemberDefTok;
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.optional = tag >= 0;
     m->v.tag = tag;
     $$ = m;
 }
-| ICE_OPTIONAL_OP ')' type_id
+| ICE_OPTIONAL_OP ')'
 {
-    TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast($3);
-    unit->error("missing tag for optional member `" + ts->v.second + "'");
-    DataMemberDefTokPtr m = new DataMemberDefTok; // Dummy
-    m->v.type = ts->v.first;
-    m->v.name = ts->v.second;
+    unit->error("missing tag for optional");
+    OptionalDefTokPtr m = new OptionalDefTok; // Dummy
+    m->v.optional = false;
+    m->v.tag = -1;
+    $$ = m;
+}
+| ICE_OPTIONAL
+{
+    unit->error("missing tag for optional");
+    OptionalDefTokPtr m = new OptionalDefTok; // Dummy
     m->v.optional = false;
     m->v.tag = -1;
     $$ = m;
 }
-| ICE_OPTIONAL type_id
+;
+
+// ----------------------------------------------------------------------
+optional_type_id
+// ----------------------------------------------------------------------
+: optional type_id
 {
+    OptionalDefTokPtr m = OptionalDefTokPtr::dynamicCast($1);
     TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast($2);
-    unit->error("missing tag for optional member `" + ts->v.second + "'");
-    DataMemberDefTokPtr m = new DataMemberDefTok; // Dummy
     m->v.type = ts->v.first;
     m->v.name = ts->v.second;
-    m->v.optional = false;
-    m->v.tag = -1;
     $$ = m;
 }
 | type_id
 {
     TypeStringTokPtr ts = TypeStringTokPtr::dynamicCast($1);
-    DataMemberDefTokPtr m = new DataMemberDefTok;
+    OptionalDefTokPtr m = new OptionalDefTok;
     m->v.type = ts->v.first;
     m->v.name = ts->v.second;
     m->v.optional = false;
@@ -745,9 +746,9 @@ class_exports
 // ----------------------------------------------------------------------
 data_member
 // ----------------------------------------------------------------------
-: data_member_type_id
+: optional_type_id
 {
-    DataMemberDefTokPtr def = DataMemberDefTokPtr::dynamicCast($1);
+    OptionalDefTokPtr def = OptionalDefTokPtr::dynamicCast($1);
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     DataMemberPtr dm;
     if(cl)
@@ -767,9 +768,9 @@ data_member
     unit->currentContainer()->checkIntroduced(def->v.name, dm);
     $$ = dm;
 }
-| data_member_type_id '=' const_initializer
+| optional_type_id '=' const_initializer
 {
-    DataMemberDefTokPtr def = DataMemberDefTokPtr::dynamicCast($1);
+    OptionalDefTokPtr def = OptionalDefTokPtr::dynamicCast($1);
     ConstDefTokPtr value = ConstDefTokPtr::dynamicCast($3);
 
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
@@ -842,10 +843,26 @@ data_member
 // ----------------------------------------------------------------------
 return_type
 // ----------------------------------------------------------------------
-: type
+: optional type
+{
+    OptionalDefTokPtr m = OptionalDefTokPtr::dynamicCast($1);
+    m->v.type = TypePtr::dynamicCast($2);
+    $$ = m;
+}
+| type
+{
+    OptionalDefTokPtr m = new OptionalDefTok();
+    m->v.type = TypePtr::dynamicCast($1);
+    m->v.optional = false;
+    m->v.tag = -1;
+    $$ = m;
+}
 | ICE_VOID
 {
-    $$ = 0;
+    OptionalDefTokPtr m = new OptionalDefTok;
+    m->v.optional = false;
+    m->v.tag = -1;
+    $$ = m;
 }
 ;
 
@@ -854,12 +871,12 @@ operation_preamble
 // ----------------------------------------------------------------------
 : return_type ICE_IDENT_OP
 {
-    TypePtr returnType = TypePtr::dynamicCast($1);
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast($1);
     string name = StringTokPtr::dynamicCast($2)->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag);
 	if(op)
 	{
 	    cl->checkIntroduced(name, op);
@@ -878,12 +895,13 @@ operation_preamble
 }
 | ICE_IDEMPOTENT return_type ICE_IDENT_OP
 {
-    TypePtr returnType = TypePtr::dynamicCast($2);
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast($2);
     string name = StringTokPtr::dynamicCast($3)->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType, Operation::Idempotent);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag,
+                                              Operation::Idempotent);
 	if(op)
 	{
 	    cl->checkIntroduced(name, op);
@@ -902,12 +920,12 @@ operation_preamble
 }
 | return_type ICE_KEYWORD_OP
 {
-    TypePtr returnType = TypePtr::dynamicCast($1);
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast($1);
     string name = StringTokPtr::dynamicCast($2)->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag);
 	if(op)
 	{
 	    unit->pushContainer(op);
@@ -926,12 +944,13 @@ operation_preamble
 }
 | ICE_IDEMPOTENT return_type ICE_KEYWORD_OP
 {
-    TypePtr returnType = TypePtr::dynamicCast($2);
+    OptionalDefTokPtr returnType = OptionalDefTokPtr::dynamicCast($2);
     string name = StringTokPtr::dynamicCast($3)->v;
     ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
     if(cl)
     {
-	OperationPtr op = cl->createOperation(name, returnType, Operation::Idempotent);
+	OperationPtr op = cl->createOperation(name, returnType->v.type, returnType->v.optional, returnType->v.tag,
+                                              Operation::Idempotent);
 	if(op)
 	{
 	    unit->pushContainer(op);
@@ -1403,17 +1422,15 @@ parameters
 : // empty
 {
 }
-| out_qualifier meta_data type_id
+| out_qualifier meta_data optional_type_id
 {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast($1);
-    TypeStringTokPtr tsp = TypeStringTokPtr::dynamicCast($3);
-    TypePtr type = tsp->v.first;
-    string ident = tsp->v.second;
+    OptionalDefTokPtr tsp = OptionalDefTokPtr::dynamicCast($3);
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	ParamDeclPtr pd = op->createParamDecl(ident, type, isOutParam->v);
-	unit->currentContainer()->checkIntroduced(ident, pd);
+	ParamDeclPtr pd = op->createParamDecl(tsp->v.name, tsp->v.type, isOutParam->v, tsp->v.optional, tsp->v.tag);
+	unit->currentContainer()->checkIntroduced(tsp->v.name, pd);
         StringListTokPtr metaData = StringListTokPtr::dynamicCast($2);
         if(!metaData->v.empty())
         {
@@ -1421,17 +1438,15 @@ parameters
         }
     }
 }
-| parameters ',' out_qualifier meta_data type_id
+| parameters ',' out_qualifier meta_data optional_type_id
 {
     BoolTokPtr isOutParam = BoolTokPtr::dynamicCast($3);
-    TypeStringTokPtr tsp = TypeStringTokPtr::dynamicCast($5);
-    TypePtr type = tsp->v.first;
-    string ident = tsp->v.second;
+    OptionalDefTokPtr tsp = OptionalDefTokPtr::dynamicCast($5);
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	ParamDeclPtr pd = op->createParamDecl(ident, type, isOutParam->v);
-	unit->currentContainer()->checkIntroduced(ident, pd);
+	ParamDeclPtr pd = op->createParamDecl(tsp->v.name, tsp->v.type, isOutParam->v, tsp->v.optional, tsp->v.tag);
+	unit->currentContainer()->checkIntroduced(tsp->v.name, pd);
         StringListTokPtr metaData = StringListTokPtr::dynamicCast($4);
         if(!metaData->v.empty())
         {
@@ -1447,7 +1462,7 @@ parameters
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(ident->v, type, isOutParam->v); // Dummy
+	op->createParamDecl(ident->v, type, isOutParam->v, false, 0); // Dummy
 	unit->error("keyword `" + ident->v + "' cannot be used as parameter name");
     }
 }
@@ -1459,7 +1474,7 @@ parameters
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(ident->v, type, isOutParam->v); // Dummy
+	op->createParamDecl(ident->v, type, isOutParam->v, false, 0); // Dummy
 	unit->error("keyword `" + ident->v + "' cannot be used as parameter name");
     }
 }
@@ -1470,7 +1485,7 @@ parameters
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v); // Dummy
+	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v, false, 0); // Dummy
 	unit->error("missing parameter name");
     }
 }
@@ -1481,7 +1496,7 @@ parameters
     OperationPtr op = OperationPtr::dynamicCast(unit->currentContainer());
     if(op)
     {
-	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v); // Dummy
+	op->createParamDecl(IceUtil::generateUUID(), type, isOutParam->v, false, 0); // Dummy
 	unit->error("missing parameter name");
     }
 }
diff --git a/cpp/src/Slice/GrammarUtil.h b/cpp/src/Slice/GrammarUtil.h
index f71e0dc961f..c803152dd24 100644
--- a/cpp/src/Slice/GrammarUtil.h
+++ b/cpp/src/Slice/GrammarUtil.h
@@ -26,7 +26,8 @@ class ExceptionListTok;
 class ClassListTok;
 class EnumeratorListTok;
 class ConstDefTok;
-class DataMemberDefTok;
+class OptionalDefTok;
+class OptionalTypeDefTok;
 
 typedef ::IceUtil::Handle<StringTok> StringTokPtr;
 typedef ::IceUtil::Handle<StringListTok> StringListTokPtr;
@@ -39,7 +40,7 @@ typedef ::IceUtil::Handle<ExceptionListTok> ExceptionListTokPtr;
 typedef ::IceUtil::Handle<ClassListTok> ClassListTokPtr;
 typedef ::IceUtil::Handle<EnumeratorListTok> EnumeratorListTokPtr;
 typedef ::IceUtil::Handle<ConstDefTok> ConstDefTokPtr;
-typedef ::IceUtil::Handle<DataMemberDefTok> DataMemberDefTokPtr;
+typedef ::IceUtil::Handle<OptionalDefTok> OptionalDefTokPtr;
 
 // ----------------------------------------------------------------------
 // StringTok
@@ -177,15 +178,15 @@ public:
 };
 
 // ----------------------------------------------------------------------
-// DataMemberDefTok
+// OptionalDefTok
 // ----------------------------------------------------------------------
 
-class SLICE_API DataMemberDefTok : public GrammarBase
+class SLICE_API OptionalDefTok : public GrammarBase
 {
 public:
 
-    DataMemberDefTok() { }
-    DataMemberDef v;
+    OptionalDefTok() { }
+    OptionalDef v;
 };
 
 }
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 50b1e68101d..e7ecd451617 100755
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -40,6 +40,30 @@ string readWriteAttribute[] = { "read", "write" };
 string txAttribute[] = { "supports", "mandatory", "required", "never" };
 enum { Supports, Mandatory, Required, Never };
 
+DataMemberList
+filterOrderedOptionalDataMembers(const DataMemberList& members)
+{
+    class SortFn
+    {
+    public:
+        static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs)
+        {
+            return lhs->tag() < rhs->tag();
+        }
+    };
+
+    DataMemberList result;
+    for(DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
+    {
+        if((*p)->optional())
+        {
+            result.push_back(*p);
+        }
+    }
+    result.sort(SortFn::compare);
+    return result;
+}
+
 }
 
 namespace Slice
@@ -2939,6 +2963,8 @@ Slice::ClassDef::destroy()
 OperationPtr
 Slice::ClassDef::createOperation(const string& name,
                                  const TypePtr& returnType,
+                                 bool optional,
+                                 int tag,
                                  Operation::Mode mode)
 {
     checkIdentifier(name);
@@ -3037,7 +3063,7 @@ Slice::ClassDef::createOperation(const string& name,
     }
     
     _hasOperations = true;
-    OperationPtr op = new Operation(this, name, returnType, mode);
+    OperationPtr op = new Operation(this, name, returnType, optional, tag, mode);
     _contents.push_back(op);
     return op;
 }
@@ -3282,6 +3308,12 @@ Slice::ClassDef::dataMembers() const
     return result;
 }
 
+DataMemberList
+Slice::ClassDef::orderedOptionalDataMembers() const
+{
+    return filterOrderedOptionalDataMembers(dataMembers());
+}
+
 //
 // Return the data members of this class and its parent classes, in base-to-derived order.
 //
@@ -3753,6 +3785,12 @@ Slice::Exception::dataMembers() const
     return result;
 }
 
+DataMemberList
+Slice::Exception::orderedOptionalDataMembers() const
+{
+    return filterOrderedOptionalDataMembers(dataMembers());
+}
+
 //
 // Return the data members of this exception and its parent exceptions, in base-to-derived order.
 //
@@ -4556,22 +4594,13 @@ Slice::Enum::usesClasses() const
 size_t
 Slice::Enum::minWireSize() const
 {
-    size_t sz = _enumerators.size();
-    if(sz <= 0x7f)
-    {
-        return 1;
-    }
-    if(sz <= 0x7fff)
-    {
-        return 2;
-    }
-    return 4;
+    return 1;
 }
 
 bool
 Slice::Enum::isVariableLength() const
 {
-    return false;
+    return true;
 }
 
 string
@@ -4716,6 +4745,18 @@ Slice::Operation::returnType() const
     return _returnType;
 }
 
+bool
+Slice::Operation::returnIsOptional() const
+{
+    return _returnIsOptional;
+}
+
+int
+Slice::Operation::returnTag() const
+{
+    return _returnTag;
+}
+
 Operation::Mode
 Slice::Operation::mode() const
 {
@@ -4736,7 +4777,7 @@ Slice::Operation::sendMode() const
 }
 
 ParamDeclPtr
-Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool isOutParam)
+Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool isOutParam, bool optional, int tag)
 {
     checkIdentifier(name);
 
@@ -4835,7 +4876,7 @@ Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool
         _unit->error(msg);
     }
 
-    ParamDeclPtr p = new ParamDecl(this, name, type, isOutParam);
+    ParamDeclPtr p = new ParamDecl(this, name, type, isOutParam, optional, tag);
     _contents.push_back(p);
     return p;
 }
@@ -5121,11 +5162,15 @@ Slice::Operation::visit(ParserVisitor* visitor, bool)
 Slice::Operation::Operation(const ContainerPtr& container,
                             const string& name,
                             const TypePtr& returnType,
+                            bool returnIsOptional,
+                            int returnTag,
                             Mode mode) :
     SyntaxTreeBase(container->unit()),
     Contained(container, name),
     Container(container->unit()),
     _returnType(returnType),
+    _returnIsOptional(returnIsOptional),
+    _returnTag(returnTag),
     _mode(mode)
 {
     if(_unit->profile() == IceE)
@@ -5166,6 +5211,18 @@ Slice::ParamDecl::isOutParam() const
     return _isOutParam;
 }
 
+bool
+Slice::ParamDecl::optional() const
+{
+    return _optional;
+}
+
+int
+Slice::ParamDecl::tag() const
+{
+    return _tag;
+}
+
 Contained::ContainedType
 Slice::ParamDecl::containedType() const
 {
@@ -5196,11 +5253,14 @@ Slice::ParamDecl::visit(ParserVisitor* visitor, bool)
     visitor->visitParamDecl(this);
 }
 
-Slice::ParamDecl::ParamDecl(const ContainerPtr& container, const string& name, const TypePtr& type, bool isOutParam) :
+Slice::ParamDecl::ParamDecl(const ContainerPtr& container, const string& name, const TypePtr& type, bool isOutParam,
+                            bool optional, int tag) :
     SyntaxTreeBase(container->unit()),
     Contained(container, name),
     _type(type),
-    _isOutParam(isOutParam)
+    _isOutParam(isOutParam),
+    _optional(optional),
+    _tag(tag)
 {
 }
 
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 021ee80172c..54091b39450 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -26,7 +26,10 @@ using namespace Slice;
 using namespace IceUtil;
 using namespace IceUtilInternal;
 
-static string
+namespace
+{
+
+string
 getDeprecateSymbol(const ContainedPtr& p1, const ContainedPtr& p2)
 {
     string deprecateMetadata, deprecateSymbol;
@@ -38,7 +41,7 @@ getDeprecateSymbol(const ContainedPtr& p1, const ContainedPtr& p2)
     return deprecateSymbol;
 }
 
-static void
+void
 writeConstantValue(IceUtilInternal::Output& out, const TypePtr& type, const SyntaxTreeBasePtr& valueType,
                    const string& value, int useWstring, const StringList& metaData)
 {
@@ -126,7 +129,32 @@ writeConstantValue(IceUtilInternal::Output& out, const TypePtr& type, const Synt
     }
 }
 
-static void
+void
+writeMarshalUnmarshalDataMember(IceUtilInternal::Output& C, const DataMemberPtr& p, bool marshal)
+{
+    writeMarshalUnmarshalCode(C, p->type(), p->optional(), p->tag(), fixKwd(p->name()), marshal, p->getMetaData());
+}
+
+void
+writeMarshalUnmarshalDataMembers(IceUtilInternal::Output& C, 
+                                 const DataMemberList& dataMembers, 
+                                 const DataMemberList& optionalDataMembers, 
+                                 bool marshal)
+{
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        if(!(*q)->optional())
+        {
+            writeMarshalUnmarshalDataMember(C, *q, marshal);
+        }
+    }
+    for(DataMemberList::const_iterator q = optionalDataMembers.begin(); q != optionalDataMembers.end(); ++q)
+    {
+        writeMarshalUnmarshalDataMember(C, *q, marshal);
+    }
+}
+
+void
 writeDataMemberInitializers(IceUtilInternal::Output& C, const DataMemberList& members, int useWstring)
 {
     bool first = true;
@@ -152,6 +180,8 @@ writeDataMemberInitializers(IceUtilInternal::Output& C, const DataMemberList& me
     }
 }
 
+}
+
 Slice::Gen::Gen(const string& base, const string& headerExtension, const string& sourceExtension,
                 const vector<string>& extraHeaders, const string& include,
                 const vector<string>& includePaths, const string& dllExport, const string& dir,
@@ -327,6 +357,7 @@ Slice::Gen::generate(const UnitPtr& p)
     H << "\n#include <Ice/ObjectF.h>";
     H << "\n#include <Ice/Exception.h>";
     H << "\n#include <Ice/LocalObject.h>";
+    H << "\n#include <Ice/StreamTraits.h>";
 
     if(p->usesProxies())
     {
@@ -358,7 +389,9 @@ Slice::Gen::generate(const UnitPtr& p)
     {
         H << "\n#include <Ice/FactoryTableInit.h>";
     }
+    
     H << "\n#include <IceUtil/ScopedArray.h>";
+    H << "\n#include <IceUtil/Optional.h>";
 
     if(p->usesNonLocals())
     {
@@ -454,12 +487,12 @@ Slice::Gen::generate(const UnitPtr& p)
     ObjectDeclVisitor objectDeclVisitor(H, C, _dllExport);
     p->visit(&objectDeclVisitor, false);
 
-    HandleVisitor handleVisitor(H, C, _dllExport, _stream);
-    p->visit(&handleVisitor, false);
-
     TypesVisitor typesVisitor(H, C, _dllExport, _stream);
     p->visit(&typesVisitor, false);
 
+    StreamVisitor streamVistor(H, C);
+    p->visit(&streamVistor, false);
+
     AsyncVisitor asyncVisitor(H, C, _dllExport);
     p->visit(&asyncVisitor, false);
 
@@ -490,12 +523,6 @@ Slice::Gen::generate(const UnitPtr& p)
     ObjectVisitor objectVisitor(H, C, _dllExport, _stream);
     p->visit(&objectVisitor, false);
 
-    if(_stream)
-    {
-        StreamVisitor streamVistor(H, C);
-        p->visit(&streamVistor, false);
-    }
-
     //
     // We need to delay generating the template after the proxy
     // definition, because __completed calls the begin_ method in the
@@ -635,8 +662,6 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     ExceptionPtr base = p->base();
     DataMemberList dataMembers = p->dataMembers();
     DataMemberList allDataMembers = p->allDataMembers();
-    bool basePreserved = p->inheritsMetaData("preserve-slice");
-    bool preserved = basePreserved || p->hasMetaData("preserve-slice");
     bool hasDefaultValues = p->hasDefaultValues();
     DataMemberList::const_iterator q;
 
@@ -653,7 +678,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     for(q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
     {
-        string typeName = inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+        string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
         allTypes.push_back(typeName);
         allParamDecls.push_back(typeName + " __ice_" + fixKwd((*q)->name()));
     }
@@ -667,16 +692,6 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         }
     }
 
-    //
-    // We declare a __usingClasses member for the initial preserved type in a hierarchy
-    // if neither that type nor its base class uses classes.
-    //
-    bool initUsingClasses = false;
-    if(preserved && !basePreserved && !p->usesClasses() && (!base || (base && !base->usesClasses())))
-    {
-        initUsingClasses = true;
-    }
-
     H << sp << nl << "class " << _dllExport << name << " : ";
     H.useCurrentPosAsIndent();
     H << "public ";
@@ -701,7 +716,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         H << "const char*" << "int";
     }
     H << epar;
-    if(!p->isLocal() && !hasDefaultValues && !initUsingClasses)
+    if(!p->isLocal() && !hasDefaultValues)
     {
         H << " {}";
     }
@@ -741,19 +756,11 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         C << sb;
         C << eb;
     }
-    else if(hasDefaultValues || initUsingClasses)
+    else if(hasDefaultValues)
     {
         C << sp << nl << scoped.substr(2) << "::" << name << "() :";
         C.inc();
         writeDataMemberInitializers(C, dataMembers, _useWstring);
-        if(initUsingClasses)
-        {
-            if(hasDefaultValues)
-            {
-                C << ",";
-            }
-            C << nl << "__usingClasses(false)";
-        }
         C.dec();
         C << sb;
         C << eb;
@@ -804,14 +811,6 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
             }
             C << nl << *pi << "(__ice_" << *pi << ')';
         }
-        if(initUsingClasses)
-        {
-            if(!baseParams.empty() || !params.empty())
-            {
-                C << ",";
-            }
-            C << nl << "__usingClasses(false)";
-        }
         if(p->isLocal() || !baseParams.empty() || !params.empty())
         {
             C.dec();
@@ -873,9 +872,6 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
     string name = fixKwd(p->name());
     string scope = fixKwd(p->scope());
     string scoped = fixKwd(p->scoped());
-    DataMemberList dataMembers = p->dataMembers();
-    DataMemberList::const_iterator q;
-
     string factoryName;
 
     if(!p->isLocal())
@@ -914,10 +910,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         C << sp << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::IceInternal::BasicStream* __os) const";
         C << sb;
         C << nl << "__os->startWriteSlice(\"" << p->scoped() << "\", " << (!base ? "true" : "false") << ");";
-        for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-        {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), true, "", true, (*q)->getMetaData());
-        }
+        writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), true);
         C << nl << "__os->endWriteSlice();";
         if(base)
         {
@@ -942,10 +935,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::IceInternal::BasicStream* __is)";
         C << sb;
         C << nl << "__is->startReadSlice();";
-        for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-        {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), false, "", true, (*q)->getMetaData());
-        }
+        writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), false);
         C << nl << "__is->endReadSlice();";
         if(base)
         {
@@ -955,65 +945,55 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(_stream)
         {
-            C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __os) const";
             C << sb;
             if(preserved)
             {
-                C << nl << "__outS->startException(__slicedData);";
+                C << nl << "__os->startException(__slicedData);";
             }
             else
             {
-                C << nl << "__outS->startException(0);";
+                C << nl << "__os->startException(0);";
             }
-            C << nl << "__writeImpl(__outS);";
-            C << nl << "__outS->endException();";
+            C << nl << "__writeImpl(__os);";
+            C << nl << "__os->endException();";
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__writeImpl(const ::Ice::OutputStreamPtr& __outS) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) 
+              << "::__writeImpl(const ::Ice::OutputStreamPtr& __os) const";
             C << sb;
-            C << nl << "__outS->startSlice(\"" << p->scoped() << "\", " << (!base ? "true" : "false") << ");";
-            for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-            {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), true, "", (*q)->getMetaData(),
-                                                _useWstring);
-            }
-            C << nl << "__outS->endSlice();";
+            C << nl << "__os->startSlice(\"" << p->scoped() << "\", " << (!base ? "true" : "false") << ");";
+            writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), true);
+            C << nl << "__os->endSlice();";
             if(base)
             {
-                emitUpcall(base, "::__writeImpl(__outS);");
+                emitUpcall(base, "::__writeImpl(__os);");
             }
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__read(const ::Ice::InputStreamPtr& __inS)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __is)";
             C << sb;
-            C << nl << "__inS->startException();";
-            C << nl << "__readImpl(__inS);";
+            C << nl << "__is->startException();";
+            C << nl << "__readImpl(__is);";
             if(preserved)
             {
-                C << nl << "__slicedData = __inS->endException(true);";
+                C << nl << "__slicedData = __is->endException(true);";
             }
             else
             {
-                C << nl << "__inS->endException(false);";
+                C << nl << "__is->endException(false);";
             }
             C << eb;
 
             C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__readImpl(const ::Ice::InputStreamPtr& __inS)";
+              << "::__readImpl(const ::Ice::InputStreamPtr& __is)";
             C << sb;
-            C << nl << "__inS->startSlice();";
-            for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-            {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), false, "", (*q)->getMetaData(), 
-                                                _useWstring);
-            }
-            C << nl << "__inS->endSlice();";
+            C << nl << "__is->startSlice();";
+            writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), false);
+            C << nl << "__is->endSlice();";
             if(base)
             {
-                emitUpcall(base, "::__readImpl(__inS);");
+                emitUpcall(base, "::__readImpl(__is);");
             }
             C << eb;
         }
@@ -1037,53 +1017,12 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             C << eb;
         }
 
-        //
-        // Override __usesClasses() if necessary.
-        //
-        if(p->usesClasses())
-        {
-            if(!base || (base && !base->usesClasses()))
-            {
-                H << nl << "virtual bool __usesClasses() const;";
-
-                C << sp << nl << "bool";
-                C << nl << scoped.substr(2) << "::__usesClasses() const";
-                C << sb;
-                C << nl << "return true;";
-                C << eb;
-            }
-        }
-        else if(preserved && !basePreserved)
-        {
-            if(!base || (base && !base->usesClasses()))
-            {
-                //
-                // Although a preserved exception may not contain any class data members,
-                // the preserved slices of derived exceptions may contain class data members.
-                //
-                H << sp << nl << "virtual bool __usesClasses() const;";
-                H << nl << "virtual void __usesClasses(bool);";
-                C << sp << nl << "bool" << nl << scoped.substr(2) << "::__usesClasses() const";
-                C << sb;
-                C << nl << "return __usingClasses;";
-                C << eb;
-                C << sp << nl << "void" << nl << scoped.substr(2) << "::__usesClasses(bool __b)";
-                C << sb;
-                C << nl << "__usingClasses = __b;";
-                C << eb;
-            }
-        }
-
         if(preserved && !basePreserved)
         {
             H.zeroIndent();
             H << sp << nl << "protected:";
             H.restoreIndent();
             H << sp << nl << "::Ice::SlicedDataPtr __slicedData;";
-            if(!p->usesClasses() && (!base || (base && !base->usesClasses())))
-            {
-                H << nl << "bool __usingClasses;";
-            }
         }
 
         factoryName = "__F" + p->flattenedScope() + p->name();
@@ -1216,7 +1155,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
         vector<string> types;
         for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
-            string typeName = inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+            string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
             types.push_back(typeName);
             paramDecls.push_back(typeName + " __ice_" + (*q)->name());
         }
@@ -1340,15 +1279,15 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
         if(_stream)
         {
-            H << nl << dllExport << "void ice_write(const ::Ice::OutputStreamPtr&) const;";
-            H << nl << dllExport << "void ice_read(const ::Ice::InputStreamPtr&);";
+            H << nl << dllExport << "void __write(const ::Ice::OutputStreamPtr&) const;";
+            H << nl << dllExport << "void __read(const ::Ice::InputStreamPtr&);";
         }
 
         C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::IceInternal::BasicStream* __os) const";
         C << sb;
         for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), true, "", true, (*q)->getMetaData());
+            writeMarshalUnmarshalDataMember(C, *q, true);
         }
         C << eb;
 
@@ -1356,78 +1295,35 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         C << sb;
         for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
         {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), false, "", true, (*q)->getMetaData());
+            writeMarshalUnmarshalDataMember(C, *q, false);
         }
         C << eb;
 
         if(_stream)
         {
-            C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::ice_write(const ::Ice::OutputStreamPtr& __outS) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __os) const";
             C << sb;
             for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
             {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), true, "", (*q)->getMetaData(), 
-                                                _useWstring);
+                C << nl << "__os->write(" << fixKwd((*q)->name()) << ");";
             }
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::ice_read(const ::Ice::InputStreamPtr& __inS)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __is)";
             C << sb;
             for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
             {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), false, "", (*q)->getMetaData(), 
-                                                _useWstring);
+                C << nl << "__is->read(" << fixKwd((*q)->name()) << ");";
             }
             C << eb;
         }
     }
 
     H << eb << ';';
+
     if(findMetaData(p->getMetaData()) == "class")
     {
         H << sp << nl << "typedef ::IceUtil::Handle< " << scoped << "> " << p->name() + "Ptr;";
-
-        if(!p->isLocal() && _stream)
-        {
-            H << sp << nl << "void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
-              << p->name() << "Ptr&);";
-            H << nl << "void ice_read" << p->name() << "(const ::Ice::InputStreamPtr&, " << p->name()
-              << "Ptr&);";
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __outS, const " << fixKwd(p->scoped() + "Ptr") << "& __v)";
-            C << sb;
-            C << nl << "__v->ice_write(__outS);";
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __inS, " << fixKwd(p->scoped() + "Ptr") << "& __v)";
-            C << sb;
-            C << nl << "__v->ice_read(__inS);";
-            C << eb;
-        }
-    }
-    else
-    {
-        if(!p->isLocal() && _stream)
-        {
-            H << sp << nl << dllExport << "void ice_write" << p->name() << "(const ::Ice::OutputStreamPtr&, const "
-              << name << "&);";
-            H << nl << dllExport << "void ice_read" << p->name() << "(const ::Ice::InputStreamPtr&, " << name << "&);";
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& __v)";
-            C << sb;
-            C << nl << "__v.ice_write(__outS);";
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& __v)";
-            C << sb;
-            C << nl << "__v.ice_read(__inS);";
-            C << eb;
-        }
     }
 
     _useWstring = resetUseWstring(_useWstringHist);
@@ -1438,7 +1334,8 @@ Slice::Gen::TypesVisitor::visitDataMember(const DataMemberPtr& p)
 {
     string name = fixKwd(p->name());
     TypePtr type = p->type();
-    if(p->container() != 0 && (StructPtr::dynamicCast(p->container()) || ExceptionPtr::dynamicCast(p->container())) &&
+    if(p->container() != 0 && 
+       (StructPtr::dynamicCast(p->container()) || ExceptionPtr::dynamicCast(p->container())) &&
        SequencePtr::dynamicCast(type))
     {
         SequencePtr s = SequencePtr::dynamicCast(type);
@@ -1457,8 +1354,7 @@ Slice::Gen::TypesVisitor::visitDataMember(const DataMemberPtr& p)
         }
     }
 
-    string s = typeToString(p->type(), p->getMetaData(), _useWstring);
-    H << nl << s << ' ' << name << ';';
+    H << nl << typeToString(p->type(), p->optional(), p->getMetaData(), _useWstring) << ' ' << name << ';';
 }
 
 void
@@ -1483,201 +1379,6 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             H << nl << "typedef ::std::vector<" << (s[0] == ':' ? " " : "") << s << "> " << name << ';';
         }
     }
-
-    BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-    if(!p->isLocal())
-    {
-        string scoped = fixKwd(p->scoped());
-        string scope = fixKwd(p->scope());
-
-        if(protobuf || !seqType.empty())
-        {
-            string typeName = name;
-            string scopedName = scoped;
-            if(protobuf && !seqType.empty())
-            {
-                typeName = seqType;
-                scopedName = seqType;
-            }
-            H << nl << _dllExport << "void __write" << name << "(::IceInternal::BasicStream*, const "
-              << typeName << "&);";
-            H << nl << _dllExport << "void __read" << name << "(::IceInternal::BasicStream*, "
-              << typeName << "&);";
-
-            if(_stream)
-            {
-                H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name()
-                  << "(const ::Ice::OutputStreamPtr&, const " << typeName << "&);";
-                H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << p->name()
-                  << "(const ::Ice::InputStreamPtr&, " << typeName << "&);";
-            }
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "__write" << name <<
-                "(::IceInternal::BasicStream* __os, const " << scopedName << "& v)";
-            C << sb;
-            if(protobuf)
-            {
-                C << nl << "::std::vector< ::Ice::Byte> data(v.ByteSize());";
-                C << nl << "if(!v.IsInitialized())";
-                C << sb;
-                C << nl << "throw ::Ice::MarshalException(__FILE__, __LINE__, \"type not fully initialized: \" + v.InitializationErrorString());";
-                C << eb;
-                C << nl << "if(!v.SerializeToArray(&data[0], data.size()))";
-                C << sb;
-                C << nl << "throw ::Ice::MarshalException(__FILE__, __LINE__, \"SerializeToArray failed\");";
-                C << eb;
-                C << nl << "__os->write(&data[0], &data[0] + data.size());";
-            }
-            else
-            {
-                C << nl << "::Ice::Int size = static_cast< ::Ice::Int>(v.size());";
-                C << nl << "__os->writeSize(size);";
-                C << nl << "for(" << name << "::const_iterator p = v.begin(); p != v.end(); ++p)";
-                C << sb;
-                writeMarshalUnmarshalCode(C, type, "(*p)", true);
-                C << eb;
-            }
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "__read" << name
-              << "(::IceInternal::BasicStream* __is, " << scopedName << "& v)";
-            C << sb;
-            if(protobuf)
-            {
-                C << nl << "::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> data;";
-                C << nl << "__is->read(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;
-            }
-            else
-            {
-                C << nl << "::Ice::Int sz;";
-                C << nl << "__is->readAndCheckSeqSize(" << type->minWireSize() << ", sz);";
-                C << nl << name << "(sz).swap(v);";
-                C << nl << "for(" << name << "::iterator p = v.begin(); p != v.end(); ++p)";
-                C << sb;
-                writeMarshalUnmarshalCode(C, type, "(*p)", false);
-                C << eb;
-            }
-            C << eb;
-
-            if(_stream)
-            {
-                C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-                  << "(const ::Ice::OutputStreamPtr& __outS, const " << scopedName << "& v)";
-                C << sb;
-                if(protobuf)
-                {
-                    C << nl << "::std::vector< ::Ice::Byte> data(v.ByteSize());";
-                    C << nl << "if(!v.IsInitialized())";
-                    C << sb;
-                    C << nl << "throw ::Ice::MarshalException(__FILE__, __LINE__, \"type not fully initialized: \" + v.InitializationErrorString());";
-                    C << eb;
-                    C << nl << "v.SerializeToArray(&data[0], data.size());";
-
-                    C << nl << "__outS->write(data);";
-                }
-                else
-                {
-                    C << nl << "__outS->writeSize(::Ice::Int(v.size()));";
-                    C << nl << scopedName << "::const_iterator p;";
-                    C << nl << "for(p = v.begin(); p != v.end(); ++p)";
-                    C << sb;
-                    writeStreamMarshalUnmarshalCode(C, type, "(*p)", true, "", StringList(), _useWstring);
-                    C << eb;
-                }
-                C << eb;
-
-                C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-                  << "(const ::Ice::InputStreamPtr& __inS, " << scopedName << "& v)";
-                C << sb;
-                if(protobuf)
-                {
-                    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;
-                }
-                else
-                {
-                    C << nl << "::Ice::Int sz = __inS->readAndCheckSeqSize(" << type->minWireSize() << ");";
-                    C << nl << scopedName << "(sz).swap(v);";
-                    C << nl << scopedName << "::iterator p;";
-                    C << nl << "for(p = v.begin(); p != v.end(); ++p)";
-                    C << sb;
-                    writeStreamMarshalUnmarshalCode(C, type, "(*p)", false, "", StringList(), _useWstring);
-                    C << eb;
-                }
-                C << eb;
-            }
-        }
-        else if(!builtin || builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindObjectProxy)
-        {
-            H << nl << _dllExport << "void __write" << name << "(::IceInternal::BasicStream*, const " << s
-              << "*, const " << s << "*);";
-            H << nl << _dllExport << "void __read" << name << "(::IceInternal::BasicStream*, " << name << "&);";
-
-            if(_stream)
-            {
-                H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name()
-                  << "(const ::Ice::OutputStreamPtr&, const " << name << "&);";
-                H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << p->name()
-                  << "(const ::Ice::InputStreamPtr&, " << name << "&);";
-            }
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "__write" << name
-              << "(::IceInternal::BasicStream* __os, const " << s << "* begin, const " << s << "* end)";
-            C << sb;
-            C << nl << "::Ice::Int size = static_cast< ::Ice::Int>(end - begin);";
-            C << nl << "__os->writeSize(size);";
-            C << nl << "for(int i = 0; i < size; ++i)";
-            C << sb;
-            writeMarshalUnmarshalCode(C, type, "begin[i]", true);
-            C << eb;
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "__read" << name
-              << "(::IceInternal::BasicStream* __is, " << scoped << "& v)";
-            C << sb;
-            C << nl << "::Ice::Int sz;";
-            C << nl << "__is->readAndCheckSeqSize(" << type->minWireSize() << ", sz);";
-            C << nl << "v.resize(sz);";
-            C << nl << "for(int i = 0; i < sz; ++i)";
-            C << sb;
-            writeMarshalUnmarshalCode(C, type, "v[i]", false);
-            C << eb;
-            C << eb;
-
-            if(_stream)
-            {
-                C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-                  << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
-                C << sb;
-                C << nl << "__outS->writeSize(::Ice::Int(v.size()));";
-                C << nl << scoped << "::const_iterator p;";
-                C << nl << "for(p = v.begin(); p != v.end(); ++p)";
-                C << sb;
-                writeStreamMarshalUnmarshalCode(C, type, "(*p)", true, "", StringList(), _useWstring);
-                C << eb;
-                C << eb;
-
-                C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-                  << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
-                C << sb;
-                C << nl << "::Ice::Int sz = __inS->readAndCheckSeqSize(" << type->minWireSize() << ");";
-                C << nl << "v.resize(sz);";
-                C << nl << "for(int i = 0; i < sz; ++i)";
-                C << sb;
-                writeStreamMarshalUnmarshalCode(C, type, "v[i]", false, "", StringList(), _useWstring);
-                C << eb;
-                C << eb;
-            }
-        }
-    }
 }
 
 void
@@ -1709,78 +1410,6 @@ Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
     }
     string vs = typeToString(valueType, p->valueMetaData(), _useWstring);
     H << sp << nl << "typedef ::std::map<" << ks << ", " << vs << "> " << name << ';';
-
-    if(!p->isLocal())
-    {
-        string scoped = fixKwd(p->scoped());
-        string scope = fixKwd(p->scope());
-
-        H << nl << _dllExport << "void __write" << name << "(::IceInternal::BasicStream*, const " << name << "&);";
-        H << nl << _dllExport << "void __read" << name << "(::IceInternal::BasicStream*, " << name << "&);";
-
-        if(_stream)
-        {
-            H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr&, const " << name << "&);";
-            H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr&, " << name << "&);";
-        }
-
-        C << sp << nl << "void" << nl << scope.substr(2) << "__write" << name
-          << "(::IceInternal::BasicStream* __os, const " << scoped << "& v)";
-        C << sb;
-        C << nl << "__os->writeSize(::Ice::Int(v.size()));";
-        C << nl << scoped << "::const_iterator p;";
-        C << nl << "for(p = v.begin(); p != v.end(); ++p)";
-        C << sb;
-        writeMarshalUnmarshalCode(C, keyType, "p->first", true);
-        writeMarshalUnmarshalCode(C, valueType, "p->second", true);
-        C << eb;
-        C << eb;
-
-        C << sp << nl << "void" << nl << scope.substr(2) << "__read" << name
-          << "(::IceInternal::BasicStream* __is, " << scoped << "& v)";
-        C << sb;
-        C << nl << "::Ice::Int sz;";
-        C << nl << "__is->readSize(sz);";
-        C << nl << "while(sz--)";
-        C << sb;
-        C << nl << "::std::pair<const " << ks << ", " << vs << "> pair;";
-        const string pf = string("const_cast<") + ks + "&>(pair.first)";
-        writeMarshalUnmarshalCode(C, keyType, pf, false);
-        C << nl << scoped << "::iterator __i = v.insert(v.end(), pair);";
-        writeMarshalUnmarshalCode(C, valueType, "__i->second", false);
-        C << eb;
-        C << eb;
-
-        if(_stream)
-        {
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
-            C << sb;
-            C << nl << "__outS->writeSize(::Ice::Int(v.size()));";
-            C << nl << scoped << "::const_iterator p;";
-            C << nl << "for(p = v.begin(); p != v.end(); ++p)";
-            C << sb;
-            writeStreamMarshalUnmarshalCode(C, keyType, "p->first", true, "", p->keyMetaData(), _useWstring);
-            writeStreamMarshalUnmarshalCode(C, valueType, "p->second", true, "", p->valueMetaData(), _useWstring);
-            C << eb;
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
-            C << sb;
-            C << nl << "::Ice::Int sz = __inS->readSize();";
-            C << nl << "while(sz--)";
-            C << sb;
-            C << nl << "::std::pair<const " << ks << ", " << vs << "> pair;";
-            writeStreamMarshalUnmarshalCode(C, keyType, pf, false, "", p->keyMetaData(), _useWstring);
-            C << nl << scoped << "::iterator __i = v.insert(v.end(), pair);";
-            writeStreamMarshalUnmarshalCode(C, valueType, "__i->second", false, "", p->valueMetaData(), _useWstring);
-            C << eb;
-            C << eb;
-        }
-    }
 }
 
 void
@@ -1800,77 +1429,6 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
         }
     }
     H << eb << ';';
-
-    string scoped = fixKwd(p->scoped());
-    string scope = fixKwd(p->scope());
-
-    if(!p->isLocal())
-    {
-        size_t sz = enumerators.size();
-        assert(sz <= 0x7fffffff); // 64-bit enums are not supported
-
-        H << sp << nl << _dllExport << "void __write(::IceInternal::BasicStream*, " << name << ");";
-        H << nl << _dllExport << "void __read(::IceInternal::BasicStream*, " << name << "&);";
-
-        if(_stream)
-        {
-            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 << "&);";
-        }
-
-        C << sp << nl << "void" << nl << scope.substr(2) << "__write(::IceInternal::BasicStream* __os, " << scoped
-          << " v)";
-        C << sb;
-        if(sz <= 0x7f)
-        {
-            C << nl << "__os->write(static_cast< ::Ice::Byte>(v), " << sz << ");";
-        }
-        else if(sz <= 0x7fff)
-        {
-            C << nl << "__os->write(static_cast< ::Ice::Short>(v), " << sz << ");";
-        }
-        else
-        {
-            C << nl << "__os->write(static_cast< ::Ice::Int>(v), " << sz << ");";
-        }
-        C << eb;
-
-        C << sp << nl << "void" << nl << scope.substr(2) << "__read(::IceInternal::BasicStream* __is, " << scoped
-          << "& v)";
-        C << sb;
-        if(sz <= 0x7f)
-        {
-            C << nl << "::Ice::Byte val;";
-        }
-        else if(sz <= 0x7fff)
-        {
-            C << nl << "::Ice::Short val;";
-        }
-        else
-        {
-            C << nl << "::Ice::Int val;";
-        }
-        C << nl << "__is->read(val, " << sz << ");";
-        C << nl << "v = static_cast< " << scoped << ">(val);";
-        C << eb;
-
-        if(_stream)
-        {
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __outS, " << scoped << " v)";
-            C << sb;
-            C << nl << "__outS->write(v);";
-            C << eb;
-
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
-            C << sb;
-            C << nl << "__inS->read(v);";
-            C << eb;
-        }
-    }
 }
 
 void
@@ -1957,6 +1515,8 @@ Slice::Gen::ProxyDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
     string scoped = fixKwd(p->scoped());
 
     H << sp << nl << "class " << name << ';';
+    H << nl << _dllExport << "void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy" 
+      << scoped << ">&);";
     H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);";
 }
 
@@ -2066,6 +1626,23 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p)
       << "::IceProxy::Ice::Object* ::IceProxy" << scope << "upCast(::IceProxy" << scoped
       << "* p) { return p; }";
 
+    C << sp;
+    C << nl << "void" << nl << "::IceProxy" << scope << "__read(::IceInternal::BasicStream* __is, "
+      << "::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">& v)";
+    C << sb;
+    C << nl << "::Ice::ObjectPrx proxy;";
+    C << nl << "__is->read(proxy);";
+    C << nl << "if(!proxy)";
+    C << sb;
+    C << nl << "v = 0;";
+    C << eb;
+    C << nl << "else";
+    C << sb;
+    C << nl << "v = new ::IceProxy" << scoped << ';';
+    C << nl << "v->__copyFrom(proxy);";
+    C << eb;
+    C << eb;
+
     return true;
 }
 
@@ -2444,8 +2021,9 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     string scope = fixKwd(p->scope());
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->getMetaData(), _useWstring | TypeContextAMIEnd);
-    string retSEndAMI = returnTypeToString(ret, p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd);
+    bool retIsOpt = p->returnIsOptional();
+    string retS = returnTypeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextAMIEnd);
+    string retSEndAMI = returnTypeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd);
 
     ContainerPtr container = p->container();
     ClassDefPtr cl = ClassDefPtr::dynamicCast(container);
@@ -2476,12 +2054,13 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         string typeStringEndAMI;
         if((*q)->isOutParam())
         {
-            typeString = outputTypeToString((*q)->type(), metaData, _useWstring | TypeContextAMIEnd);
-            typeStringEndAMI = outputTypeToString((*q)->type(), metaData, _useWstring | TypeContextAMIPrivateEnd);
+            typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring | TypeContextAMIEnd);
+            typeStringEndAMI = outputTypeToString((*q)->type(), (*q)->optional(), metaData,
+                                                  _useWstring | TypeContextAMIPrivateEnd);
         }
         else
         {
-            typeString = inputTypeToString((*q)->type(), metaData, _useWstring);
+            typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
         }
 
         params.push_back(typeString);
@@ -2517,7 +2096,8 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     bool generatePrivateEnd = retS != retSEndAMI || outParamsDeclAMI != outParamsDeclEndAMI;
     if(ret && generatePrivateEnd)
     {
-        string typeStringEndAMI = outputTypeToString(ret, p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd);
+        string typeStringEndAMI = outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), 
+                                                     _useWstring | TypeContextAMIPrivateEnd);
         outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "__ret");
     }
 
@@ -2680,7 +2260,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         {
             C << nl << "__os->format(" << formatTypeToString(format) << ");";
         }
-        writeMarshalCode(C, inParams, 0, StringList(), TypeContextInParam);
+        writeMarshalCode(C, inParams, 0, TypeContextInParam);
         C << nl << "__result->__endWriteParams();";
     }
     C << nl << "__result->__send(true);";
@@ -2705,7 +2285,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         // access violations errors with the test/Ice/slicing/objects test on VC9 
         // and Windows 64 bits when compiled with optimization (see bug 4400).
         //
-        writeAllocateCode(C, ParamDeclList(), ret, p->getMetaData(), _useWstring | TypeContextAMIEnd);
+        writeAllocateCode(C, ParamDeclList(), p, _useWstring | TypeContextAMIEnd);
 
         C << nl << "if(!__result->__wait())";
         C << sb;
@@ -2741,7 +2321,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         if(ret || !outParams.empty())
         {
             C << nl << "::IceInternal::BasicStream* __is = __result->__startReadParams();";
-            writeUnmarshalCode(C, outParams, ret, p->getMetaData(), _useWstring | TypeContextAMIEnd);
+            writeUnmarshalCode(C, outParams, p, _useWstring | TypeContextAMIEnd);
             C << nl << "__result->__endReadParams();";
         }
         else
@@ -2801,7 +2381,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         if(ret || !outParams.empty())
         {
             C << nl << "::IceInternal::BasicStream* __is = __result->__startReadParams();";
-            writeUnmarshalCode(C, outParams, ret, p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd);
+            writeUnmarshalCode(C, outParams, p, _useWstring | TypeContextAMIPrivateEnd);
             C << nl << "__result->__endReadParams();";
         }
         else
@@ -3036,7 +2616,7 @@ Slice::Gen::DelegateVisitor::visitOperation(const OperationPtr& p)
     string name = fixKwd(p->name());
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     vector<string> params;
 
@@ -3044,24 +2624,15 @@ Slice::Gen::DelegateVisitor::visitOperation(const OperationPtr& p)
     for(ParamDeclList::const_iterator q = paramList.begin(); q != paramList.end(); ++q)
     {
         StringList metaData = (*q)->getMetaData();
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC==0x550)
-        //
-        // Work around for Sun CC 5.5 bug #4853566
-        //
         string typeString;
         if((*q)->isOutParam())
         {
-            typeString = outputTypeToString((*q)->type(), metaData, _useWstring);
+            typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
         }
         else
         {
-            typeString = inputTypeToString((*q)->type(), metaData, _useWstring);
+            typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
         }
-#else
-        string typeString = (*q)->isOutParam() ?  outputTypeToString((*q)->type(), metaData, _useWstring)
-            : inputTypeToString((*q)->type(), metaData, _useWstring);
-#endif
-
         params.push_back(typeString);
     }
 
@@ -3176,7 +2747,7 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
     string scoped = fixKwd(p->scoped());
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     vector<string> params;
     vector<string> paramsDecl;
@@ -3194,12 +2765,12 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
         if(isOutParam)
         {
             outParams.push_back(*q);
-            typeString = outputTypeToString(type, metaData, _useWstring);
+            typeString = outputTypeToString(type, (*q)->optional(), metaData, _useWstring);
         }
         else
         {
             inParams.push_back(*q);
-            typeString = inputTypeToString(type, metaData, _useWstring);
+            typeString = inputTypeToString(type, (*q)->optional(), metaData, _useWstring);
         }
 
         params.push_back(typeString);
@@ -3233,7 +2804,7 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
                 C << nl << "__os->format(" << formatTypeToString(format) << ");";
             }
         }
-        writeMarshalCode(C, inParams, 0, StringList(), TypeContextInParam);
+        writeMarshalCode(C, inParams, 0, TypeContextInParam);
         C << nl << "__og.endWriteParams();";
         C << eb;
         C << nl << "catch(const ::Ice::LocalException& __ex)";
@@ -3248,7 +2819,7 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
     // Declare the return __ret variable at the top-level scope to
     // enable NRVO with GCC (see also bug #3619).
     //
-    writeAllocateCode(C, ParamDeclList(), ret, p->getMetaData(), _useWstring);
+    writeAllocateCode(C, ParamDeclList(), p, _useWstring);
     if(!p->returnsData())
     {
         C << nl << "if(__og.hasResponse())";
@@ -3312,19 +2883,10 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
     C << eb;
     C << eb;
 
-    for(ParamDeclList::const_iterator opi = outParams.begin(); opi != outParams.end(); ++opi)
-    {
-        StructPtr st = StructPtr::dynamicCast((*opi)->type());
-        if(st && findMetaData(st->getMetaData()) == "class")
-        {
-            C << nl << fixKwd((*opi)->name()) << " = new " << fixKwd(st->scoped()) << ";";
-        }
-    }
-
     if(ret || !outParams.empty())
     {
         C << nl << "::IceInternal::BasicStream* __is = __og.startReadParams();";
-        writeUnmarshalCode(C, outParams, ret, p->getMetaData());
+        writeUnmarshalCode(C, outParams, p);
         C << nl << "__og.endReadParams();";
     }
     else
@@ -3454,7 +3016,7 @@ Slice::Gen::DelegateDVisitor::visitOperation(const OperationPtr& p)
     string scoped = fixKwd(p->scoped());
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     vector<string> params;
     vector<string> paramsDecl;
@@ -3468,23 +3030,15 @@ Slice::Gen::DelegateDVisitor::visitOperation(const OperationPtr& p)
         string paramName = fixKwd((*q)->name());
 
         StringList metaData = (*q)->getMetaData();
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC==0x550)
-        //
-        // Work around for Sun CC 5.5 bug #4853566
-        //
         string typeString;
         if((*q)->isOutParam())
         {
-            typeString = outputTypeToString((*q)->type(), metaData, _useWstring);
+            typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
         }
         else
         {
-            typeString = inputTypeToString((*q)->type(), metaData, _useWstring);
+            typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
         }
-#else
-        string typeString = (*q)->isOutParam() ?  outputTypeToString((*q)->type(), metaData, _useWstring)
-                                               : inputTypeToString((*q)->type(), metaData, _useWstring);
-#endif
 
         params.push_back(typeString);
         paramsDecl.push_back(typeString + ' ' + paramName);
@@ -3533,7 +3087,7 @@ Slice::Gen::DelegateDVisitor::visitOperation(const OperationPtr& p)
         C << sp << nl << "_DirectI" << spar;
         if(ret)
         {
-            string resultRef = outputTypeToString(ret, p->getMetaData(), _useWstring);
+            string resultRef = outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
             C << resultRef + " __result";
         }
         C << directParamsDecl << "const ::Ice::Current& __current" << epar << " : ";
@@ -3610,7 +3164,7 @@ Slice::Gen::DelegateDVisitor::visitOperation(const OperationPtr& p)
         C << nl;
         if(ret)
         {
-            string resultRef= outputTypeToString(ret, p->getMetaData(), _useWstring);
+            string resultRef= outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
             C << nl << resultRef << " _result;";
         }
 
@@ -3741,6 +3295,7 @@ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
         H << nl << _dllExport << "::Ice::Object* upCast(" << scoped << "*);";
         H << nl << "typedef ::IceInternal::Handle< " << scoped << "> " << p->name() << "Ptr;";
         H << nl << "typedef ::IceInternal::ProxyHandle< ::IceProxy" << scoped << "> " << p->name() << "Prx;";
+        H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, ::Ice::ObjectPtr&);";
     }
     else
     {
@@ -3873,7 +3428,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p)
 
     for(q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
     {
-        string typeName = inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+        string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
         allTypes.push_back(typeName);
         allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
     }
@@ -3882,7 +3437,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p)
     {
         if(p->hasDefaultValues())
         {
-            H << name << "() :";
+            H << sp << nl << name << "() :";
             H.inc();
             writeDataMemberInitializers(H, dataMembers, _useWstring);
             H.dec();
@@ -4326,12 +3881,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
           << "::__writeImpl(::IceInternal::BasicStream* __os) const";
         C << sb;
         C << nl << "__os->startWriteSlice(ice_staticId(), " << (!base ? "true" : "false") << ");";
-        DataMemberList dataMembers = p->dataMembers();
-        DataMemberList::const_iterator q;
-        for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-        {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), true, "", true, (*q)->getMetaData());
-        }
+        writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), true);
         C << nl << "__os->endWriteSlice();";
         if(base)
         {
@@ -4358,10 +3908,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         C << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::IceInternal::BasicStream* __is)";
         C << sb;
         C << nl << "__is->startReadSlice();";
-        for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-        {
-            writeMarshalUnmarshalCode(C, (*q)->type(), fixKwd((*q)->name()), false, "", true, (*q)->getMetaData());
-        }
+        writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), false);
         C << nl << "__is->endReadSlice();";
         if(base)
         {
@@ -4371,63 +3918,54 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
 
         if(_stream)
         {
-            C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __os) const";
             C << sb;
             if(preserved)
             {
-                C << nl << "__outS->startObject(__slicedData);";
+                C << nl << "__os->startObject(__slicedData);";
             }
             else
             {
-                C << nl << "__outS->startObject(0);";
+                C << nl << "__os->startObject(0);";
             }
-            C << nl << "__writeImpl(__outS);";
-            C << nl << "__outS->endObject();";
+            C << nl << "__writeImpl(__os);";
+            C << nl << "__os->endObject();";
             C << eb;
 
             C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__writeImpl(const ::Ice::OutputStreamPtr& __outS) const";
+              << "::__writeImpl(const ::Ice::OutputStreamPtr& __os) const";
             C << sb;
-            C << nl << "__outS->startSlice(ice_staticId(), " << (!base ? "true" : "false") << ");";
-            for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-            {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), true, "", (*q)->getMetaData(), 
-                                                _useWstring);
-            }
-            C << nl << "__outS->endSlice();";
+            C << nl << "__os->startSlice(ice_staticId(), " << (!base ? "true" : "false") << ");";
+            writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), true);
+            C << nl << "__os->endSlice();";
             if(base)
             {
-                emitUpcall(base, "::__writeImpl(__outS);");
+                emitUpcall(base, "::__writeImpl(__os);");
             }
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __inS)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __is)";
             C << sb;
-            C << nl << "__inS->startObject();";
-            C << nl << "__readImpl(__inS);";
+            C << nl << "__is->startObject();";
+            C << nl << "__readImpl(__is);";
             if(preserved)
             {
-                C << nl << "__slicedData = __inS->endObject(true);";
+                C << nl << "__slicedData = __is->endObject(true);";
             }
             else
             {
-                C << nl << "__inS->endObject(false);";
+                C << nl << "__is->endObject(false);";
             }
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(const ::Ice::InputStreamPtr& __inS)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(const ::Ice::InputStreamPtr& __is)";
             C << sb;
-            C << nl << "__inS->startSlice();";
-            for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
-            {
-                writeStreamMarshalUnmarshalCode(C, (*q)->type(), (*q)->name(), false, "", (*q)->getMetaData(),
-                                                _useWstring);
-            }
-            C << nl << "__inS->endSlice();";
+            C << nl << "__is->startSlice();";
+            writeMarshalUnmarshalDataMembers(C, p->dataMembers(), p->orderedOptionalDataMembers(), false);
+            C << nl << "__is->endSlice();";
             if(base)
             {
-                emitUpcall(base, "::__readImpl(__inS);");
+                emitUpcall(base, "::__readImpl(__is);");
             }
             C << eb;
         }
@@ -4517,51 +4055,15 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         }
     }
 
-    bool inProtected = false;
-
-    if(!p->isAbstract())
-    {
-        //
-        // We add a protected destructor to force heap instantiation of the class.
-        //
-        H.dec();
-        H << sp << nl << "protected:";
-        H.inc();
-        H << sp << nl << "virtual ~" << fixKwd(p->name()) << "() {}";
-
-        if(!_doneStaticSymbol)
-        {
-            H << sp << nl << "friend class " << p->name() << "__staticInit;";
-        }
-
-        inProtected = true;
-    }
-
     //
     // Emit data members. Access visibility may be specified by metadata.
     //
+    bool inProtected = false;
     DataMemberList dataMembers = p->dataMembers();
     DataMemberList::const_iterator q;
     bool prot = p->hasMetaData("protected");
     for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
-        TypePtr type = (*q)->type();
-        if(SequencePtr::dynamicCast(type))
-        {
-            SequencePtr s = SequencePtr::dynamicCast(type);
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(s->type());
-            if(builtin && builtin->kind() == Builtin::KindByte)
-            {
-                StringList metaData = s->getMetaData();
-                bool protobuf;
-                findMetaData(s, metaData, protobuf);
-                if(protobuf)
-                {
-                    emitWarning((*q)->file(), (*q)->line(), "protobuf cannot be used as a class member in C++");
-                }
-            }
-        }
-
         if(prot || (*q)->hasMetaData("protected"))
         {
             if(!inProtected)
@@ -4583,9 +4085,27 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             }
         }
 
-        string name = fixKwd((*q)->name());
-        string s = typeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
-        H << sp << nl << s << ' ' << name << ';';
+        emitDataMember(*q);
+    }
+
+    if(!p->isAbstract())
+    {
+        //
+        // We add a protected destructor to force heap instantiation of the class.
+        //
+        if(!inProtected)
+        {
+            H.dec();
+            H << sp << nl << "protected:";
+            H.inc();
+            inProtected = true;
+        }
+        H << sp << nl << "virtual ~" << fixKwd(p->name()) << "() {}";
+
+        if(!_doneStaticSymbol)
+        {
+            H << sp << nl << "friend class " << p->name() << "__staticInit;";
+        }
     }
 
     if(!p->isLocal() && preserved && !basePreserved)
@@ -4640,12 +4160,10 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
     {
         C << sp << nl << "void "
 	  << (_dllExport.empty() ? "" : "ICE_DECLSPEC_EXPORT ");
-        C << nl << scope.substr(2) << "__patch__" << p->name() << "Ptr(void* __addr, ::Ice::ObjectPtr& v)";
+        C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, ::Ice::ObjectPtr& v)";
         C << sb;
-        C << nl << scope << p->name() << "Ptr* p = static_cast< " << scope << p->name() << "Ptr*>(__addr);";
-        C << nl << "assert(p);";
-        C << nl << "*p = " << scope << p->name() << "Ptr::dynamicCast(v);";
-        C << nl << "if(v && !*p)";
+        C << nl << "handle = " << scope << p->name() << "Ptr::dynamicCast(v);";
+        C << nl << "if(v && !handle)";
         C << sb;
         C << nl << "IceInternal::Ex::throwUOE(" << scoped << "::ice_staticId(), v->ice_id());";
         C << eb;
@@ -4686,7 +4204,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
     string scope = fixKwd(p->scope());
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     string params = "(";
     string paramsDecl = "(";
@@ -4714,12 +4232,12 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
         if(isOutParam)
         {
             outParams.push_back(*q);
-            typeString = outputTypeToString(type, (*q)->getMetaData(), _useWstring);
+            typeString = outputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), _useWstring);
         }
         else
         {
             inParams.push_back(*q);
-            typeString = inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+            typeString = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
         }
 
         if(q != paramList.begin())
@@ -4823,8 +4341,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
             if(!inParams.empty())
             {
                 C << nl << "::IceInternal::BasicStream* __is = __inS.startReadParams();";
-                writeAllocateCode(C, inParams, 0, StringList(), _useWstring | TypeContextInParam);
-                writeUnmarshalCode(C, inParams, 0, StringList(), TypeContextInParam);
+                writeAllocateCode(C, inParams, 0, _useWstring | TypeContextInParam);
+                writeUnmarshalCode(C, inParams, 0, TypeContextInParam);
                 C << nl << "__inS.endReadParams();";
             }
             else
@@ -4832,7 +4350,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
                 C << nl << "__inS.readEmptyParams();";
             }
 
-            writeAllocateCode(C, outParams, 0, StringList(), _useWstring);
+            writeAllocateCode(C, outParams, 0, _useWstring);
             if(!throws.empty())
             {
                 C << nl << "try";
@@ -4852,7 +4370,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
                 {
                     C << nl << "__os->format(" << formatTypeToString(format) << ");";
                 }
-                writeMarshalCode(C, outParams, ret, p->getMetaData());
+                writeMarshalCode(C, outParams, p);
                 C << nl << "__inS.__endWriteParams(true);";
             }
             else
@@ -4887,8 +4405,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
             if(!inParams.empty())
             {
                 C << nl << "::IceInternal::BasicStream* __is = __inS.startReadParams();";
-                writeAllocateCode(C, inParams, 0, StringList(), _useWstring | TypeContextInParam);
-                writeUnmarshalCode(C, inParams, 0, StringList(), TypeContextInParam);
+                writeAllocateCode(C, inParams, 0, _useWstring | TypeContextInParam);
+                writeUnmarshalCode(C, inParams, 0, TypeContextInParam);
                 C << nl << "__inS.endReadParams();";
             }
             else
@@ -4929,11 +4447,12 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
             string typeString;
             if((*r)->isOutParam())
             {
-                typeString = outputTypeToString((*r)->type(), metaData, _useWstring | TypeContextAMIEnd);
+                typeString = outputTypeToString((*r)->type(), (*r)->optional(), metaData, 
+                                                _useWstring | TypeContextAMIEnd);
             }
             else
             {
-                typeString = inputTypeToString((*r)->type(), metaData, _useWstring);
+                typeString = inputTypeToString((*r)->type(), (*r)->optional(), metaData, _useWstring);
             }
 
             if(!(*r)->isOutParam())
@@ -4966,6 +4485,30 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 }
 
 void
+Slice::Gen::ObjectVisitor::emitDataMember(const DataMemberPtr& p)
+{
+    TypePtr type = p->type();
+    if(SequencePtr::dynamicCast(type))
+    {
+        SequencePtr s = SequencePtr::dynamicCast(type);
+        BuiltinPtr builtin = BuiltinPtr::dynamicCast(s->type());
+        if(builtin && builtin->kind() == Builtin::KindByte)
+        {
+            StringList metaData = s->getMetaData();
+            bool protobuf;
+            findMetaData(s, metaData, protobuf);
+            if(protobuf)
+            {
+                emitWarning(p->file(), p->line(), "protobuf cannot be used as a class member in C++");
+            }
+        }
+    }
+
+    string name = fixKwd(p->name());
+    H << sp << nl << typeToString(p->type(), p->optional(), p->getMetaData(), _useWstring) << ' ' << name << ';';
+}
+
+void
 Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
 {
     string scoped = fixKwd(p->scoped());
@@ -5050,7 +4593,7 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
         {
             if((*i)->type()->usesClasses())
             {
-                emitGCInsertCode((*i)->type(), fixKwd((*i)->name()), "", 0);
+                emitGCInsertCode((*i)->type(), getDataMemberRef(*i), "", 0);
             }
         }
         C << eb;
@@ -5086,7 +4629,7 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
         {
             if((*j)->type()->usesClasses())
             {
-                emitGCClearCode((*j)->type(), fixKwd((*j)->name()), "", 0);
+                emitGCClearCode((*j)->type(), getDataMemberRef(*j), "", 0);
             }
         }
         C << eb;
@@ -5096,8 +4639,8 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
 void
 Slice::Gen::ObjectVisitor::emitGCInsertCode(const TypePtr& p, const string& prefix, const string& name, int level)
 {
-    if((BuiltinPtr::dynamicCast(p) && BuiltinPtr::dynamicCast(p)->kind() == Builtin::KindObject)
-       || ClassDeclPtr::dynamicCast(p))
+    BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
+    if((builtin && BuiltinPtr::dynamicCast(p)->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(p))
     {
         C << nl << "if(" << prefix << name << ')';
         C << sb;
@@ -5160,8 +4703,8 @@ Slice::Gen::ObjectVisitor::emitGCInsertCode(const TypePtr& p, const string& pref
 void
 Slice::Gen::ObjectVisitor::emitGCClearCode(const TypePtr& p, const string& prefix, const string& name, int level)
 {
-    if((BuiltinPtr::dynamicCast(p) && BuiltinPtr::dynamicCast(p)->kind() == Builtin::KindObject)
-       || ClassDeclPtr::dynamicCast(p))
+    BuiltinPtr builtin = BuiltinPtr::dynamicCast(p);
+    if((builtin && BuiltinPtr::dynamicCast(p)->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(p))
     {
         C << nl << "if(" << prefix << name << ")";
         C << sb;
@@ -5294,7 +4837,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p)
 
         for(q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
         {
-            string typeName = inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+            string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
             allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
         }
 
@@ -5466,8 +5009,9 @@ bool
 usePrivateEnd(const OperationPtr& p)
 {
     TypePtr ret = p->returnType();
-    string retSEnd = returnTypeToString(ret, p->getMetaData(), TypeContextAMIEnd);
-    string retSPrivateEnd = returnTypeToString(ret, p->getMetaData(), TypeContextAMIPrivateEnd);
+    bool retIsOpt = p->returnIsOptional();
+    string retSEnd = returnTypeToString(ret, retIsOpt, p->getMetaData(), TypeContextAMIEnd);
+    string retSPrivateEnd = returnTypeToString(ret, retIsOpt, p->getMetaData(), TypeContextAMIPrivateEnd);
         
     ParamDeclList outParams;
     vector<string> outDeclsEnd;
@@ -5478,8 +5022,10 @@ usePrivateEnd(const OperationPtr& p)
     {
         if((*q)->isOutParam())
         {
-            outDeclsEnd.push_back(outputTypeToString((*q)->type(), (*q)->getMetaData(), TypeContextAMIEnd));
-            outDeclsPrivateEnd.push_back(outputTypeToString((*q)->type(), (*q)->getMetaData(), TypeContextAMIPrivateEnd));
+            outDeclsEnd.push_back(outputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), 
+                                                     TypeContextAMIEnd));
+            outDeclsPrivateEnd.push_back(outputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                                            TypeContextAMIPrivateEnd));
         }
     }
     
@@ -5510,7 +5056,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
     string delTmplName = (withCookie ? "Callback_" : "CallbackNC_") + clName + "_" + p->name();
 
     TypePtr ret = p->returnType();
-    string retS = inputTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
     string retEndArg = getEndArg(ret, p->getMetaData(), "__ret");
         
     ParamDeclList outParams;
@@ -5527,7 +5073,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
             outParams.push_back(*q);
             outArgs.push_back(fixKwd((*q)->name()));
             outEndArgs.push_back(getEndArg((*q)->type(), (*q)->getMetaData(), outArgs.back()));
-            outDecls.push_back(inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring));
+            outDecls.push_back(inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring));
         }
     }
 
@@ -5616,8 +5162,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << sb;
         H << nl << clScope << clName << "Prx __proxy = " << clScope << clName
           << "Prx::uncheckedCast(__result->getProxy());";
-        writeAllocateCode(H, outParams, ret, p->getMetaData(), 
-                          _useWstring | TypeContextInParam | TypeContextAMICallPrivateEnd);
+        writeAllocateCode(H, outParams, p, _useWstring | TypeContextInParam | TypeContextAMICallPrivateEnd);
         H << nl << "try";
         H << sb;
         H << nl;
@@ -5638,7 +5183,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
             }
             H << "__result" << epar << ';';
         }
-        writeEndCode(H, outParams, ret, p->getMetaData());
+        writeEndCode(H, outParams, p);
         H << eb;
         H << nl << "catch(::Ice::Exception& ex)";
         H << sb;
@@ -5770,134 +5315,6 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
     }
 }
 
-Slice::Gen::HandleVisitor::HandleVisitor(Output& h, Output& c, const string& dllExport, bool stream) :
-    H(h), C(c), _dllExport(dllExport), _stream(stream)
-{
-}
-
-bool
-Slice::Gen::HandleVisitor::visitModuleStart(const ModulePtr& p)
-{
-    if(!p->hasClassDecls())
-    {
-        return false;
-    }
-
-    string name = fixKwd(p->name());
-
-    H << sp;
-    H << nl << "namespace " << name << nl << '{';
-
-    return true;
-}
-
-void
-Slice::Gen::HandleVisitor::visitModuleEnd(const ModulePtr& p)
-{
-    H << sp;
-    H << nl << '}';
-}
-
-void
-Slice::Gen::HandleVisitor::visitClassDecl(const ClassDeclPtr& p)
-{
-    string name = p->name();
-    string scoped = fixKwd(p->scoped());
-
-    if(!p->isLocal())
-    {
-        H << sp;
-        H << nl << _dllExport << "void __read(::IceInternal::BasicStream*, " << name << "Prx&);";
-        H << nl << _dllExport << "void __patch__" << name << "Ptr(void*, ::Ice::ObjectPtr&);";
-        if(_stream)
-        {
-            H << sp << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << name
-              << "Prx(const ::Ice::OutputStreamPtr&, const " << name << "Prx&);";
-            H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << name
-              << "Prx(const ::Ice::InputStreamPtr&, " << name << "Prx&);";
-
-            H << nl << _dllExport << "ICE_DEPRECATED_API void ice_write" << name
-              << "(const ::Ice::OutputStreamPtr&, const "
-              << name << "Ptr&);";
-            H << nl << _dllExport << "ICE_DEPRECATED_API void ice_read" << name << "(const ::Ice::InputStreamPtr&, "
-              << name << "Ptr&);";
-        }
-    }
-}
-
-bool
-Slice::Gen::HandleVisitor::visitClassDefStart(const ClassDefPtr& p)
-{
-    if(!p->isLocal())
-    {
-        string name = p->name();
-        string scoped = fixKwd(p->scoped());
-        string scope = fixKwd(p->scope());
-
-        string factory;
-        string type;
-        if(!p->isAbstract())
-        {
-            type = scoped + "::ice_staticId()";
-            factory = scoped + "::ice_factory()";
-        }
-        else
-        {
-            type = "\"\"";
-            factory = "0";
-        }
-
-        C << sp;
-        C << nl << "void" << nl << scope.substr(2) << "__read(::IceInternal::BasicStream* __is, "
-          << scope << name << "Prx& v)";
-        C << sb;
-        C << nl << "::Ice::ObjectPrx proxy;";
-        C << nl << "__is->read(proxy);";
-        C << nl << "if(!proxy)";
-        C << sb;
-        C << nl << "v = 0;";
-        C << eb;
-        C << nl << "else";
-        C << sb;
-        C << nl << "v = new ::IceProxy" << scoped << ';';
-        C << nl << "v->__copyFrom(proxy);";
-        C << eb;
-        C << eb;
-
-        if(_stream)
-        {
-            C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << name
-              << "Prx(const ::Ice::OutputStreamPtr& __outS, const " << scope << name << "Prx& v)";
-            C << sb;
-            C << nl << "__outS->write(v);";
-            C << eb;
-
-            C << sp;
-            C << nl << "void" << nl << scope.substr(2) << "ice_read" << name
-              << "Prx(const ::Ice::InputStreamPtr& __inS, " << scope << name << "Prx& v)";
-            C << sb;
-            C << nl << "__inS->read(v);";
-            C << eb;
-
-            C << sp;
-            C << nl << "void" << nl << scope.substr(2) << "ice_write" << name
-              << "(const ::Ice::OutputStreamPtr& __outS, const " << scope << name << "Ptr& v)";
-            C << sb;
-            C << nl << "__outS->writeObject(v);";
-            C << eb;
-
-            C << sp;
-            C << nl << "void" << nl << scope.substr(2) << "ice_read" << name << "(const ::Ice::InputStreamPtr& __inS, "
-              << scope << name << "Ptr& __v)";
-            C << sb;
-            C << nl << "__inS->read(__v);";
-            C << eb;
-        }
-    }
-
-    return true;
-}
-
 Slice::Gen::ImplVisitor::ImplVisitor(Output& h, Output& c, const string& dllExport) :
     H(h), C(c), _dllExport(dllExport), _useWstring(false)
 {
@@ -6135,7 +5552,7 @@ Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
         string opName = op->name();
 
         TypePtr ret = op->returnType();
-        string retS = returnTypeToString(ret, op->getMetaData(), _useWstring);
+        string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), _useWstring);
 
         if(!p->isLocal() && (p->hasMetaData("amd") || op->hasMetaData("amd")))
         {
@@ -6148,7 +5565,8 @@ Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
             {
                 if(!(*q)->isOutParam())
                 {
-                    H << ',' << nl << inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring);
+                    H << ',' << nl << inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), 
+                                                        _useWstring);
                 }
             }
             H << ',' << nl << "const Ice::Current&";
@@ -6165,8 +5583,8 @@ Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
             {
                 if(!(*q)->isOutParam())
                 {
-                    C << ',' << nl << inputTypeToString((*q)->type(), (*q)->getMetaData(), _useWstring) << ' '
-                      << fixKwd((*q)->name());
+                    C << ',' << nl << inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), 
+                                                        _useWstring) << ' ' << fixKwd((*q)->name());
                 }
             }
             C << ',' << nl << "const Ice::Current& current";
@@ -6228,23 +5646,15 @@ Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                     H << ',' << nl;
                 }
                 StringList metaData = (*q)->getMetaData();
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC==0x550)
-                //
-                // Work around for Sun CC 5.5 bug #4853566
-                //
                 string typeString;
                 if((*q)->isOutParam())
                 {
-                    typeString = outputTypeToString((*q)->type(), metaData, _useWstring);
+                    typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
                 }
                 else
                 {
-                    typeString = inputTypeToString((*q)->type(), metaData, _useWstring);
+                    typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
                 }
-#else
-                string typeString = (*q)->isOutParam() ? outputTypeToString((*q)->type(), metaData, _useWstring)
-                                                       : inputTypeToString((*q)->type(), metaData, _useWstring);
-#endif
                 H << typeString;
             }
             if(!p->isLocal())
@@ -6271,23 +5681,15 @@ Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                     C << ',' << nl;
                 }
                 StringList metaData = (*q)->getMetaData();
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC==0x550)
-                //
-                // Work around for Sun CC 5.5 bug #4853566
-                //
                 string typeString;
                 if((*q)->isOutParam())
                 {
-                    typeString = outputTypeToString((*q)->type(), _useWstring, metaData);
+                    typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
                 }
                 else
                 {
-                    typeString = inputTypeToString((*q)->type(), _useWstring, metaData);
+                    typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring);
                 }
-#else
-                string typeString = (*q)->isOutParam() ? outputTypeToString((*q)->type(), metaData, _useWstring)
-                                                       : inputTypeToString((*q)->type(), metaData, _useWstring);
-#endif
                 C << typeString << ' ' << fixKwd((*q)->name());
             }
             if(!p->isLocal())
@@ -6396,12 +5798,12 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     paramsDeclInvoke.push_back("const " + proxyName + "& __prx");
 
     TypePtr ret = p->returnType();
-    string retS = inputTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     if(ret)
     {
         params.push_back(retS);
-        paramsAMD.push_back(inputTypeToString(ret, p->getMetaData(), _useWstring));
+        paramsAMD.push_back(inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring));
         paramsDecl.push_back(retS + " __ret");
         args.push_back("__ret");
     }
@@ -6413,12 +5815,12 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     {
         string paramName = fixKwd((*q)->name());
         TypePtr type = (*q)->type();
-        string typeString = inputTypeToString(type, (*q)->getMetaData(), _useWstring);
+        string typeString = inputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), _useWstring);
 
         if((*q)->isOutParam())
         {
             params.push_back(typeString);
-            paramsAMD.push_back(inputTypeToString(type, (*q)->getMetaData(), _useWstring));
+            paramsAMD.push_back(inputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), _useWstring));
             paramsDecl.push_back(typeString + ' ' + paramName);
             args.push_back(paramName);
 
@@ -6589,7 +5991,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
 #endif
 
     TypePtr ret = p->returnType();
-    string retS = inputTypeToString(ret, p->getMetaData(), _useWstring);
+    string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
 
     if(ret)
     {
@@ -6608,7 +6010,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
         {
             string paramName = fixKwd((*q)->name());
             TypePtr type = (*q)->type();
-            string typeString = inputTypeToString(type, (*q)->getMetaData(), _useWstring);
+            string typeString = inputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), _useWstring);
 
             if(ret || !outParams.empty())
             {
@@ -6682,11 +6084,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
         {
             C << nl << "__os->format(" << formatTypeToString(format) << ");";
         }
-        writeMarshalCode(C, outParams, 0, StringList(), TypeContextInParam);
-        if(ret)
-        {
-            writeMarshalUnmarshalCode(C, ret, "__ret", true, "", true, p->getMetaData(), TypeContextInParam);
-        }
+        writeMarshalCode(C, outParams, p, TypeContextInParam);
         C << nl << "__endWriteParams(true);";
         C << eb;
         C << nl << "catch(const ::Ice::Exception& __ex)";
@@ -6772,10 +6170,6 @@ Slice::Gen::StreamVisitor::visitModuleStart(const ModulePtr& m)
         // Only emit this for the top-level module.
         //
         H << sp;
-        H.zeroIndent();
-        H << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERFIX
-        H << nl << "#else";
-        H.restoreIndent();
         H << nl << "namespace Ice" << nl << '{';
     }
 
@@ -6791,9 +6185,6 @@ Slice::Gen::StreamVisitor::visitModuleEnd(const ModulePtr& m)
         // Only emit this for the top-level module.
         //
         H << nl << '}';
-        H.zeroIndent();
-        H << nl << "#endif";
-        H.restoreIndent();
     }
 }
 
@@ -6838,6 +6229,15 @@ Slice::Gen::StreamVisitor::visitStructStart(const StructPtr& p)
             H << nl << "static const ::Ice::StreamTraitType type = ::Ice::StreamTraitTypeStruct;";
         }
         H << nl << "static const int minWireSize = " << p->minWireSize() << ";";
+        H << nl << "static const bool isVariableLength = " << p->isVariableLength() << ";";
+        if(p->isVariableLength())
+        {
+            H << nl << "static const ::Ice::OptionalType optionalType = ::Ice::OptionalTypeFSize;";
+        }
+        else
+        {
+            H << nl << "static const ::Ice::OptionalType optionalType = ::Ice::OptionalTypeVSize;";
+        }
         H << eb << ";" << nl;
     }
     return false;
@@ -6850,22 +6250,11 @@ Slice::Gen::StreamVisitor::visitEnum(const EnumPtr& p)
     H << nl << "template<>";
     H << nl << "struct StreamTrait< " << scoped << ">";
     H << sb;
-    H << nl << "static const ::Ice::StreamTraitType type = ";
-    size_t sz = p->getEnumerators().size();
-    if(sz <= 127)
-    {
-        H << "::Ice::StreamTraitTypeByteEnum;";
-    }
-    else if(sz <= 32767)
-    {
-        H << "::Ice::StreamTraitTypeShortEnum;";
-    }
-    else
-    {
-        H << "::Ice::StreamTraitTypeIntEnum;";
-    }
-    H << nl << "static const int enumLimit = " << sz << ";";
+    H << nl << "static const ::Ice::StreamTraitType type = ::Ice::StreamTraitTypeEnum;";
+    H << nl << "static const int enumLimit = " << p->getEnumerators().size() << ";";
     H << nl << "static const int minWireSize = " << p->minWireSize() << ";";
+    H << nl << "static const bool isVariableLength = true;";
+    H << nl << "static const ::Ice::OptionalType optionalType = ::Ice::OptionalTypeSize;";
     H << eb << ";" << nl;
 }
 
diff --git a/cpp/src/slice2cpp/Gen.h b/cpp/src/slice2cpp/Gen.h
index 6e217075c10..9d05ca2a8b5 100644
--- a/cpp/src/slice2cpp/Gen.h
+++ b/cpp/src/slice2cpp/Gen.h
@@ -255,6 +255,7 @@ private:
 
     private:
 
+        void emitDataMember(const DataMemberPtr&);
         void emitGCFunctions(const ClassDefPtr&);
         void emitGCInsertCode(const TypePtr&, const std::string&, const std::string&, int);
         void emitGCClearCode(const TypePtr&, const std::string&, const std::string&, int);
@@ -320,26 +321,6 @@ private:
         std::list<int> _useWstringHist;
     };
 
-    class HandleVisitor : private ::IceUtil::noncopyable, public ParserVisitor
-    {
-    public:
-
-        HandleVisitor(::IceUtilInternal::Output&, ::IceUtilInternal::Output&, const std::string&, bool);
-
-        virtual bool visitModuleStart(const ModulePtr&);
-        virtual void visitModuleEnd(const ModulePtr&);
-        virtual void visitClassDecl(const ClassDeclPtr&);
-        virtual bool visitClassDefStart(const ClassDefPtr&);
-
-    private:
-
-        ::IceUtilInternal::Output& H;
-        ::IceUtilInternal::Output& C;
-
-        std::string _dllExport;
-        bool _stream;
-    };
-
     class ImplVisitor : private ::IceUtil::noncopyable, public ParserVisitor
     {
     public:
diff --git a/cpp/src/slice2freeze/Main.cpp b/cpp/src/slice2freeze/Main.cpp
index 14ff61bc8c2..04026196d4f 100644
--- a/cpp/src/slice2freeze/Main.cpp
+++ b/cpp/src/slice2freeze/Main.cpp
@@ -319,7 +319,7 @@ writeCodecH(const TypePtr& type, const StringList& metaData, const string& name,
     H << sp << nl << "public:";
     H << sp;
     H.inc();
-    H << nl << "static void write(" << inputTypeToString(type, metaData)
+    H << nl << "static void write(" << inputTypeToString(type, false, metaData)
       << ", Freeze::" << freezeType << "&, const ::Ice::CommunicatorPtr&, const Ice::EncodingVersion&);";
     H << nl << "static void read(" << typeToString(type, metaData) << "&, const Freeze::" << freezeType << "&, "
       << "const ::Ice::CommunicatorPtr&, const Ice::EncodingVersion&);";
@@ -333,7 +333,7 @@ writeCodecC(const TypePtr& type, const StringList& metaData, const string& name,
 {
     string quotedFreezeType = "\"" + freezeType + "\"";
 
-    C << sp << nl << "void" << nl << name << "::write(" << inputTypeToString(type, metaData) << " v, "
+    C << sp << nl << "void" << nl << name << "::write(" << inputTypeToString(type, false, metaData) << " v, "
       << "Freeze::" << freezeType << "& bytes, const ::Ice::CommunicatorPtr& communicator, "
       << "const Ice::EncodingVersion& encoding)";
     C << sb;
@@ -343,7 +343,7 @@ writeCodecC(const TypePtr& type, const StringList& metaData, const string& name,
     {
         C << nl << "stream.startWriteEncaps();";
     }
-    writeMarshalUnmarshalCode(C, type, "v", true, "stream", false, metaData);
+    writeMarshalUnmarshalCode(C, type, false, 0, "v", true, metaData, 0, "stream", false);
     if(type->usesClasses())
     {
         C << nl << "stream.writePendingObjects();";
@@ -372,7 +372,7 @@ writeCodecC(const TypePtr& type, const StringList& metaData, const string& name,
     {
         C << nl << "stream.startReadEncaps();";
     }
-    writeMarshalUnmarshalCode(C, type, "v", false, "stream", false, metaData);
+    writeMarshalUnmarshalCode(C, type, false, 0, "v", false, metaData, 0, "stream", false);
     if(type->usesClasses())
     {
         C << nl << "stream.readPendingObjects();";
@@ -501,7 +501,7 @@ writeDictWithIndicesH(const string& name, const Dict& dict,
         //
         // Codec
         //
-        H << nl << "static void write(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData)
+        H << nl << "static void write(" << inputTypeToString(indexTypes[i].type, 0, indexTypes[i].metaData)
           << ", Freeze::Key&, const Ice::CommunicatorPtr&, const Ice::EncodingVersion&);";
 
         H << nl << "static void read(" 
@@ -572,9 +572,9 @@ writeDictWithIndicesH(const string& name, const Dict& dict,
     {
         H << sp;
         H << nl << "iterator findBy" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ", bool = true);";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ", bool = true);";
         H << nl << "const_iterator findBy" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ", bool = true) const;";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ", bool = true) const;";
 
         H << nl << "iterator beginFor" << capitalizedMembers[i] << "();";
         H << nl << "const_iterator beginFor" << capitalizedMembers[i] << "() const;";
@@ -583,28 +583,28 @@ writeDictWithIndicesH(const string& name, const Dict& dict,
         H << nl << "const_iterator endFor" << capitalizedMembers[i] << "() const;";
         
         H << nl << "iterator lowerBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ");";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ");";
         H << nl << "const_iterator lowerBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ") const;";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ") const;";
         
         H << nl << "iterator upperBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ");";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ");";
         H << nl << "const_iterator upperBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ") const;";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ") const;";
 
         H << nl << "std::pair<iterator, iterator> equalRangeFor" 
-          << capitalizedMembers[i] << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) 
+          << capitalizedMembers[i] << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) 
           << ");";
         
         H << nl << "std::pair<const_iterator, const_iterator> equalRangeFor" 
-          << capitalizedMembers[i] << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData)
+          << capitalizedMembers[i] << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData)
           << ") const;";
 
         string countFunction = dict.indices[i].member.empty() ? string("valueCount")
             : dict.indices[i].member + "Count";
 
         H << nl << "int " << countFunction
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << ") const;";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << ") const;";
 
     }
     
@@ -623,8 +623,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         + typeToString(valueType, valueMetaData) + ", " + name + "KeyCodec, " 
         + name + "ValueCodec, " + compare + " >";
 
-    string keyCompareParams =
-        string("< ") + typeToString(keyType, keyMetaData) + ", "
+    string keyCompareParams = string("< ") + typeToString(keyType, keyMetaData) + ", "
         + name + "KeyCodec, " + compare + " >";
     
     vector<string> capitalizedMembers;
@@ -708,7 +707,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         
         C << sp << nl << "void" 
           << nl << absolute << "::" << className << "::" 
-          << "write(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData)
+          << "write(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData)
           << " __index, Freeze::Key& __bytes, const Ice::CommunicatorPtr& __communicator, "
           << "const Ice::EncodingVersion& __encoding)";
         C << sb;
@@ -736,7 +735,8 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
                 valueS = "__lowerCaseIndex";
             }
             
-            writeMarshalUnmarshalCode(C, indexTypes[i].type, valueS, true, "__stream", false, indexTypes[i].metaData);
+            writeMarshalUnmarshalCode(C, indexTypes[i].type, false, 0, valueS, true, indexTypes[i].metaData, 0, 
+                                      "__stream", false);
             C << nl << "::std::vector<Ice::Byte>(__stream.b.begin(), __stream.b.end()).swap(__bytes);";
         }
         C << eb;
@@ -760,8 +760,8 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
             C << nl << "__stream.b.resize(__bytes.size());";
             C << nl << "::memcpy(&__stream.b[0], &__bytes[0], __bytes.size());";
             C << nl << "__stream.i = __stream.b.begin();";
-            writeMarshalUnmarshalCode(C, indexTypes[i].type, "__index", false, "__stream", false, 
-                                      indexTypes[i].metaData);
+            writeMarshalUnmarshalCode(C, indexTypes[i].type, false, 0, "__index", false, indexTypes[i].metaData, 0,
+                                      "__stream", false);
         }
         C << eb;
     }
@@ -839,7 +839,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << absolute << "::iterator"
           << nl << absolute << "::" << "findBy" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData)
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData)
           << " __index, bool __onlyDups)";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
@@ -850,7 +850,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << absolute << "::const_iterator"
           << nl << absolute << "::" << "findBy" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData)
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData)
           << " __index, bool __onlyDups) const";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
@@ -885,7 +885,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << absolute << "::iterator"
           << nl << absolute << "::" << "lowerBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index)";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index)";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
         C << nl << indexClassName << "::" << "write(__index, __bytes, _communicator, _encoding);";
@@ -895,7 +895,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << absolute << "::const_iterator"
           << nl << absolute << "::" << "lowerBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index) const";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index) const";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
         C << nl << indexClassName << "::" << "write(__index, __bytes, _communicator, _encoding);";
@@ -905,7 +905,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         
         C << sp << nl << absolute << "::iterator"
           << nl << absolute << "::" << "upperBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index)";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index)";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
         C << nl << indexClassName << "::" << "write(__index, __bytes, _communicator, _encoding);";
@@ -915,7 +915,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << absolute << "::const_iterator"
           << nl << absolute << "::" << "upperBoundFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index) const";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index) const";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
         C << nl << indexClassName << "::" << "write(__index, __bytes, _communicator, _encoding);";
@@ -926,7 +926,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         C << sp << nl << "std::pair<" << absolute << "::iterator, "
           << absolute << "::iterator>"
           << nl << absolute << "::" << "equalRangeFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index)";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index)";
         C << sb;
         C << nl << "return std::make_pair(lowerBoundFor" << capitalizedMembers[i]
           << "(__index), upperBoundFor" << capitalizedMembers[i] << "(__index));";
@@ -935,7 +935,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         C << sp << nl << "std::pair<" << absolute << "::const_iterator, "
           << absolute << "::const_iterator>"
           << nl << absolute << "::" << "equalRangeFor" << capitalizedMembers[i]
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index) const";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index) const";
         C << sb;
         C << nl << "return std::make_pair(lowerBoundFor" << capitalizedMembers[i]
           << "(__index), upperBoundFor" << capitalizedMembers[i] << "(__index));";
@@ -946,7 +946,7 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
 
         C << sp << nl << "int"
           << nl << absolute << "::" << countFunction
-          << "(" << inputTypeToString(indexTypes[i].type, indexTypes[i].metaData) << " __index) const";
+          << "(" << inputTypeToString(indexTypes[i].type, false, indexTypes[i].metaData) << " __index) const";
         C << sb;
         C << nl << "Freeze::Key __bytes;";
         C << nl << indexClassName << "::" << "write(__index, __bytes, _communicator, _encoding);";
@@ -1202,7 +1202,7 @@ void
 writeIndexC(const TypePtr& type, const TypePtr& memberType, const string& memberName,
             bool caseSensitive, const string& fullName, const string& name, Output& C)
 {
-    string inputType = inputTypeToString(memberType);
+    string inputType = inputTypeToString(memberType, false);
 
     C << sp << nl << fullName << "::" << name 
       << "(const ::std::string& __name, const ::std::string& __facet)";
@@ -1270,7 +1270,7 @@ writeIndexC(const TypePtr& type, const TypePtr& memberType, const string& member
         valueS = "__lowerCaseIndex";
     }
 
-    writeMarshalUnmarshalCode(C, memberType, valueS, true, "__stream", false);
+    writeMarshalUnmarshalCode(C, memberType, false, 0, valueS, true, StringList(), 0, "__stream", false);
     if(memberType->usesClasses())
     {
         C << nl << "__stream.writePendingObjects();";
@@ -1363,7 +1363,7 @@ writeIndex(const string& n, const UnitPtr& u, const Index& index, Output& H, Out
         H << nl << "namespace " << *q << nl << '{';
     }
 
-    writeIndexH(inputTypeToString(dataMember->type()), name, H, dllExport);
+    writeIndexH(inputTypeToString(dataMember->type(), false), name, H, dllExport);
     
     for(q = scope.begin(); q != scope.end(); ++q)
     {
diff --git a/cpp/test/Ice/custom/.depend b/cpp/test/Ice/custom/.depend
index 2d4287d5ddb..51c2dc45b2f 100644
--- a/cpp/test/Ice/custom/.depend
+++ b/cpp/test/Ice/custom/.depend
@@ -1,31 +1,31 @@
-Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-Client$(OBJEXT): Client.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h Test.h MyByteSeq.h StringConverterI.h
-AllTests$(OBJEXT): AllTests.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h $(includedir)/IceUtil/Iterator.h ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
+Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+Client$(OBJEXT): Client.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h Test.h MyByteSeq.h StringConverterI.h
+AllTests$(OBJEXT): AllTests.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
-Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-TestI$(OBJEXT): TestI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestI.h Test.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
-WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
-Server$(OBJEXT): Server.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
+Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+TestI$(OBJEXT): TestI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestI.h Test.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
+WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
+Server$(OBJEXT): Server.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
-TestAMD$(OBJEXT): TestAMD.cpp TestAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-TestAMDI$(OBJEXT): TestAMDI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestAMDI.h TestAMD.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
-WstringAMD$(OBJEXT): WstringAMD.cpp WstringAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-WstringAMDI$(OBJEXT): WstringAMDI.cpp WstringAMDI.h WstringAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
-ServerAMD$(OBJEXT): ServerAMD.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestAMDI.h TestAMD.h MyByteSeq.h WstringAMDI.h WstringAMD.h StringConverterI.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
+TestAMD$(OBJEXT): TestAMD.cpp TestAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+TestAMDI$(OBJEXT): TestAMDI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestAMDI.h TestAMD.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
+WstringAMD$(OBJEXT): WstringAMD.cpp WstringAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+WstringAMDI$(OBJEXT): WstringAMDI.cpp WstringAMDI.h WstringAMD.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
+ServerAMD$(OBJEXT): ServerAMD.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestAMDI.h TestAMD.h MyByteSeq.h WstringAMDI.h WstringAMD.h StringConverterI.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
-Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h $(includedir)/IceUtil/Iterator.h
-TestI$(OBJEXT): TestI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestI.h Test.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
-WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
-Collocated$(OBJEXT): Collocated.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
-AllTests$(OBJEXT): AllTests.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h $(includedir)/IceUtil/Iterator.h ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
+Test$(OBJEXT): Test.cpp Test.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h MyByteSeq.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+Wstring$(OBJEXT): Wstring.cpp Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/ObjectFactory.h
+TestI$(OBJEXT): TestI.cpp $(includedir)/Ice/Communicator.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/Properties.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h TestI.h Test.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h MyByteSeq.h
+WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/Stream.h
+Collocated$(OBJEXT): Collocated.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
+AllTests$(OBJEXT): AllTests.cpp $(includedir)/Ice/Ice.h $(includedir)/Ice/Initialize.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/Config.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/PropertiesF.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/StatsF.h $(includedir)/Ice/Dispatcher.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/IceUtil/Unicode.h $(includedir)/Ice/LocalException.h $(includedir)/Ice/Properties.h $(includedir)/Ice/Outgoing.h $(includedir)/Ice/Incoming.h $(includedir)/Ice/ServantLocatorF.h $(includedir)/Ice/ServantManagerF.h $(includedir)/Ice/Direct.h $(includedir)/Ice/Logger.h $(includedir)/Ice/LoggerUtil.h $(includedir)/Ice/Stats.h $(includedir)/Ice/Communicator.h $(includedir)/Ice/RouterF.h $(includedir)/Ice/LocatorF.h $(includedir)/Ice/PluginF.h $(includedir)/Ice/ImplicitContextF.h $(includedir)/Ice/CommunicatorAsync.h $(includedir)/Ice/ObjectFactory.h $(includedir)/Ice/ObjectAdapter.h $(includedir)/Ice/FacetMap.h $(includedir)/Ice/Endpoint.h $(includedir)/Ice/ServantLocator.h $(includedir)/Ice/IncomingAsync.h $(includedir)/Ice/Process.h $(includedir)/Ice/Application.h $(includedir)/Ice/Connection.h $(includedir)/Ice/ConnectionAsync.h $(includedir)/Ice/Functional.h $(includedir)/IceUtil/Functional.h $(includedir)/Ice/ImplicitContext.h $(includedir)/Ice/Locator.h $(includedir)/Ice/FactoryTableInit.h $(includedir)/Ice/FactoryTable.h $(includedir)/Ice/ProcessF.h $(includedir)/Ice/Router.h $(includedir)/Ice/DispatchInterceptor.h $(includedir)/Ice/IconvStringConverter.h ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h $(includedir)/Ice/StringConverter.h $(includedir)/Ice/Config.h $(includedir)/IceUtil/Config.h $(includedir)/Ice/CommunicatorF.h $(includedir)/Ice/LocalObjectF.h $(includedir)/IceUtil/Shared.h $(includedir)/Ice/Handle.h $(includedir)/IceUtil/Handle.h $(includedir)/IceUtil/Exception.h $(includedir)/Ice/ProxyF.h $(includedir)/Ice/ProxyHandle.h $(includedir)/Ice/ObjectF.h $(includedir)/Ice/Exception.h $(includedir)/Ice/Format.h $(includedir)/Ice/LocalObject.h $(includedir)/Ice/StreamTraits.h $(includedir)/IceUtil/ScopedArray.h $(includedir)/IceUtil/Optional.h $(includedir)/Ice/UndefSysMacros.h $(includedir)/Ice/Plugin.h $(includedir)/Ice/Proxy.h $(includedir)/IceUtil/Mutex.h $(includedir)/IceUtil/Lock.h $(includedir)/IceUtil/ThreadException.h $(includedir)/IceUtil/Time.h $(includedir)/IceUtil/MutexProtocol.h $(includedir)/Ice/ProxyFactoryF.h $(includedir)/Ice/ConnectionIF.h $(includedir)/Ice/RequestHandlerF.h $(includedir)/Ice/EndpointIF.h $(includedir)/Ice/EndpointF.h $(includedir)/Ice/EndpointTypes.h $(includedir)/Ice/ObjectAdapterF.h $(includedir)/Ice/ReferenceF.h $(includedir)/Ice/OutgoingAsync.h $(includedir)/IceUtil/Monitor.h $(includedir)/IceUtil/Cond.h $(includedir)/IceUtil/Timer.h $(includedir)/IceUtil/Thread.h $(includedir)/Ice/OutgoingAsyncF.h $(includedir)/Ice/InstanceF.h $(includedir)/Ice/Current.h $(includedir)/Ice/ConnectionF.h $(includedir)/Ice/Identity.h $(includedir)/Ice/Version.h $(includedir)/Ice/BasicStream.h $(includedir)/IceUtil/Iterator.h $(includedir)/Ice/ObjectFactoryF.h $(includedir)/Ice/Buffer.h $(includedir)/Ice/Protocol.h $(includedir)/Ice/SlicedDataF.h $(includedir)/Ice/UserExceptionFactory.h $(includedir)/Ice/StreamF.h $(includedir)/Ice/LoggerF.h $(includedir)/Ice/BuiltinSequences.h $(includedir)/Ice/Stream.h $(includedir)/Ice/Object.h $(includedir)/Ice/GCShared.h $(includedir)/Ice/GCCountMap.h $(includedir)/Ice/IncomingAsyncF.h $(includedir)/IceUtil/Unicode.h
 Test.h Test.cpp: Test.ice $(SLICE2CPP) $(SLICEPARSERLIB)
 TestAMD.h TestAMD.cpp: TestAMD.ice $(SLICE2CPP) $(SLICEPARSERLIB)
 Wstring.h Wstring.cpp: Wstring.ice $(SLICE2CPP) $(SLICEPARSERLIB)
diff --git a/cpp/test/Ice/custom/.depend.mak b/cpp/test/Ice/custom/.depend.mak
index 25835dbdf04..82bc48f4fb3 100644
--- a/cpp/test/Ice/custom/.depend.mak
+++ b/cpp/test/Ice/custom/.depend.mak
@@ -1,31 +1,31 @@
-Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-Client$(OBJEXT): Client.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h Test.h MyByteSeq.h StringConverterI.h
-AllTests$(OBJEXT): AllTests.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" "$(includedir)/IceUtil/Iterator.h" ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
+Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+Client$(OBJEXT): Client.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h Test.h MyByteSeq.h StringConverterI.h
+AllTests$(OBJEXT): AllTests.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h"
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
-Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-TestI$(OBJEXT): TestI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestI.h Test.h "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
-WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
-Server$(OBJEXT): Server.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
+Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+TestI$(OBJEXT): TestI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestI.h Test.h "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
+WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
+Server$(OBJEXT): Server.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h"
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
-TestAMD$(OBJEXT): TestAMD.cpp TestAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-TestAMDI$(OBJEXT): TestAMDI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestAMDI.h TestAMD.h "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
-WstringAMD$(OBJEXT): WstringAMD.cpp WstringAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-WstringAMDI$(OBJEXT): WstringAMDI.cpp WstringAMDI.h WstringAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
-ServerAMD$(OBJEXT): ServerAMD.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestAMDI.h TestAMD.h MyByteSeq.h WstringAMDI.h WstringAMD.h StringConverterI.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
+TestAMD$(OBJEXT): TestAMD.cpp TestAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+TestAMDI$(OBJEXT): TestAMDI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestAMDI.h TestAMD.h "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
+WstringAMD$(OBJEXT): WstringAMD.cpp WstringAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+WstringAMDI$(OBJEXT): WstringAMDI.cpp WstringAMDI.h WstringAMD.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
+ServerAMD$(OBJEXT): ServerAMD.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestAMDI.h TestAMD.h MyByteSeq.h WstringAMDI.h WstringAMD.h StringConverterI.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h"
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
-Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/IceUtil/Iterator.h"
-TestI$(OBJEXT): TestI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestI.h Test.h "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
-WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
-Collocated$(OBJEXT): Collocated.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
-AllTests$(OBJEXT): AllTests.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" "$(includedir)/IceUtil/Iterator.h" ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
+Test$(OBJEXT): Test.cpp Test.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" MyByteSeq.h "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+Wstring$(OBJEXT): Wstring.cpp Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/ObjectFactory.h"
+TestI$(OBJEXT): TestI.cpp "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" TestI.h Test.h "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" MyByteSeq.h
+WstringI$(OBJEXT): WstringI.cpp WstringI.h Wstring.h "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/Stream.h"
+Collocated$(OBJEXT): Collocated.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h TestI.h Test.h MyByteSeq.h WstringI.h Wstring.h StringConverterI.h
+AllTests$(OBJEXT): AllTests.cpp "$(includedir)/Ice/Ice.h" "$(includedir)/Ice/Initialize.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/Config.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/PropertiesF.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/StatsF.h" "$(includedir)/Ice/Dispatcher.h" "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/IceUtil/Unicode.h" "$(includedir)/Ice/LocalException.h" "$(includedir)/Ice/Properties.h" "$(includedir)/Ice/Outgoing.h" "$(includedir)/Ice/Incoming.h" "$(includedir)/Ice/ServantLocatorF.h" "$(includedir)/Ice/ServantManagerF.h" "$(includedir)/Ice/Direct.h" "$(includedir)/Ice/Logger.h" "$(includedir)/Ice/LoggerUtil.h" "$(includedir)/Ice/Stats.h" "$(includedir)/Ice/Communicator.h" "$(includedir)/Ice/RouterF.h" "$(includedir)/Ice/LocatorF.h" "$(includedir)/Ice/PluginF.h" "$(includedir)/Ice/ImplicitContextF.h" "$(includedir)/Ice/CommunicatorAsync.h" "$(includedir)/Ice/ObjectFactory.h" "$(includedir)/Ice/ObjectAdapter.h" "$(includedir)/Ice/FacetMap.h" "$(includedir)/Ice/Endpoint.h" "$(includedir)/Ice/ServantLocator.h" "$(includedir)/Ice/IncomingAsync.h" "$(includedir)/Ice/Process.h" "$(includedir)/Ice/Application.h" "$(includedir)/Ice/Connection.h" "$(includedir)/Ice/ConnectionAsync.h" "$(includedir)/Ice/Functional.h" "$(includedir)/IceUtil/Functional.h" "$(includedir)/Ice/ImplicitContext.h" "$(includedir)/Ice/Locator.h" "$(includedir)/Ice/FactoryTableInit.h" "$(includedir)/Ice/FactoryTable.h" "$(includedir)/Ice/ProcessF.h" "$(includedir)/Ice/Router.h" "$(includedir)/Ice/DispatchInterceptor.h" "$(includedir)/Ice/IconvStringConverter.h" ../../include/TestCommon.h Test.h MyByteSeq.h Wstring.h
 MyByteSeq$(OBJEXT): MyByteSeq.cpp MyByteSeq.h "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h"
-StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
+StringConverterI$(OBJEXT): StringConverterI.cpp StringConverterI.h "$(includedir)/Ice/StringConverter.h" "$(includedir)/Ice/Config.h" "$(includedir)/IceUtil/Config.h" "$(includedir)/Ice/CommunicatorF.h" "$(includedir)/Ice/LocalObjectF.h" "$(includedir)/IceUtil/Shared.h" "$(includedir)/Ice/Handle.h" "$(includedir)/IceUtil/Handle.h" "$(includedir)/IceUtil/Exception.h" "$(includedir)/Ice/ProxyF.h" "$(includedir)/Ice/ProxyHandle.h" "$(includedir)/Ice/ObjectF.h" "$(includedir)/Ice/Exception.h" "$(includedir)/Ice/Format.h" "$(includedir)/Ice/LocalObject.h" "$(includedir)/Ice/StreamTraits.h" "$(includedir)/IceUtil/ScopedArray.h" "$(includedir)/IceUtil/Optional.h" "$(includedir)/Ice/UndefSysMacros.h" "$(includedir)/Ice/Plugin.h" "$(includedir)/Ice/Proxy.h" "$(includedir)/IceUtil/Mutex.h" "$(includedir)/IceUtil/Lock.h" "$(includedir)/IceUtil/ThreadException.h" "$(includedir)/IceUtil/Time.h" "$(includedir)/IceUtil/MutexProtocol.h" "$(includedir)/Ice/ProxyFactoryF.h" "$(includedir)/Ice/ConnectionIF.h" "$(includedir)/Ice/RequestHandlerF.h" "$(includedir)/Ice/EndpointIF.h" "$(includedir)/Ice/EndpointF.h" "$(includedir)/Ice/EndpointTypes.h" "$(includedir)/Ice/ObjectAdapterF.h" "$(includedir)/Ice/ReferenceF.h" "$(includedir)/Ice/OutgoingAsync.h" "$(includedir)/IceUtil/Monitor.h" "$(includedir)/IceUtil/Cond.h" "$(includedir)/IceUtil/Timer.h" "$(includedir)/IceUtil/Thread.h" "$(includedir)/Ice/OutgoingAsyncF.h" "$(includedir)/Ice/InstanceF.h" "$(includedir)/Ice/Current.h" "$(includedir)/Ice/ConnectionF.h" "$(includedir)/Ice/Identity.h" "$(includedir)/Ice/Version.h" "$(includedir)/Ice/BasicStream.h" "$(includedir)/IceUtil/Iterator.h" "$(includedir)/Ice/ObjectFactoryF.h" "$(includedir)/Ice/Buffer.h" "$(includedir)/Ice/Protocol.h" "$(includedir)/Ice/SlicedDataF.h" "$(includedir)/Ice/UserExceptionFactory.h" "$(includedir)/Ice/StreamF.h" "$(includedir)/Ice/LoggerF.h" "$(includedir)/Ice/BuiltinSequences.h" "$(includedir)/Ice/Stream.h" "$(includedir)/Ice/Object.h" "$(includedir)/Ice/GCShared.h" "$(includedir)/Ice/GCCountMap.h" "$(includedir)/Ice/IncomingAsyncF.h" "$(includedir)/IceUtil/Unicode.h"
 Test.h Test.cpp: Test.ice "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
 TestAMD.h TestAMD.cpp: TestAMD.ice "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
 Wstring.h Wstring.cpp: Wstring.ice "$(SLICE2CPP)" "$(SLICEPARSERLIB)"
diff --git a/cpp/test/Ice/custom/Test.ice b/cpp/test/Ice/custom/Test.ice
index 58a0b1f65cc..738e6c817d6 100644
--- a/cpp/test/Ice/custom/Test.ice
+++ b/cpp/test/Ice/custom/Test.ice
@@ -21,6 +21,8 @@ sequence<bool> BoolSeq;
 sequence<BoolList> BoolListSeq;
 ["cpp:type:std::list< ::Test::BoolSeq>"] sequence<BoolSeq> BoolSeqList;
 
+["cpp:type:std::list<std::deque<bool> >"] sequence<["cpp:type:std::deque<bool>"] BoolSeq> BoolDequeList;
+
 sequence<byte> ByteSeq;
 ["cpp:type:std::list< ::Ice::Byte>"] sequence<byte> ByteList;
 
@@ -139,6 +141,12 @@ sequence<ClassStruct> ClassStructSeq;
 
     BoolList opBoolList(BoolList inSeq, out BoolList outSeq);
 
+    BoolDequeList opBoolDequeList(BoolDequeList inSeq, out BoolDequeList outSeq);
+    ["cpp:array"] BoolDequeList opBoolDequeListArray(["cpp:array"] BoolDequeList inSeq,
+                                                out ["cpp:array"] BoolDequeList outSeq);
+    ["cpp:range"] BoolDequeList opBoolDequeListRange(["cpp:range"] BoolDequeList inSeq,
+                                                out ["cpp:range"] BoolDequeList outSeq);
+
     ["cpp:type:std::deque< ::Ice::Byte>"] ByteSeq 
     opByteSeq(["cpp:type:std::deque< ::Ice::Byte>"] ByteSeq inSeq, 
               out ["cpp:type:std::deque< ::Ice::Byte>"] ByteSeq outSeq);
diff --git a/cpp/test/Ice/custom/TestI.cpp b/cpp/test/Ice/custom/TestI.cpp
index 6f2aac99d3e..7fe8a0f1b9e 100644
--- a/cpp/test/Ice/custom/TestI.cpp
+++ b/cpp/test/Ice/custom/TestI.cpp
@@ -128,6 +128,38 @@ TestIntfI::opBoolList(const std::list<bool>& inSeq,
     return inSeq;
 }
 
+::Test::BoolDequeList 
+TestIntfI::opBoolDequeList(const ::Test::BoolDequeList& inSeq, ::Test::BoolDequeList& outSeq, const Ice::Current&)
+{
+    outSeq = inSeq;
+    return inSeq;
+}
+
+::Test::BoolDequeList 
+TestIntfI::opBoolDequeListArray(const ::std::pair<const std::deque<bool>*, const std::deque<bool>*>& inSeq, 
+                                ::Test::BoolDequeList& outSeq, 
+                                const ::Ice::Current&)
+{
+    for(const std::deque<bool>* p = inSeq.first; p != inSeq.second; ++p)
+    {
+        outSeq.push_back(*p);
+    }
+    return outSeq;
+}
+
+::Test::BoolDequeList 
+TestIntfI::opBoolDequeListRange(const ::std::pair< ::Test::BoolDequeList::const_iterator,
+                                                   ::Test::BoolDequeList::const_iterator>& inSeq,
+                                ::Test::BoolDequeList& outSeq,
+                                const ::Ice::Current&)
+{
+    for(::Test::BoolDequeList::const_iterator p = inSeq.first; p != inSeq.second; ++p)
+    {
+        outSeq.push_back(*p);
+    }
+    return outSeq;
+}
+
 std::deque< ::Ice::Byte>
 TestIntfI::opByteSeq(const std::deque< ::Ice::Byte>& inSeq,
                      std::deque< ::Ice::Byte>& outSeq,
diff --git a/cpp/test/Ice/custom/TestI.h b/cpp/test/Ice/custom/TestI.h
index cd30bb89bf8..474ad7c51b5 100644
--- a/cpp/test/Ice/custom/TestI.h
+++ b/cpp/test/Ice/custom/TestI.h
@@ -70,6 +70,20 @@ public:
                                        std::list<bool>&,
                                        const Ice::Current&);
 
+    virtual ::Test::BoolDequeList opBoolDequeList(const ::Test::BoolDequeList&, 
+                                                  ::Test::BoolDequeList&, 
+                                                  const Ice::Current&);
+
+    virtual ::Test::BoolDequeList opBoolDequeListArray(const ::std::pair<const std::deque<bool>*, 
+                                                                         const std::deque<bool>*>&, 
+                                                       ::Test::BoolDequeList&, 
+                                                       const ::Ice::Current&);
+
+    virtual ::Test::BoolDequeList opBoolDequeListRange(const ::std::pair< ::Test::BoolDequeList::const_iterator,
+                                                                          ::Test::BoolDequeList::const_iterator>&, 
+                                                       ::Test::BoolDequeList&, 
+                                                       const ::Ice::Current&);
+
     virtual std::deque< ::Ice::Byte> opByteSeq(const std::deque< ::Ice::Byte>&,
                                                std::deque< ::Ice::Byte>&,
                                                const Ice::Current&);
diff --git a/cpp/test/Ice/optional/AllTests.cpp b/cpp/test/Ice/optional/AllTests.cpp
new file mode 100644
index 00000000000..f1566cff448
--- /dev/null
+++ b/cpp/test/Ice/optional/AllTests.cpp
@@ -0,0 +1,1035 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/Ice.h>
+#include <TestCommon.h>
+#include <Test.h>
+
+using namespace std;
+using namespace Test;
+
+class TestObjectReader : public Ice::ObjectReader
+{
+public:
+    virtual void
+    read(const Ice::InputStreamPtr& in)
+    {
+        in->startObject();
+        in->startSlice();
+        in->endSlice();
+        in->endObject(false);
+    }
+};
+
+class BObjectReader : public Ice::ObjectReader
+{
+public:
+    virtual void
+    read(const Ice::InputStreamPtr& in)
+    {
+        in->startObject();
+        // ::Test::B
+        in->startSlice();
+        Ice::Int v;
+        in->read(v);
+        in->endSlice();
+        // ::Test::A
+        in->startSlice();
+        in->read(v);
+        in->endSlice();
+        in->endObject(false);
+    }
+};
+
+class CObjectReader : public Ice::ObjectReader
+{
+public:
+    virtual void
+    read(const Ice::InputStreamPtr& in)
+    {
+        in->startObject();
+        // ::Test::C
+        in->startSlice();
+        in->skipSlice();
+        // ::Test::B
+        in->startSlice();
+        Ice::Int v;
+        in->read(v);
+        in->endSlice();
+        // ::Test::A
+        in->startSlice();
+        in->read(v);
+        in->endSlice();
+        in->endObject(false);
+    }
+};
+
+class DObjectWriter : public Ice::ObjectWriter
+{
+public:
+
+    virtual void
+    write(const Ice::OutputStreamPtr& out) const
+    {
+        out->startObject(0);
+        // ::Test::D
+        out->startSlice("::Test::D", false);
+        string s = "test";
+        out->write(s);
+        IceUtil::Optional<vector<string> > o;
+        o = vector<string>();
+        o->push_back("test1");
+        o->push_back("test2");
+        o->push_back("test3");
+        o->push_back("test4");
+        out->write(1, o);
+        APtr a = new A();
+        a->mc = 18;
+        out->write(1000, IceUtil::Optional<APtr>(a));
+        out->endSlice();
+        // ::Test::B
+        out->startSlice(B::ice_staticId(), false);
+        Ice::Int v = 14;
+        out->write(v);
+        out->endSlice();
+        // ::Test::A
+        out->startSlice(A::ice_staticId(), true);
+        out->write(v);
+        out->endSlice();
+        out->endObject();
+    }
+};
+
+class DObjectReader : public Ice::ObjectReader
+{
+public:
+
+    virtual void
+    read(const Ice::InputStreamPtr& in)
+    {
+        in->startObject();
+        // ::Test::D
+        in->startSlice();
+        string s;
+        in->read(s);
+        test(s == "test");
+        IceUtil::Optional<vector<string> > o;
+        in->read(1, o);
+        test(o && o->size() == 4 && 
+             (*o)[0] == "test1" && (*o)[1] == "test2" && (*o)[2] == "test3" && (*o)[3] == "test4");
+        in->read(1000, a);
+        in->endSlice();
+        // ::Test::B
+        in->startSlice();
+        Ice::Int v;
+        in->read(v);
+        in->endSlice();
+        // ::Test::A
+        in->startSlice();
+        in->read(v);
+        in->endSlice();
+        in->endObject(false);
+    }
+
+    void check()
+    {
+        test((*a)->mc == 18);
+    }
+
+private:
+
+    IceUtil::Optional<APtr> a;
+
+};
+
+class FactoryI : public Ice::ObjectFactory
+{
+    bool _enabled;
+
+public:
+
+    Ice::ObjectPtr
+    create(const string& typeId) 
+    {
+        if(!_enabled)
+        {
+            return 0;
+        }
+
+        if(typeId == "::Test::OneOptional")
+        {
+            return new TestObjectReader;
+        }
+        else if(typeId == "::Test::MultiOptional")
+        {
+            return new TestObjectReader;
+        }
+        else if(typeId == "::Test::B")
+        {
+            return new BObjectReader;
+        }
+        else if(typeId == "::Test::C")
+        {
+            return new CObjectReader;
+        }
+        else if(typeId == "::Test::D")
+        {
+            return new DObjectReader;
+        }
+        
+        return 0;
+    }
+
+    void destroy()
+    {
+    }
+
+    void
+    setEnabled(bool enabled)
+    {
+        _enabled = enabled;
+    }
+};
+
+InitialPrx
+allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
+{
+    FactoryI* factory = new FactoryI();
+    Ice::ObjectFactoryPtr f(factory);
+    communicator->addObjectFactory(factory, "");
+
+    cout << "testing stringToProxy... " << flush;
+    string ref = "initial:default -p 12010";
+    Ice::ObjectPrx base = communicator->stringToProxy(ref);
+    test(base);
+    cout << "ok" << endl;
+
+    cout << "testing checked cast... " << flush;
+    InitialPrx initial = InitialPrx::checkedCast(base);
+    test(initial);
+    test(initial == base);
+    cout << "ok" << endl;
+
+    cout << "testing constructor, copy constructor, and assignment operator... " << flush;
+
+    OneOptionalPtr oo1 = new OneOptional();
+    test(!oo1->a);
+    oo1->a = 15;
+    test(oo1->a && *oo1->a == 15);
+
+    OneOptionalPtr oo2 = new OneOptional(16);
+    test(oo2->a && *oo2->a == 16);
+
+    OneOptionalPtr oo3 = new OneOptional(*oo2);
+    test(oo3->a && *oo3->a == 16);
+
+    *oo3 = *oo1;
+    test(oo3->a && *oo3->a == 15);
+
+    OneOptionalPtr oon = new OneOptional(IceUtil::None);
+    test(!oon->a);
+
+    MultiOptionalPtr mo1 = new MultiOptional();
+    mo1->a = 15;
+    mo1->b = true;
+    mo1->c = 19;
+    mo1->d = 78;
+    mo1->e = 99;
+    mo1->f = 5.5f;
+    mo1->g = 1.0;
+    mo1->h = "test";
+    mo1->i = Test::MyEnumMember;
+    mo1->j = MultiOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+    mo1->k = mo1;
+    mo1->bs = ByteSeq(); 
+    (*mo1->bs).push_back(5);
+    mo1->ss = StringSeq();
+    mo1->ss->push_back("test");
+    mo1->ss->push_back("test2");
+    mo1->iid = IntIntDict();
+    (*mo1->iid)[4] = 3;
+    mo1->sid = StringIntDict();
+    (*mo1->sid)["test"] = 10;
+    FixedStruct fs;
+    fs.m = 78;
+    mo1->fs = fs;
+    VarStruct vs;
+    vs.m = "hello";
+    mo1->vs = vs;
+
+    mo1->shs = ShortSeq();
+    mo1->shs->push_back(1);
+    mo1->es = MyEnumSeq();
+    mo1->es->push_back(MyEnumMember);
+    mo1->es->push_back(MyEnumMember);
+    mo1->fss = FixedStructSeq();
+    mo1->fss->push_back(fs);
+    mo1->vss = VarStructSeq();
+    mo1->vss->push_back(vs);
+    mo1->oos = OneOptionalSeq();
+    mo1->oos->push_back(oo1);
+    mo1->oops = OneOptionalPrxSeq();
+    mo1->oops->push_back(OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test")));
+
+    mo1->ied = IntEnumDict();
+    mo1->ied.get()[4] = MyEnumMember;
+    mo1->ifsd = IntFixedStructDict();
+    mo1->ifsd.get()[4] = fs;
+    mo1->ivsd = IntVarStructDict();
+    mo1->ivsd.get()[5] = vs;
+    mo1->iood = IntOneOptionalDict();
+    mo1->iood.get()[5] = new OneOptional();
+    mo1->iood.get()[5]->a = 15;
+    mo1->ioopd = IntOneOptionalPrxDict();
+    mo1->ioopd.get()[5] = OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+
+    mo1->bos = BoolSeq();
+    mo1->bos->push_back(false);
+    mo1->bos->push_back(true);
+    mo1->bos->push_back(false);
+
+    MultiOptionalPtr mo2 = new MultiOptional(*mo1);
+
+    MultiOptionalPtr mo3 = new MultiOptional();
+    *mo3 = *mo2;
+
+    test(mo3->a == 15);
+    test(mo3->b == true);
+    test(mo3->c == 19);
+    test(mo3->d == 78);
+    test(mo3->e == 99);
+    test(mo3->f == 5.5f);
+    test(mo3->g == 1.0);
+    test(mo3->h == string("test"));
+    test(mo3->i == Test::MyEnumMember);
+    test(mo3->j == MultiOptionalPrx::uncheckedCast(communicator->stringToProxy("test")));
+    test(mo3->k == mo1);
+    test(mo3->bs == mo1->bs);
+    test(mo3->ss == mo1->ss);
+    test(mo3->iid == mo1->iid);
+    test(mo3->sid == mo1->sid);
+    test(mo3->fs == mo1->fs);
+    test(mo3->vs == mo1->vs);
+
+    test(mo3->shs == mo1->shs);
+    test(mo3->es == mo1->es);
+    test(mo3->fss == mo1->fss);
+    test(mo3->vss == mo1->vss);
+    test(mo3->oos == mo1->oos);
+    test(mo3->oops == mo1->oops);
+
+    test(mo3->ied == mo1->ied);
+    test(mo3->ifsd == mo1->ifsd);
+    test(mo3->ivsd == mo1->ivsd);
+    test(mo3->iood == mo1->iood);
+    test(mo3->ioopd == mo1->ioopd);
+
+    test(mo3->bos == mo1->bos);
+
+    cout << "ok" << endl;
+
+    cout << "testing marshalling... " << flush;
+    OneOptionalPtr oo4 = OneOptionalPtr::dynamicCast(initial->pingPong(new OneOptional()));
+    test(!oo4->a);
+
+    OneOptionalPtr oo5 = OneOptionalPtr::dynamicCast(initial->pingPong(oo1));
+    test(oo1->a == oo5->a);
+
+    MultiOptionalPtr mo4 = MultiOptionalPtr::dynamicCast(initial->pingPong(new MultiOptional()));
+    test(!mo4->a);
+    test(!mo4->b);
+    test(!mo4->c);
+    test(!mo4->d);
+    test(!mo4->e);
+    test(!mo4->f);
+    test(!mo4->g);
+    test(!mo4->h);
+    test(!mo4->i);
+    test(!mo4->j);
+    test(!mo4->k);
+    test(!mo4->bs);
+    test(!mo4->ss);
+    test(!mo4->iid);
+    test(!mo4->sid);
+    test(!mo4->fs);
+    test(!mo4->vs);
+
+    test(!mo4->shs);
+    test(!mo4->es);
+    test(!mo4->fss);
+    test(!mo4->vss);
+    test(!mo4->oos);
+    test(!mo4->oops);
+
+    test(!mo4->ied);
+    test(!mo4->ifsd);
+    test(!mo4->ivsd);
+    test(!mo4->iood);
+    test(!mo4->ioopd);
+
+    test(!mo4->bos);
+    
+    mo1->k = mo1;
+    MultiOptionalPtr mo5 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo1));
+    test(mo5->a == mo1->a);
+    test(mo5->b == mo1->b);
+    test(mo5->c == mo1->c);
+    test(mo5->d == mo1->d);
+    test(mo5->e == mo1->e);
+    test(mo5->f == mo1->f);
+    test(mo5->g == mo1->g);
+    test(mo5->h == mo1->h);
+    test(mo5->i == mo1->i);
+    test(mo5->j == mo1->j);
+    test(mo5->k == mo5->k);
+    test(mo5->bs == mo1->bs);
+    test(mo5->ss == mo1->ss);
+    test(mo5->iid == mo1->iid);
+    test(mo5->sid == mo1->sid);
+    test(mo5->fs == mo1->fs);
+    test(mo5->vs == mo1->vs);
+
+    test(mo5->shs == mo1->shs);
+    test(mo5->es == mo1->es);
+    test(mo5->fss == mo1->fss);
+    test(mo5->vss == mo1->vss);
+    test(!mo5->oos->empty() && (*mo5->oos)[0]->a == oo1->a);
+    test(mo5->oops == mo1->oops);
+
+    test(mo5->ied == mo1->ied);
+    test(mo5->ifsd == mo1->ifsd);
+    test(mo5->ivsd == mo1->ivsd);
+    test(!mo5->iood->empty() && (*mo5->iood)[5]->a == 15);
+    test(mo5->ioopd == mo1->ioopd);
+
+    test(mo5->bos == mo1->bos);
+
+    // Clear the first half of the optional parameters
+    MultiOptionalPtr mo6 = new MultiOptional(*mo5);
+    mo6->a = IceUtil::None;
+    mo6->c = IceUtil::None;
+    mo6->e = IceUtil::None;
+    mo6->g = IceUtil::None;
+    mo6->i = IceUtil::None;
+    mo6->k = IceUtil::None;
+    mo6->ss = IceUtil::None;
+    mo6->sid = IceUtil::None;
+    mo6->vs = IceUtil::None;
+
+    mo6->es = IceUtil::None;
+    mo6->vss = IceUtil::None;
+    mo6->oops = IceUtil::None;
+
+    mo6->ied = IceUtil::None;
+    mo6->ivsd = IceUtil::None;
+    mo6->ioopd = IceUtil::None;
+
+    MultiOptionalPtr mo7 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo6));
+    test(!mo7->a);
+    test(mo7->b == mo1->b);
+    test(!mo7->c);
+    test(mo7->d == mo1->d);
+    test(!mo7->e);
+    test(mo7->f == mo1->f);
+    test(!mo7->g);
+    test(mo7->h == mo1->h);
+    test(!mo7->i);
+    test(mo7->j == mo1->j);
+    test(!mo7->k);
+    test(mo7->bs == mo1->bs);
+    test(!mo7->ss);
+    test(mo7->iid == mo1->iid);
+    test(!mo7->sid);
+    test(mo7->fs == mo1->fs);
+    test(!mo7->vs);
+
+    test(mo7->shs == mo1->shs);
+    test(!mo7->es);
+    test(mo7->fss == mo1->fss);
+    test(!mo7->vss);
+    test(!mo7->oos->empty() && (*mo7->oos)[0]->a == oo1->a);
+    test(!mo7->oops);
+
+    test(!mo7->ied);
+    test(mo7->ifsd == mo1->ifsd);
+    test(!mo7->ivsd);
+    test(!mo7->iood->empty() && (*mo7->iood)[5]->a == 15);
+    test(!mo7->ioopd);
+
+    // Clear the second half of the optional parameters
+    MultiOptionalPtr mo8 = new MultiOptional(*mo5);
+    mo8->b = IceUtil::None;
+    mo8->d = IceUtil::None;
+    mo8->f = IceUtil::None;
+    mo8->h = IceUtil::None;
+    mo8->j = IceUtil::None;
+    mo8->bs = IceUtil::None;
+    mo8->iid = IceUtil::None;
+    mo8->fs = IceUtil::None;
+
+    mo8->shs = IceUtil::None;
+    mo8->fss = IceUtil::None;
+    mo8->oos = IceUtil::None;
+
+    mo8->ifsd = IceUtil::None;
+    mo8->iood = IceUtil::None;
+
+    MultiOptionalPtr mo9 = MultiOptionalPtr::dynamicCast(initial->pingPong(mo8));
+    test(mo9->a == mo1->a);
+    test(!mo9->b);
+    test(mo9->c == mo1->c);
+    test(!mo9->d);
+    test(mo9->e == mo1->e);
+    test(!mo9->f);
+    test(mo9->g == mo1->g);
+    test(!mo9->h);
+    test(mo9->i == mo1->i);
+    test(!mo9->j);
+    test(mo9->k == mo9->k);
+    test(!mo9->bs);
+    test(mo9->ss == mo1->ss);
+    test(!mo9->iid);
+    test(mo9->sid == mo1->sid);
+    test(!mo9->fs);
+    test(mo9->vs == mo1->vs);
+
+    test(!mo8->shs);
+    test(mo8->es == mo1->es);
+    test(!mo8->fss);
+    test(mo8->vss == mo1->vss);
+    test(!mo8->oos);
+    test(mo8->oops == mo1->oops);
+
+    test(mo8->ied == mo1->ied);
+    test(!mo8->ifsd);
+    test(mo8->ivsd == mo1->ivsd);
+    test(!mo8->iood);
+
+    //
+    // Send a request using blobjects. Upon receival, we don't read
+    // any of the optional members. This ensures the optional members
+    // are skipped even if the receiver knows nothing about them.
+    //
+    factory->setEnabled(true);
+    Ice::OutputStreamPtr out = Ice::createOutputStream(communicator);
+    out->startEncapsulation();
+    out->write(oo1);
+    out->endEncapsulation();
+    Ice::ByteSeq inEncaps;
+    out->finished(inEncaps);
+    Ice::ByteSeq outEncaps;
+    test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+    Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
+    in->startEncapsulation();
+    Ice::ObjectPtr obj;
+    in->read(obj);
+    in->endEncapsulation();
+    test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
+
+    out = Ice::createOutputStream(communicator);
+    out->startEncapsulation();
+    out->write(mo1);
+    out->endEncapsulation();
+    out->finished(inEncaps);
+    test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+    in = Ice::createInputStream(communicator, outEncaps);
+    in->startEncapsulation();
+    in->read(obj);
+    in->endEncapsulation();
+    test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
+    factory->setEnabled(false);
+    cout << "ok" << endl;
+
+    cout << "testing marshalling of large containers with fixed size elements..." << flush;
+    MultiOptionalPtr mc = new MultiOptional();
+
+    ByteSeq byteSeq;
+    byteSeq.resize(1000);
+    mc->bs = byteSeq;
+
+    ShortSeq shortSeq;
+    shortSeq.resize(300);
+    mc->shs = shortSeq;
+
+    FixedStructSeq fsSeq;
+    fsSeq.resize(300);
+    mc->fss = fsSeq;
+
+    IntFixedStructDict ifsd;
+    for(int i = 0; i < 300; ++i)
+    {
+        ifsd.insert(make_pair(i, FixedStruct()));
+    }
+    mc->ifsd = ifsd;
+
+    mc = MultiOptionalPtr::dynamicCast(initial->pingPong(mc));
+    test(mc->bs->size() == 1000);
+    test(mc->shs->size() == 300);
+    test(mc->fss->size() == 300);
+    test(mc->ifsd->size() == 300);
+
+    factory->setEnabled(true);
+    out = Ice::createOutputStream(communicator);
+    out->startEncapsulation();
+    out->write(mc);
+    out->endEncapsulation();
+    out->finished(inEncaps);
+    test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+    in = Ice::createInputStream(communicator, outEncaps);
+    in->startEncapsulation();
+    in->read(obj);
+    in->endEncapsulation();
+    test(obj && dynamic_cast<TestObjectReader*>(obj.get()));
+    factory->setEnabled(false);
+
+    cout << "ok" << endl;
+
+    cout << "testing tag marshalling... " << flush;
+    BPtr b = new B();
+    BPtr b2 = BPtr::dynamicCast(initial->pingPong(b));
+    test(!b2->ma);
+    test(!b2->mb);
+    test(!b2->mc);
+    
+    b->ma = 10;
+    b->mb = 11;
+    b->mc = 12;
+    b->md = 13;
+
+    b2 = BPtr::dynamicCast(initial->pingPong(b));
+    test(b2->ma == 10);
+    test(b2->mb == 11);
+    test(b2->mc == 12);
+    test(b2->md == 13);
+
+    factory->setEnabled(true);
+    out = Ice::createOutputStream(communicator);
+    out->startEncapsulation();
+    out->write(b);
+    out->endEncapsulation();
+    out->finished(inEncaps);
+    test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+    in = Ice::createInputStream(communicator, outEncaps);
+    in->startEncapsulation();
+    in->read(obj);
+    in->endEncapsulation();
+    test(obj);
+    factory->setEnabled(false);
+
+    cout << "ok" << endl;
+
+    cout << "testing optional with default values... " << flush;
+    WDPtr wd = WDPtr::dynamicCast(initial->pingPong(new WD()));
+    test(*wd->a == 5);
+    test(*wd->s == "test");
+    wd->a = IceUtil::None;
+    wd->s = IceUtil::None;
+    wd = WDPtr::dynamicCast(initial->pingPong(wd));
+    test(!wd->a);
+    test(!wd->s);
+    cout << "ok" << endl;
+
+    if(communicator->getProperties()->getPropertyAsInt("Ice.Default.SlicedFormat") > 0)
+    {
+        cout << "testing marshalling with unknown class slices... " << flush;
+        CPtr c = new C();
+        c->ss = "test";
+        c->ms = "testms";
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(c);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        factory->setEnabled(true);
+        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(obj);
+        in->endEncapsulation();
+        test(dynamic_cast<CObjectReader*>(obj.get())); 
+        factory->setEnabled(false);
+
+        factory->setEnabled(true);
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        Ice::ObjectPtr d = new DObjectWriter();
+        out->write(d);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        test(initial->ice_invoke("pingPong", Ice::Normal, inEncaps, outEncaps));
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(obj);
+        in->endEncapsulation();
+        test(obj && dynamic_cast<DObjectReader*>(obj.get()));
+        dynamic_cast<DObjectReader*>(obj.get())->check();
+        factory->setEnabled(false);
+    
+        cout << "ok" << endl;
+    }
+
+    cout << "testing optional parameters... " << flush;
+    {
+        IceUtil::Optional<Ice::Byte> p1;
+        IceUtil::Optional<Ice::Byte> p3;
+        IceUtil::Optional<Ice::Byte> p2 = initial->opByte(p1, p3);
+        test(!p2 && !p3);
+
+        p1 = 56;
+        p2 = initial->opByte(p1, p3);
+        test(p2 == 56 && p3 == 56);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opByte", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == 56 && p3 == 56);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<Ice::Long> p1;
+        IceUtil::Optional<Ice::Long> p3;
+        IceUtil::Optional<Ice::Long> p2 = initial->opLong(p1, p3);
+        test(!p2 && !p3);
+
+        p1 = 56;
+        p2 = initial->opLong(p1, p3);
+        test(p2 == 56 && p3 == 56);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opLong", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == 56 && p3 == 56);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<string> p1;
+        IceUtil::Optional<string> p3;
+        IceUtil::Optional<string> p2 = initial->opString(p1, p3);
+        test(!p2 && !p3);
+
+        p1 = string("test");
+        p2 = initial->opString(p1, p3);
+        test(p2 == string("test") && p3 == string("test"));
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opString", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == string("test") && p3 == string("test"));
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<OneOptionalPtr> p1;
+        IceUtil::Optional<OneOptionalPtr> p3;
+        IceUtil::Optional<OneOptionalPtr> p2 = initial->opOneOptional(p1, p3);
+        test(!p2 && !p3);
+
+        p1 = new OneOptional(58);
+        p2 = initial->opOneOptional(p1, p3);
+        test((*p2)->a == 58 && (*p3)->a == 58);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opOneOptional", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test((*p2)->a == 58 && (*p3)->a == 58);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<OneOptionalPrx> p1;
+        IceUtil::Optional<OneOptionalPrx> p3;
+        IceUtil::Optional<OneOptionalPrx> p2 = initial->opOneOptionalProxy(p1, p3);
+        test(!p2 && !p3);
+
+        p1 = OneOptionalPrx::uncheckedCast(communicator->stringToProxy("test"));
+        p2 = initial->opOneOptionalProxy(p1, p3);
+        test(p2 == p1 && p3 == p1);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opOneOptionalProxy", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == p1 && p3 == p1);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    cout << "ok" << endl;
+
+    cout << "testing optional parameters and custom sequences... " << flush;
+    {
+        IceUtil::Optional<std::pair<const Ice::Byte*, const Ice::Byte*> > p1;
+        IceUtil::Optional<ByteSeq> p3;
+        IceUtil::Optional<ByteSeq> p2 = initial->opByteSeq(p1, p3);
+        test(!p2 && !p3);
+
+        vector<Ice::Byte> bs(100);
+        fill(bs.begin(), bs.end(), 56);
+        p1 = make_pair(&bs[0], &bs[0] + bs.size());
+        p2 = initial->opByteSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == bs && p3 == bs);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opByteSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == bs && p3 == bs);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<std::pair<const Ice::Short*, const Ice::Short*> > p1;
+        IceUtil::Optional<ShortSeq> p3;
+        IceUtil::Optional<ShortSeq> p2 = initial->opShortSeq(p1, p3);
+        test(!p2 && !p3);
+
+        vector<Ice::Short> bs(100);
+        fill(bs.begin(), bs.end(), 56);
+        p1 = make_pair(&bs[0], &bs[0] + bs.size());
+        p2 = initial->opShortSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == bs && p3 == bs);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opByteSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == bs && p3 == bs);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<std::pair<const bool*, const bool*> > p1;
+        IceUtil::Optional<BoolSeq> p3;
+        IceUtil::Optional<BoolSeq> p2 = initial->opBoolSeq(p1, p3);
+        test(!p2 && !p3);
+
+        bool bs[100];
+        vector<bool> bsv(&bs[0], &bs[0] + 100);
+        p1 = make_pair(&bs[0], &bs[0] + 100);
+        p2 = initial->opBoolSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == bsv && p3 == bsv);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opBoolSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == bsv && p3 == bsv);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation(); 
+    }
+
+    {
+        IceUtil::Optional<std::pair<StringSeq::const_iterator, StringSeq::const_iterator> > p1;
+        IceUtil::Optional<StringSeq> p3;
+        IceUtil::Optional<StringSeq> p2 = initial->opStringSeq(p1, p3);
+        test(!p2 && !p3);
+
+        StringSeq ss(10);
+        fill(ss.begin(), ss.end(), "test1");
+        p1 = make_pair(&ss[0], &ss[0] + ss.size());
+        p2 = initial->opStringSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == ss && p3 == ss);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opStringSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == ss && p3 == ss);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    {
+        IceUtil::Optional<std::pair<const FixedStruct*, const FixedStruct*> > p1;
+        IceUtil::Optional<FixedStructSeq> p3;
+        IceUtil::Optional<FixedStructSeq> p2 = initial->opFixedStructSeq(p1, p3);
+        test(!p2 && !p3);
+
+        FixedStruct fss[10];
+        vector<FixedStruct> fssv(&fss[0], &fss[0] + 10);
+        p1 = make_pair(&fss[0], &fss[0] + 10);
+        p2 = initial->opFixedStructSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == fssv && p3 == fssv);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opFixedStructSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == fssv && p3 == fssv);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation(); 
+    }
+
+    {
+        IceUtil::Optional<std::pair<VarStructSeq::const_iterator, VarStructSeq::const_iterator> > p1;
+        IceUtil::Optional<VarStructSeq> p3;
+        IceUtil::Optional<VarStructSeq> p2 = initial->opVarStructSeq(p1, p3);
+        test(!p2 && !p3);
+
+        VarStructSeq ss(10);
+        p1 = make_pair(&ss[0], &ss[0] + ss.size());
+        p2 = initial->opVarStructSeq(p1, p3);
+        test(p2 && p3);
+        test(p2 == ss && p3 == ss);
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(2, p1);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        initial->ice_invoke("opVarStructSeq", Ice::Normal, inEncaps, outEncaps);
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->read(1, p2);
+        in->read(3, p3);
+        in->endEncapsulation();
+        test(p2 == ss && p3 == ss);
+
+        in = Ice::createInputStream(communicator, outEncaps);
+        in->startEncapsulation();
+        in->endEncapsulation();
+    }
+
+    cout << "ok" << endl;
+
+    cout << "testing exception optionals... " << flush;
+    {
+        try
+        {
+            initial->opOptionalException(IceUtil::None, IceUtil::None, IceUtil::None);
+        }
+        catch(const OptionalException& ex)
+        {
+            test(!ex.a);
+            test(!ex.b);
+            test(!ex.o);
+        }
+
+        try
+        {
+            initial->opOptionalException(30, string("test"), OneOptionalPtr(new OneOptional(53)));
+        }
+        catch(const OptionalException& ex)
+        {
+            test(ex.a == 30);
+            test(ex.b == string("test"));
+            test((*ex.o)->a = 53);
+        }
+    }
+    cout << "ok" << endl;
+
+    return initial;
+}
diff --git a/cpp/test/Ice/optional/Client.cpp b/cpp/test/Ice/optional/Client.cpp
new file mode 100644
index 00000000000..ffb919949ef
--- /dev/null
+++ b/cpp/test/Ice/optional/Client.cpp
@@ -0,0 +1,57 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/Ice.h>
+#include <TestCommon.h>
+#include <TestI.h>
+
+using namespace std;
+using namespace Test;
+
+int
+run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+{
+    InitialPrx allTests(const Ice::CommunicatorPtr&, bool);
+    InitialPrx initial = allTests(communicator, false);
+    initial->shutdown();
+    return EXIT_SUCCESS;
+}
+
+int
+main(int argc, char* argv[])
+{
+    int status;
+    Ice::CommunicatorPtr communicator;
+
+    try
+    {
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
+    }
+    catch(const Ice::Exception& ex)
+    {
+        cerr << ex << endl;
+        status = EXIT_FAILURE;
+    }
+
+    if(communicator)
+    {
+        try
+        {
+            communicator->destroy();
+        }
+        catch(const Ice::Exception& ex)
+        {
+            cerr << ex << endl;
+            status = EXIT_FAILURE;
+        }
+    }
+
+    return status;
+}
diff --git a/cpp/test/Ice/optional/Makefile b/cpp/test/Ice/optional/Makefile
new file mode 100644
index 00000000000..575f8aaea22
--- /dev/null
+++ b/cpp/test/Ice/optional/Makefile
@@ -0,0 +1,44 @@
+# **********************************************************************
+#
+# Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+#
+# This copy of Ice is licensed to you under the terms described in the
+# ICE_LICENSE file included in this distribution.
+#
+# **********************************************************************
+
+top_srcdir	= ../../..
+
+CLIENT		= client
+SERVER		= server
+
+TARGETS		= $(CLIENT) $(SERVER)
+
+OBJS		= Test.o \
+                  TestI.o
+
+COBJS		= Client.o \
+		  AllTests.o
+
+SOBJS		= Server.o
+
+SRCS		= $(OBJS:.o=.cpp) \
+		  $(COBJS:.o=.cpp) \
+		  $(SOBJS:.o=.cpp) \
+
+SLICE_SRCS	= Test.ice
+
+include $(top_srcdir)/config/Make.rules
+
+CPPFLAGS	:= -I. -I../../include $(CPPFLAGS)
+SLICE2CPPFLAGS  := --stream $(SLICE2CPPFLAGS)
+
+$(CLIENT): $(OBJS) $(COBJS)
+	rm -f $@
+	$(CXX) $(LDFLAGS) -o $@ $(OBJS) $(COBJS) $(LIBS)
+
+$(SERVER): $(OBJS) $(SOBJS)
+	rm -f $@
+	$(CXX) $(LDFLAGS) -o $@ $(OBJS) $(SOBJS) $(LIBS)
+
+include .depend
diff --git a/cpp/test/Ice/optional/Makefile.mak b/cpp/test/Ice/optional/Makefile.mak
new file mode 100644
index 00000000000..7e08d35b94c
--- /dev/null
+++ b/cpp/test/Ice/optional/Makefile.mak
@@ -0,0 +1,52 @@
+# **********************************************************************

+#

+# Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.

+#

+# This copy of Ice is licensed to you under the terms described in the

+# ICE_LICENSE file included in this distribution.

+#

+# **********************************************************************

+

+top_srcdir	= ..\..\..

+

+CLIENT		= client.exe

+SERVER		= server.exe

+

+TARGETS		= $(CLIENT) $(SERVER)

+

+COBJS		= Test.obj \

+		  TestI.obj \

+		  Client.obj \

+		  AllTests.obj

+

+SOBJS		= Test.obj \

+		  TestI.obj \

+		  Server.obj

+

+SRCS		= $(COBJS:.obj=.cpp) \

+		  $(SOBJS:.obj=.cpp)

+

+!include $(top_srcdir)/config/Make.rules.mak

+

+SLICE2CPPFLAGS	= --stream $(SLICE2CPPFLAGS)

+CPPFLAGS	= -I. -I../../include $(CPPFLAGS) -DWIN32_LEAN_AND_MEAN

+

+!if "$(GENERATE_PDB)" == "yes"

+CPDBFLAGS        = /pdb:$(CLIENT:.exe=.pdb)

+SPDBFLAGS        = /pdb:$(SERVER:.exe=.pdb)

+!endif

+

+$(CLIENT): $(COBJS)

+	$(LINK) $(LD_EXEFLAGS) $(CPDBFLAGS) $(SETARGV) $(COBJS) $(PREOUT)$@ $(PRELIBS)$(LIBS)

+	@if exist $@.manifest echo ^ ^ ^ Embedding manifest using $(MT) && \

+	    $(MT) -nologo -manifest $@.manifest -outputresource:$@;#1 && del /q $@.manifest

+

+$(SERVER): $(SOBJS)

+	$(LINK) $(LD_EXEFLAGS) $(SPDBFLAGS) $(SETARGV) $(SOBJS) $(PREOUT)$@ $(PRELIBS)$(LIBS)

+	@if exist $@.manifest echo ^ ^ ^ Embedding manifest using $(MT) && \

+	    $(MT) -nologo -manifest $@.manifest -outputresource:$@;#1 && del /q $@.manifest

+

+clean::

+	del /q Test.cpp Test.h

+

+!include .depend.mak

diff --git a/cpp/test/Ice/optional/Server.cpp b/cpp/test/Ice/optional/Server.cpp
new file mode 100644
index 00000000000..089f0e1ce00
--- /dev/null
+++ b/cpp/test/Ice/optional/Server.cpp
@@ -0,0 +1,58 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/Ice.h>
+#include <TestI.h>
+
+using namespace std;
+using namespace Test;
+
+int
+run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+{
+    communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010");
+    Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
+    adapter->add(new InitialI(), communicator->stringToIdentity("initial"));
+    adapter->activate();
+    communicator->waitForShutdown();
+    return EXIT_SUCCESS;
+}
+
+int
+main(int argc, char* argv[])
+{
+    int status;
+    Ice::CommunicatorPtr communicator;
+
+    try
+    {
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
+    }
+    catch(const Ice::Exception& ex)
+    {
+        cerr << ex << endl;
+        status = EXIT_FAILURE;
+    }
+
+    if(communicator)
+    {
+        try
+        {
+            communicator->destroy();
+        }
+        catch(const Ice::Exception& ex)
+        {
+            cerr << ex << endl;
+            status = EXIT_FAILURE;
+        }
+    }
+
+    return status;
+}
diff --git a/cpp/test/Ice/optional/Test.ice b/cpp/test/Ice/optional/Test.ice
new file mode 100644
index 00000000000..d42e89a0daf
--- /dev/null
+++ b/cpp/test/Ice/optional/Test.ice
@@ -0,0 +1,175 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:include:list"]]
+
+module Test
+{
+
+class OneOptional
+{
+    optional(1) int a;
+};
+
+enum MyEnum
+{
+    MyEnumMember
+};
+
+struct FixedStruct
+{
+    int m; 
+};
+
+struct VarStruct
+{
+    string m;
+};
+
+["cpp:class"] struct ClassVarStruct
+{
+    int a;
+};
+
+sequence<byte> ByteSeq;
+sequence<bool> BoolSeq;
+sequence<short> ShortSeq;
+sequence<string> StringSeq;
+sequence<MyEnum> MyEnumSeq;
+sequence<FixedStruct> FixedStructSeq;
+sequence<VarStruct> VarStructSeq;
+sequence<OneOptional> OneOptionalSeq;
+sequence<OneOptional*> OneOptionalPrxSeq;
+
+dictionary<int, int> IntIntDict; 
+dictionary<string, int> StringIntDict; 
+dictionary<int, MyEnum> IntEnumDict;
+dictionary<int, FixedStruct> IntFixedStructDict;
+dictionary<int, VarStruct> IntVarStructDict;
+dictionary<int, OneOptional> IntOneOptionalDict;
+dictionary<int, OneOptional*> IntOneOptionalPrxDict;
+
+class MultiOptional
+{
+    optional(1) byte a;
+    optional(2) bool  b;
+    optional(3) short c;
+    optional(4) int d;
+    optional(5) long e;
+    optional(6) float f;
+    optional(7) double g;
+    optional(8) string h;
+    optional(9) MyEnum i;
+    optional(10) MultiOptional* j;
+    optional(11) MultiOptional k;
+    optional(12) ByteSeq bs;
+    optional(13) StringSeq ss;
+    optional(14) IntIntDict iid;
+    optional(15) StringIntDict sid;
+    optional(16) FixedStruct fs;
+    optional(17) VarStruct vs;
+
+    optional(18) ShortSeq shs;
+    optional(19) MyEnumSeq es;
+    optional(20) FixedStructSeq fss;
+    optional(21) VarStructSeq vss;
+    optional(22) OneOptionalSeq oos;
+    optional(23) OneOptionalPrxSeq oops;
+
+    optional(24) IntEnumDict ied;
+    optional(25) IntFixedStructDict ifsd;
+    optional(26) IntVarStructDict ivsd;
+    optional(27) IntOneOptionalDict iood;
+    optional(28) IntOneOptionalPrxDict ioopd;
+
+    optional(29) BoolSeq bos;
+};
+
+class A
+{
+    int requiredA;
+    optional(1) int ma;
+    optional(50) int mb;
+    optional(500) int mc;
+};
+
+["preserve-slice"]
+class B extends A
+{
+    int requiredB;
+    optional(10) int md;
+};
+
+class C extends B
+{
+    string ss;
+    optional(890) string ms;
+};
+
+class WD
+{
+    optional(1) int a = 5;
+    optional(2) string s = "test";
+};
+
+exception OptionalException
+{
+    optional(1) int a = 5;
+    optional(2) string b;
+    optional(50) OneOptional o;
+};
+
+class OptionalWithCustom
+{
+    ["cpp:type:std::list< ::Ice::Byte>"] optional(1) ByteSeq bs;
+    optional(2) ClassVarStruct s;
+};
+
+class Initial
+{
+    void shutdown();
+
+    Object pingPong(Object o);
+
+    void opOptionalException(optional(1) int a, optional(2) string b, optional(3) OneOptional o)
+        throws OptionalException;
+
+    optional(1) byte opByte(optional(2) byte p1, out optional(3) byte p3);
+
+    optional(1) long opLong(optional(2) long p1, out optional(3) long p3);
+
+    optional(1) string opString(optional(2) string p1, out optional(3) string p3);
+
+    optional(1) OneOptional opOneOptional(optional(2) OneOptional p1, out optional(3) OneOptional p3);
+
+    optional(1) OneOptional* opOneOptionalProxy(optional(2) OneOptional* p1, out optional(3) OneOptional* p3);
+
+    // Custom mapping operations
+    ["cpp:array"] optional(1) ByteSeq opByteSeq(["cpp:array"] optional(2) ByteSeq p1, 
+                                                out ["cpp:array"] optional(3) ByteSeq p3);
+
+    ["cpp:array"] optional(1) ShortSeq opShortSeq(["cpp:array"] optional(2) ShortSeq p1, 
+                                                  out ["cpp:array"] optional(3) ShortSeq p3);
+
+    ["cpp:range:array"] optional(1) BoolSeq opBoolSeq(["cpp:range:array"] optional(2) BoolSeq p1, 
+                                                      out ["cpp:range:array"] optional(3) BoolSeq p3);
+
+    ["cpp:range"] optional(1) StringSeq opStringSeq(["cpp:range"] optional(2) StringSeq p1, 
+                                                    out ["cpp:range"] optional(3) StringSeq p3);
+
+    ["cpp:array"] optional(1) FixedStructSeq opFixedStructSeq(["cpp:array"] optional(2) FixedStructSeq p1, 
+                                                              out ["cpp:array"] optional(3) FixedStructSeq p3);
+
+    ["cpp:range"] optional(1) VarStructSeq opVarStructSeq(["cpp:range"] optional(2) VarStructSeq p1, 
+                                                          out ["cpp:range"] optional(3) VarStructSeq p3);
+};
+
+};
diff --git a/cpp/test/Ice/optional/TestI.cpp b/cpp/test/Ice/optional/TestI.cpp
new file mode 100644
index 00000000000..2e9a0f113dc
--- /dev/null
+++ b/cpp/test/Ice/optional/TestI.cpp
@@ -0,0 +1,147 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/Ice.h>
+#include <TestI.h>
+
+using namespace Test;
+using namespace IceUtil;
+using namespace Ice;
+using namespace std;
+
+InitialI::InitialI()
+{
+}
+
+void
+InitialI::shutdown(const Current& current)
+{
+    current.adapter->getCommunicator()->shutdown();
+}
+
+ObjectPtr
+InitialI::pingPong(const ObjectPtr& obj, const Current&)
+{
+    return obj;
+}
+
+
+void
+InitialI::opOptionalException(const Optional<Int>& a, 
+                              const Optional<string>& b, 
+                              const Optional<OneOptionalPtr>& o,
+                              const Ice::Current&)
+{
+    OptionalException ex;
+    ex.a = a;
+    ex.b = b;
+    ex.o = o;
+    throw ex;
+}
+
+Optional<Byte> 
+InitialI::opByte(const Optional<Byte>& p1, Optional<Byte>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<Long> 
+InitialI::opLong(const Optional<Long>& p1, Optional<Long>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<string> 
+InitialI::opString(const Optional<string>& p1, Optional<string>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<OneOptionalPtr> 
+InitialI::opOneOptional(const Optional<OneOptionalPtr>& p1, Optional<OneOptionalPtr>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<OneOptionalPrx> 
+InitialI::opOneOptionalProxy(const Optional<OneOptionalPrx>& p1, Optional<OneOptionalPrx>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<ByteSeq> 
+InitialI::opByteSeq(const Optional<pair<const Byte*, const Byte*> >& p1, Optional<ByteSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = ByteSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<ShortSeq> 
+InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Optional<ShortSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = ShortSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<BoolSeq> 
+InitialI::opBoolSeq(const Optional<pair<const bool*, const bool*> >& p1, Optional<BoolSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = BoolSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<StringSeq> 
+InitialI::opStringSeq(const Optional<pair<StringSeq::const_iterator, StringSeq::const_iterator> >& p1,
+                      Optional<StringSeq>& p3, 
+                      const Current&)
+{
+    if(p1)
+    {
+        p3 = StringSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<FixedStructSeq> 
+InitialI::opFixedStructSeq(const Optional<pair<const FixedStruct*, const FixedStruct*> >& p1,
+                           Optional<FixedStructSeq>& p3, 
+                           const Current&)
+{
+    if(p1)
+    {
+        p3 = FixedStructSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+    
+Optional<VarStructSeq> 
+InitialI::opVarStructSeq(const Optional<pair<VarStructSeq::const_iterator, VarStructSeq::const_iterator> >& p1,
+                         Optional<VarStructSeq>& p3, 
+                         const Current&)
+{
+    if(p1)
+    {
+        p3 = VarStructSeq(p1->first, p1->second);
+    }
+    return p3;
+}
diff --git a/cpp/test/Ice/optional/TestI.h b/cpp/test/Ice/optional/TestI.h
new file mode 100644
index 00000000000..12106c070f6
--- /dev/null
+++ b/cpp/test/Ice/optional/TestI.h
@@ -0,0 +1,82 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef TEST_I_H
+#define TEST_I_H
+
+#include <Test.h>
+
+
+class InitialI : public Test::Initial
+{
+public:
+
+    InitialI();
+
+    virtual void shutdown(const Ice::Current&);
+    virtual Ice::ObjectPtr pingPong(const Ice::ObjectPtr&, const Ice::Current&);
+
+    virtual void opOptionalException(const IceUtil::Optional< ::Ice::Int>&, 
+                                     const IceUtil::Optional< ::std::string>&,
+                                     const IceUtil::Optional<Test::OneOptionalPtr>&,
+                                     const Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Byte> opByte(const IceUtil::Optional< ::Ice::Byte>&, 
+                                                   IceUtil::Optional< ::Ice::Byte>&, 
+                                                   const ::Ice::Current&);
+    
+    virtual IceUtil::Optional< ::Ice::Long> opLong(const IceUtil::Optional< ::Ice::Long>&, 
+                                                   IceUtil::Optional< ::Ice::Long>&, 
+                                                   const ::Ice::Current&);
+
+    virtual IceUtil::Optional< ::std::string> opString(const IceUtil::Optional< ::std::string>&, 
+                                                       IceUtil::Optional< ::std::string>&, 
+                                                       const ::Ice::Current&);
+
+    virtual IceUtil::Optional<Test::OneOptionalPtr> opOneOptional(const IceUtil::Optional< Test::OneOptionalPtr>&, 
+                                                                  IceUtil::Optional< Test::OneOptionalPtr>&, 
+                                                                  const ::Ice::Current&);
+    
+    virtual IceUtil::Optional<Test::OneOptionalPrx> opOneOptionalProxy(const IceUtil::Optional< Test::OneOptionalPrx>&, 
+                                                                       IceUtil::Optional< Test::OneOptionalPrx>&, 
+                                                                       const ::Ice::Current&);
+    
+    virtual IceUtil::Optional< ::Test::ByteSeq> opByteSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >&, 
+        IceUtil::Optional< ::Test::ByteSeq>&, 
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::ShortSeq> opShortSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >&, 
+        IceUtil::Optional< ::Test::ShortSeq>&, 
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::BoolSeq> opBoolSeq(
+        const IceUtil::Optional< ::std::pair<const bool*, const bool*> >&, 
+        IceUtil::Optional< ::Test::BoolSeq>&, 
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::StringSeq> opStringSeq(
+        const IceUtil::Optional< ::std::pair< ::Test::StringSeq::const_iterator, 
+                                              ::Test::StringSeq::const_iterator> >&,
+        IceUtil::Optional< ::Test::StringSeq>&, 
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::FixedStructSeq> opFixedStructSeq(
+        const IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >&,
+        IceUtil::Optional< ::Test::FixedStructSeq>&, const ::Ice::Current& = ::Ice::Current());
+    
+    virtual IceUtil::Optional< ::Test::VarStructSeq> opVarStructSeq(
+        const IceUtil::Optional< ::std::pair< ::Test::VarStructSeq::const_iterator, 
+                                              ::Test::VarStructSeq::const_iterator> >&,
+        IceUtil::Optional< ::Test::VarStructSeq>&, 
+        const ::Ice::Current& = ::Ice::Current());
+};
+
+#endif
diff --git a/cpp/test/Ice/optional/run.py b/cpp/test/Ice/optional/run.py
new file mode 100755
index 00000000000..6ab39a07d80
--- /dev/null
+++ b/cpp/test/Ice/optional/run.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# **********************************************************************
+#
+# Copyright (c) 2003-2012 ZeroC, Inc. All rights reserved.
+#
+# This copy of Ice is licensed to you under the terms described in the
+# ICE_LICENSE file included in this distribution.
+#
+# **********************************************************************
+
+import os, sys
+
+path = [ ".", "..", "../..", "../../..", "../../../.." ]
+head = os.path.dirname(sys.argv[0])
+if len(head) > 0:
+    path = [os.path.join(head, p) for p in path]
+path = [os.path.abspath(p) for p in path if os.path.exists(os.path.join(p, "scripts", "TestUtil.py")) ]
+if len(path) == 0:
+    raise RuntimeError("can't find toplevel directory!")
+sys.path.append(os.path.join(path[0], "scripts"))
+import TestUtil
+
+print("Running test with compact (default) format.")
+TestUtil.clientServerTest()
+print("Running test with sliced format.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.SlicedFormat", additionalServerOptions="--Ice.Default.SlicedFormat")
diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp
index a2434f6b0ff..ac6c9b08399 100755
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -22,14 +22,6 @@
 
 using namespace std;
 
-#if defined(_MSC_VER) && (_MSC_VER < 1300) // COMPILERBUG
-//
-// VC++ 6 compiler bugs doesn't allow using templates for the Stream API.
-//
-// see: http://support.microsoft.com/kb/240866
-//      http://support.microsoft.com/kb/241569
-//
-#else
 class TestObjectWriter : public Ice::ObjectWriter
 {
 public:
@@ -158,38 +150,18 @@ public:
     {
     }
 };
-#endif
 
 int
 run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
 {
-#if defined(_MSC_VER) && (_MSC_VER < 1300)
-//
-// VC++ 6 compiler bugs doesn't allow to write
-// the Stream API using c++ templates.
-//
-// see: http://support.microsoft.com/kb/240866
-//      http://support.microsoft.com/kb/241569
-//
-#else
     MyClassFactoryWrapperPtr factoryWrapper = new MyClassFactoryWrapper;
     communicator->addObjectFactory(factoryWrapper, Test::MyClass::ice_staticId());
     communicator->addObjectFactory(new MyInterfaceFactory, Test::MyInterface::ice_staticId());
-#endif
 	
     Ice::InputStreamPtr in;
     Ice::OutputStreamPtr out;
     vector<Ice::Byte> data;
 
-#if defined(_MSC_VER) && (_MSC_VER < 1300)
-//
-// VC++ 6 compiler bugs doesn't allow to write
-// the Stream API using c++ templates.
-//
-// see: http://support.microsoft.com/kb/240866
-//      http://support.microsoft.com/kb/241569
-//
-#else
     //
     // Test the new stream api.
     //
@@ -1086,435 +1058,6 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
     }
 
     cout << "ok" << endl;
-
-#endif
-
-    //
-    // Test the old stream api.
-    //
-
-    cout << "testing primitive types... " << flush;
-
-    {
-        vector<Ice::Byte> byte;
-        in = Ice::createInputStream(communicator, byte);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->startEncapsulation();
-        out->writeBool(true);
-        out->endEncapsulation();
-        out->finished(data);
-        out = 0;
-
-        in = Ice::createInputStream(communicator, data);
-        in->startEncapsulation();
-        test(in->readBool());
-        in->endEncapsulation();
-    }
-
-    {
-        vector<Ice::Byte> byte;
-        in = Ice::createInputStream(communicator, byte);
-        try
-        {
-            in->readBool();
-            test(false);
-        }
-        catch(const Ice::UnmarshalOutOfBoundsException&)
-        {
-        }
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeBool(true);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readBool());
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeByte(1);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readByte() == 1);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeShort(2);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readShort() == 2);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeInt(3);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readInt() == 3);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeLong(4);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readLong() == 4);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeFloat(5.0);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readFloat() == 5.0);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeDouble(6.0);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readDouble() == 6.0);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        out->writeString("hello world");
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        test(in->readString() == "hello world");
-    }
-
-    cout << "ok" << endl;
-#if defined(_MSC_VER) && (_MSC_VER < 1300)
-//
-// VC++ 6 compiler bugs doesn't allow to write
-// the Stream API using c++ templates.
-//
-// see: http://support.microsoft.com/kb/240866
-//      http://support.microsoft.com/kb/241569
-//
-#else
-    cout << "testing constructed types... " << flush;
-
-    {
-        out = Ice::createOutputStream(communicator);
-        Test::ice_writeMyEnum(out, Test::enum3);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyEnum e;
-        Test::ice_readMyEnum(in, e);
-        test(e == Test::enum3);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        Test::SmallStruct s;
-        s.bo = true;
-        s.by = 1;
-        s.sh = 2;
-        s.i = 3;
-        s.l = 4;
-        s.f = 5.0;
-        s.d = 6.0;
-        s.str = "7";
-        s.e = Test::enum2;
-        s.p = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy("test:default"));
-        Test::ice_writeSmallStruct(out, s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::SmallStruct s2;
-        Test::ice_readSmallStruct(in, s2);
-        test(s2 == s);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        Test::ClassStructPtr s = new Test::ClassStruct();
-        s->i = 10;
-        Test::ice_writeClassStruct(out, s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::ClassStructPtr s2 = new Test::ClassStruct();
-        Test::ice_readClassStruct(in, s2);
-        test(s2->i == s->i);
-    }
-#endif
-    {
-        Ice::BoolSeq arr;
-        arr.push_back(true);
-        arr.push_back(false);
-        arr.push_back(true);
-        arr.push_back(false);
-
-        out = Ice::createOutputStream(communicator);
-        out->writeBoolSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::BoolSeq arr2 = in->readBoolSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::ByteSeq arr;
-        arr.push_back(0x01);
-        arr.push_back(0x11);
-        arr.push_back(0x12);
-        arr.push_back(0x22);
-
-        out = Ice::createOutputStream(communicator);
-        out->writeByteSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::ByteSeq arr2 = in->readByteSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::ShortSeq arr;
-        arr.push_back(0x01);
-        arr.push_back(0x11);
-        arr.push_back(0x12);
-        arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->writeShortSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::ShortSeq arr2 = in->readShortSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::IntSeq arr;
-        arr.push_back(0x01);
-        arr.push_back(0x11);
-        arr.push_back(0x12);
-        arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->writeIntSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::IntSeq arr2 = in->readIntSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::LongSeq arr;
-        arr.push_back(0x01);
-        arr.push_back(0x11);
-        arr.push_back(0x12);
-        arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->writeLongSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::LongSeq arr2 = in->readLongSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::FloatSeq arr;
-        arr.push_back(1);
-        arr.push_back(2);
-        arr.push_back(3);
-        arr.push_back(4);
-        out = Ice::createOutputStream(communicator);
-        out->writeFloatSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::FloatSeq arr2 = in->readFloatSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::DoubleSeq arr;
-        arr.push_back(1);
-        arr.push_back(2);
-        arr.push_back(3);
-        arr.push_back(4);
-        out = Ice::createOutputStream(communicator);
-        out->writeDoubleSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::DoubleSeq arr2 = in->readDoubleSeq();
-        test(arr2 == arr);
-    }
-
-    {
-        Ice::StringSeq arr;
-        arr.push_back("string1");
-        arr.push_back("string2");
-        arr.push_back("string3");
-        arr.push_back("string4");
-        out = Ice::createOutputStream(communicator);
-        out->writeStringSeq(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Ice::StringSeq arr2 = in->readStringSeq();
-        test(arr2 == arr);
-    }
-#if defined(_MSC_VER) && (_MSC_VER < 1300)
-//
-// VC++ 6 compiler bugs doesn't allow to write
-// the Stream API using c++ templates.
-//
-// see: http://support.microsoft.com/kb/240866
-//      http://support.microsoft.com/kb/241569
-//
-#else
-    {
-        Test::MyEnumS arr;
-        arr.push_back(Test::enum3);
-        arr.push_back(Test::enum2);
-        arr.push_back(Test::enum1);
-        arr.push_back(Test::enum2);
-
-        out = Ice::createOutputStream(communicator);
-        Test::ice_writeMyEnumS(out, arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyEnumS arr2;
-        Test::ice_readMyEnumS(in, arr2);
-        test(arr2 == arr);
-    }
-
-    {
-        Test::MyClassS arr;
-        for(int i = 0; i < 4; ++i)
-        {
-            Test::MyClassPtr c = new Test::MyClass;
-            c->c = c;
-            c->o = c;
-            c->s.e = Test::enum2;
-
-            c->seq1.push_back(true);
-            c->seq1.push_back(false);
-            c->seq1.push_back(true);
-            c->seq1.push_back(false);
-
-            c->seq2.push_back(1);
-            c->seq2.push_back(2);
-            c->seq2.push_back(3);
-            c->seq2.push_back(4);
-
-            c->seq3.push_back(1);
-            c->seq3.push_back(2);
-            c->seq3.push_back(3);
-            c->seq3.push_back(4);
-
-            c->seq4.push_back(1);
-            c->seq4.push_back(2);
-            c->seq4.push_back(3);
-            c->seq4.push_back(4);
-
-            c->seq5.push_back(1);
-            c->seq5.push_back(2);
-            c->seq5.push_back(3);
-            c->seq5.push_back(4);
-
-            c->seq6.push_back(1);
-            c->seq6.push_back(2);
-            c->seq6.push_back(3);
-            c->seq6.push_back(4);
-
-            c->seq7.push_back(1);
-            c->seq7.push_back(2);
-            c->seq7.push_back(3);
-            c->seq7.push_back(4);
-
-            c->seq8.push_back("string1");
-            c->seq8.push_back("string2");
-            c->seq8.push_back("string3");
-            c->seq8.push_back("string4");
-
-            c->seq9.push_back(Test::enum3);
-            c->seq9.push_back(Test::enum2);
-            c->seq9.push_back(Test::enum1);
-
-            c->d["hi"] = c;
-        }
-        out = Ice::createOutputStream(communicator);
-        Test::ice_writeMyClassS(out, arr);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyClassS arr2;
-        Test::ice_readMyClassS(in, arr2);
-        in->readPendingObjects();
-        test(arr2.size() == arr.size());
-        for(Test::MyClassS::size_type j = 0; j < arr2.size(); ++j)
-        {
-            test(arr2[j]);
-            test(arr2[j]->c == arr2[j]);
-            test(arr2[j]->o == arr2[j]);
-            test(arr2[j]->s.e == Test::enum2);
-            test(arr2[j]->seq1 == arr[j]->seq1);
-            test(arr2[j]->seq2 == arr[j]->seq2);
-            test(arr2[j]->seq3 == arr[j]->seq3);
-            test(arr2[j]->seq4 == arr[j]->seq4);
-            test(arr2[j]->seq5 == arr[j]->seq5);
-            test(arr2[j]->seq6 == arr[j]->seq6);
-            test(arr2[j]->seq7 == arr[j]->seq7);
-            test(arr2[j]->seq8 == arr[j]->seq8);
-            test(arr2[j]->seq9 == arr[j]->seq9);
-            test(arr2[j]->d["hi"] == arr2[j]);
-        }
-    }
-
-    {
-        Test::MyInterfacePtr i = new Test::MyInterface();
-        out = Ice::createOutputStream(communicator);
-        Test::ice_writeMyInterface(out, i);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        i = 0;
-        Test::ice_readMyInterface(in, i);
-        in->readPendingObjects();
-        test(i);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        Test::MyClassPtr obj = new Test::MyClass;
-        obj->s.e = Test::enum2;
-        TestObjectWriterPtr writer = new TestObjectWriter(obj);
-        out->writeObject(writer);
-        out->writePendingObjects();
-        out->finished(data);
-        test(writer->called);
-    }
-
-    {
-        out = Ice::createOutputStream(communicator);
-        Test::MyClassPtr obj = new Test::MyClass;
-        obj->s.e = Test::enum2;
-        TestObjectWriterPtr writer = new TestObjectWriter(obj);
-        out->writeObject(writer);
-        out->writePendingObjects();
-        out->finished(data);
-        test(writer->called);
-        factoryWrapper->setFactory(new TestObjectFactory);
-        in = Ice::createInputStream(communicator, data);
-        TestReadObjectCallbackPtr cb = new TestReadObjectCallback;
-        in->readObject(cb);
-        in->readPendingObjects();
-        test(cb->obj);
-        TestObjectReaderPtr reader = TestObjectReaderPtr::dynamicCast(cb->obj);
-        test(reader);
-        test(reader->called);
-        test(reader->obj);
-        test(reader->obj->s.e == Test::enum2);
-        factoryWrapper->setFactory(0);
-    }
-    cout << "ok" << endl;
-#endif
     return 0;
 }
 
diff --git a/cpp/test/Slice/errorDetection/OptionalMembers.err b/cpp/test/Slice/errorDetection/OptionalMembers.err
index d75ab25a5ec..d47fbaa24a7 100644
--- a/cpp/test/Slice/errorDetection/OptionalMembers.err
+++ b/cpp/test/Slice/errorDetection/OptionalMembers.err
@@ -1,13 +1,13 @@
-OptionalMembers.ice:23: missing tag for optional member `m1'
-OptionalMembers.ice:24: missing tag for optional member `m2'
+OptionalMembers.ice:23: missing tag for optional
+OptionalMembers.ice:24: missing tag for optional
 OptionalMembers.ice:25: `abc' is not defined
-OptionalMembers.ice:26: tag for optional member `m4' is out of range
-OptionalMembers.ice:27: tag for optional member `m5' is out of range
-OptionalMembers.ice:28: tag for optional member `m6' is out of range
+OptionalMembers.ice:26: tag for optional is out of range
+OptionalMembers.ice:27: tag for optional is out of range
+OptionalMembers.ice:28: tag for optional is out of range
 OptionalMembers.ice:30: tag for optional data member `m8' is already in use
-OptionalMembers.ice:31: tag for optional member `m9' is out of range
-OptionalMembers.ice:31: invalid tag `C3' for optional member `m9'
-OptionalMembers.ice:32: tag for optional member `m10' is out of range
-OptionalMembers.ice:32: invalid tag `C4' for optional member `m10'
-OptionalMembers.ice:33: invalid tag `C5' for optional member `m11'
+OptionalMembers.ice:31: tag for optional is out of range
+OptionalMembers.ice:31: invalid tag `C3' for optional
+OptionalMembers.ice:32: tag for optional is out of range
+OptionalMembers.ice:32: invalid tag `C4' for optional
+OptionalMembers.ice:33: invalid tag `C5' for optional
 OptionalMembers.ice:34: tag for optional data member `m12' is already in use