PHP port; misc. fixes

42 files changed, 1804 insertions, 413 deletions

diff --git a/cpp/src/Slice/RubyUtil.cpp b/cpp/src/Slice/RubyUtil.cpp
index c9a3bae5820..d5f8f771a13 100755
--- a/cpp/src/Slice/RubyUtil.cpp
+++ b/cpp/src/Slice/RubyUtil.cpp
@@ -912,7 +912,9 @@ Slice::Ruby::CodeVisitor::visitExceptionStart(const ExceptionPtr& p)
     //
     // Emit the type information.
     //
-    _out << sp << nl << "T_" << name << " = ::Ice::__defineException('" << scoped << "', " << name << ", ";
+    const bool preserved = p->hasMetaData("preserve-slice") || p->inheritsMetaData("preserve-slice");
+    _out << sp << nl << "T_" << name << " = ::Ice::__defineException('" << scoped << "', " << name << ", "
+         << (preserved ? "true" : "false") << ", ";
     if(!base)
     {
         _out << "nil";
diff --git a/cpp/src/slice2php/Main.cpp b/cpp/src/slice2php/Main.cpp
index 7a3209ad287..a30a16eca2d 100644
--- a/cpp/src/slice2php/Main.cpp
+++ b/cpp/src/slice2php/Main.cpp
@@ -388,8 +388,9 @@ CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
     //
     // Emit the type information.
     //
+    const bool preserved = p->hasMetaData("preserve-slice") || p->inheritsMetaData("preserve-slice");
     _out << sp << nl << type << " = IcePHP_defineClass('" << scoped << "', '" << escapeName(abs) << "', "
-         << (isAbstract ? "true" : "false") << ", ";
+         << (isAbstract ? "true" : "false") << ", " << (preserved ? "true" : "false") << ", ";
     if(!base)
     {
         _out << "$Ice__t_Object";
@@ -459,7 +460,7 @@ CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
         //
         // Define each operation. The arguments to IcePHP_defineOperation are:
         //
-        // $ClassType, 'opName', Mode, SendMode, (InParams), (OutParams), ReturnType, (Exceptions)
+        // $ClassType, 'opName', Mode, SendMode, FormatType, (InParams), (OutParams), ReturnType, (Exceptions)
         //
         // where InParams and OutParams are arrays of type descriptions, and Exceptions
         // is an array of exception type ids.
@@ -475,7 +476,7 @@ CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
 
                 _out << nl << "IcePHP_defineOperation(" << type << ", '" << (*oli)->name() << "', "
                      << getOperationMode((*oli)->mode(), _ns) << ", " << getOperationMode((*oli)->sendMode(), _ns)
-                     << ", ";
+                     << ", " << static_cast<int>((*oli)->format()) << ", ";
                 for(t = params.begin(), count = 0; t != params.end(); ++t)
                 {
                     if(!(*t)->isOutParam())
@@ -671,7 +672,9 @@ CodeVisitor::visitExceptionStart(const ExceptionPtr& p)
     //
     // Emit the type information.
     //
-    _out << sp << nl << type << " = IcePHP_defineException('" << scoped << "', '" << escapeName(abs) << "', ";
+    const bool preserved = p->hasMetaData("preserve-slice") || p->inheritsMetaData("preserve-slice");
+    _out << sp << nl << type << " = IcePHP_defineException('" << scoped << "', '" << escapeName(abs) << "', "
+         << (preserved ? "true" : "false") << ", ";
     if(!base)
     {
         _out << "null";
diff --git a/php/lib/Ice.php b/php/lib/Ice.php
index 4171c91f6f9..c146f96a503 100644
--- a/php/lib/Ice.php
+++ b/php/lib/Ice.php
@@ -87,9 +87,9 @@ abstract class Ice_ObjectImpl implements Ice_Object
     }
 }
 
-$Ice__t_Object = IcePHP_defineClass('::Ice::Object', "Ice_Object", true, null, null, null);
+$Ice__t_Object = IcePHP_defineClass('::Ice::Object', "Ice_Object", true, false, null, null, null);
 $Ice__t_ObjectSeq = IcePHP_defineSequence('::Ice::ObjectSeq', $Ice__t_Object);
-$Ice__t_LocalObject = IcePHP_defineClass('::Ice::LocalObject', "Ice_LocalObject", true, null, null, null);
+$Ice__t_LocalObject = IcePHP_defineClass('::Ice::LocalObject', "Ice_LocalObject", true, false, null, null, null);
 $Ice__t_ObjectPrx = IcePHP_defineProxy($Ice__t_Object);
 $Ice__t_ObjectProxySeq = IcePHP_defineSequence('::Ice::ObjectProxySeq', $Ice__t_ObjectPrx);
 
@@ -111,6 +111,25 @@ class Ice_InitializationData
     public $logger;
 }
 
+class Ice_SlicedData
+{
+    public $slices;
+}
+
+class Ice_SliceInfo
+{
+    public $typeId;
+    public $bytes;
+    public $objects;
+}
+
+class Ice_FormatType
+{
+    const DefaultFormat = 0;
+    const CompactFormat = 1;
+    const SlicedFormat = 2;
+}
+
 $Ice_sliceChecksums = array();
 
 //
@@ -124,11 +143,16 @@ require_once 'Ice/Locator.php';
 require_once 'Ice/ObjectFactory.php';
 require_once 'Ice/Process.php';
 require_once 'Ice/Router.php';
+require_once 'Ice/Version.php';
+
+$Ice_Protocol_1_0 = new Ice_ProtocolVersion(1, 0);
+$Ice_Encoding_1_0 = new Ice_EncodingVersion(1, 0);
+$Ice_Encoding_1_1 = new Ice_EncodingVersion(1, 1);
 
-IcePHP_defineOperation($Ice__t_Object, 'ice_isA', 2, 1, array($IcePHP__t_string), null, $IcePHP__t_bool, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_ping', 2, 1, null, null, null, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_id', 2, 1, null, null, $IcePHP__t_string, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_ids', 2, 1, null, null, $Ice__t_StringSeq, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_isA', 2, 1, 0, array($IcePHP__t_string), null, $IcePHP__t_bool, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_ping', 2, 1, 0, null, null, null, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_id', 2, 1, 0, null, null, $IcePHP__t_string, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_ids', 2, 1, 0, null, null, $Ice__t_StringSeq, null);
 
 //
 // Proxy comparison functions.
diff --git a/php/lib/Ice_ns.php b/php/lib/Ice_ns.php
index b3bfd9f2384..f1229986f9d 100644
--- a/php/lib/Ice_ns.php
+++ b/php/lib/Ice_ns.php
@@ -92,9 +92,9 @@ namespace Ice
         }
     }
 
-    $Ice__t_Object = IcePHP_defineClass('::Ice::Object', "\\Ice\\Object", true, null, null, null);
+    $Ice__t_Object = IcePHP_defineClass('::Ice::Object', "\\Ice\\Object", true, false, null, null, null);
     $Ice__t_ObjectSeq = IcePHP_defineSequence('::Ice::ObjectSeq', $Ice__t_Object);
-    $Ice__t_LocalObject = IcePHP_defineClass('::Ice::LocalObject', "\\Ice\\LocalObject", true, null, null, null);
+    $Ice__t_LocalObject = IcePHP_defineClass('::Ice::LocalObject', "\\Ice\\LocalObject", true, false, null, null, null);
     $Ice__t_ObjectPrx = IcePHP_defineProxy($Ice__t_Object);
     $Ice__t_ObjectProxySeq = IcePHP_defineSequence('::Ice::ObjectProxySeq', $Ice__t_ObjectPrx);
 
@@ -116,6 +116,25 @@ namespace Ice
         public $logger;
     }
 
+    class SlicedData
+    {
+        public $slices;
+    }
+
+    class SliceInfo
+    {
+        public $typeId;
+        public $bytes;
+        public $objects;
+    }
+
+    class FormatType
+    {
+        const DefaultFormat = 0;
+        const CompactFormat = 1;
+        const SlicedFormat = 2;
+    }
+
     $Ice_sliceChecksums = array();
 }
 
@@ -132,15 +151,24 @@ require_once 'Ice/Locator.php';
 require_once 'Ice/ObjectFactory.php';
 require_once 'Ice/Process.php';
 require_once 'Ice/Router.php';
+require_once 'Ice/Version.php';
 
-IcePHP_defineOperation($Ice__t_Object, 'ice_isA', 2, 1, array($IcePHP__t_string), array(), $IcePHP__t_bool, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_ping', 2, 1, null, null, null, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_id', 2, 1, null, null, $IcePHP__t_string, null);
-IcePHP_defineOperation($Ice__t_Object, 'ice_ids', 2, 1, null, null, $Ice__t_StringSeq, null);
+$Ice_Protocol_1_0 = new Ice\ProtocolVersion(1, 0);
+$Ice_Encoding_1_0 = new Ice\EncodingVersion(1, 0);
+$Ice_Encoding_1_1 = new Ice\EncodingVersion(1, 1);
+
+IcePHP_defineOperation($Ice__t_Object, 'ice_isA', 2, 1, 0, array($IcePHP__t_string), array(), $IcePHP__t_bool, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_ping', 2, 1, 0, null, null, null, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_id', 2, 1, 0, null, null, $IcePHP__t_string, null);
+IcePHP_defineOperation($Ice__t_Object, 'ice_ids', 2, 1, 0, null, null, $Ice__t_StringSeq, null);
 }
 
 namespace Ice
 {
+    $Protocol_1_0 = new ProtocolVersion(1, 0);
+    $Encoding_1_0 = new EncodingVersion(1, 0);
+    $Encoding_1_1 = new EncodingVersion(1, 1);
+
     //
     // Proxy comparison functions.
     //
diff --git a/php/lib/Makefile b/php/lib/Makefile
index 076c6e98589..ac86bb0f68e 100644
--- a/php/lib/Makefile
+++ b/php/lib/Makefile
@@ -45,7 +45,8 @@ ICE_SRCS	= Ice/LocalException.php \
 		  Ice/SliceChecksumDict.php \
 		  Ice/Endpoint.php \
 		  Ice/EndpointF.php \
-		  Ice/EndpointTypes.php
+		  Ice/EndpointTypes.php \
+		  Ice/Version.php
 
 #
 # IMPORTANT: If you add or remove Slice files, you also need to check Glacier2.php!
diff --git a/php/lib/Makefile.mak b/php/lib/Makefile.mak
index c5a81e40d6f..2b5e267e684 100644
--- a/php/lib/Makefile.mak
+++ b/php/lib/Makefile.mak
@@ -45,7 +45,8 @@ ICE_SRCS	= Ice\LocalException.php \
 		  Ice\SliceChecksumDict.php \

 		  Ice\Endpoint.php \

 		  Ice\EndpointF.php \

-		  Ice\EndpointTypes.php

+		  Ice\EndpointTypes.php \

+		  Ice\Version.php

 

 #

 # IMPORTANT: If you add or remove Slice files, you also need to check Glacier2.php!

diff --git a/php/src/IcePHP/Endpoint.cpp b/php/src/IcePHP/Endpoint.cpp
index 85449b00ec6..a0f3829c010 100644
--- a/php/src/IcePHP/Endpoint.cpp
+++ b/php/src/IcePHP/Endpoint.cpp
@@ -286,6 +286,10 @@ IcePHP::endpointInit(TSRMLS_D)
     ce.create_object = handleEndpointInfoAlloc;
     endpointInfoClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
     memcpy(&_endpointInfoHandlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+    zend_declare_property_null(endpointInfoClassEntry, STRCAST("protocol"), sizeof("protocol") - 1,
+                               ZEND_ACC_PUBLIC TSRMLS_CC);
+    zend_declare_property_null(endpointInfoClassEntry, STRCAST("encoding"), sizeof("encoding") - 1,
+                               ZEND_ACC_PUBLIC TSRMLS_CC);
     zend_declare_property_long(endpointInfoClassEntry, STRCAST("timeout"), sizeof("timeout") - 1, 0,
                                ZEND_ACC_PUBLIC TSRMLS_CC);
     zend_declare_property_bool(endpointInfoClassEntry, STRCAST("compress"), sizeof("compress") - 1, 0,
@@ -327,14 +331,6 @@ IcePHP::endpointInit(TSRMLS_D)
 #endif
     ce.create_object = handleEndpointInfoAlloc;
     udpEndpointInfoClassEntry = zend_register_internal_class_ex(&ce, ipEndpointInfoClassEntry, NULL TSRMLS_CC);
-    zend_declare_property_long(udpEndpointInfoClassEntry, STRCAST("protocolMajor"), sizeof("protocolMajor") - 1, 0,
-                               ZEND_ACC_PUBLIC TSRMLS_CC);
-    zend_declare_property_long(udpEndpointInfoClassEntry, STRCAST("protocolMinor"), sizeof("protocolMinor") - 1, 0,
-                               ZEND_ACC_PUBLIC TSRMLS_CC);
-    zend_declare_property_long(udpEndpointInfoClassEntry, STRCAST("encodingMajor"), sizeof("encodingMajor") - 1, 0,
-                               ZEND_ACC_PUBLIC TSRMLS_CC);
-    zend_declare_property_long(udpEndpointInfoClassEntry, STRCAST("encodingMinor"), sizeof("encodingMinor") - 1, 0,
-                               ZEND_ACC_PUBLIC TSRMLS_CC);
     zend_declare_property_string(udpEndpointInfoClassEntry, STRCAST("mcastInterface"), sizeof("mcastInterface") - 1,
                                  STRCAST(""), ZEND_ACC_PUBLIC TSRMLS_CC);
     zend_declare_property_long(udpEndpointInfoClassEntry, STRCAST("mcastTtl"), sizeof("mcastTtl") - 1, 0,
@@ -350,6 +346,8 @@ IcePHP::endpointInit(TSRMLS_D)
 #endif
     ce.create_object = handleEndpointInfoAlloc;
     opaqueEndpointInfoClassEntry = zend_register_internal_class_ex(&ce, endpointInfoClassEntry, NULL TSRMLS_CC);
+    zend_declare_property_null(opaqueEndpointInfoClassEntry, STRCAST("rawEncoding"), sizeof("rawEncoding") - 1,
+                               ZEND_ACC_PUBLIC TSRMLS_CC);
     zend_declare_property_null(opaqueEndpointInfoClassEntry, STRCAST("rawBytes"), sizeof("rawBytes") - 1,
                                ZEND_ACC_PUBLIC TSRMLS_CC);
 
@@ -410,10 +408,6 @@ IcePHP::createEndpointInfo(zval* zv, const Ice::EndpointInfoPtr& p TSRMLS_DC)
         Ice::UDPEndpointInfoPtr info = Ice::UDPEndpointInfoPtr::dynamicCast(p);
         if((status = object_init_ex(zv, udpEndpointInfoClassEntry)) == SUCCESS)
         {
-            add_property_long(zv, STRCAST("protocolMajor"), static_cast<long>(info->protocolMajor));
-            add_property_long(zv, STRCAST("protocolMinor"), static_cast<long>(info->protocolMinor));
-            add_property_long(zv, STRCAST("encodingMajor"), static_cast<long>(info->encodingMajor));
-            add_property_long(zv, STRCAST("encodingMinor"), static_cast<long>(info->encodingMinor));
             add_property_string(zv, STRCAST("mcastInterface"), const_cast<char*>(info->mcastInterface.c_str()), 1);
             add_property_long(zv, STRCAST("mcastTtl"), static_cast<long>(info->mcastTtl));
         }
@@ -423,6 +417,12 @@ IcePHP::createEndpointInfo(zval* zv, const Ice::EndpointInfoPtr& p TSRMLS_DC)
         Ice::OpaqueEndpointInfoPtr info = Ice::OpaqueEndpointInfoPtr::dynamicCast(p);
         if((status = object_init_ex(zv, opaqueEndpointInfoClassEntry)) == SUCCESS)
         {
+            zval* rawEncoding;
+            MAKE_STD_ZVAL(rawEncoding);
+            createEncodingVersion(rawEncoding, info->rawEncoding TSRMLS_CC);
+            add_property_zval(zv, STRCAST("rawEncoding"), rawEncoding);
+            zval_ptr_dtor(&rawEncoding); // add_property_zval increased the refcount of rawEncoding
+
             zval* rawBytes;
             MAKE_STD_ZVAL(rawBytes);
             array_init(rawBytes);
@@ -456,6 +456,18 @@ IcePHP::createEndpointInfo(zval* zv, const Ice::EndpointInfoPtr& p TSRMLS_DC)
         add_property_long(zv, STRCAST("port"), static_cast<long>(info->port));
     }
 
+    zval* protocol;
+    MAKE_STD_ZVAL(protocol);
+    createProtocolVersion(protocol, p->protocol TSRMLS_CC);
+    add_property_zval(zv, STRCAST("protocol"), protocol);
+    zval_ptr_dtor(&protocol); // add_property_zval increased the refcount of protocol
+
+    zval* encoding;
+    MAKE_STD_ZVAL(encoding);
+    createEncodingVersion(encoding, p->encoding TSRMLS_CC);
+    add_property_zval(zv, STRCAST("encoding"), encoding);
+    zval_ptr_dtor(&encoding); // add_property_zval increased the refcount of encoding
+
     add_property_long(zv, STRCAST("timeout"), static_cast<long>(p->timeout));
     add_property_bool(zv, STRCAST("compress"), static_cast<long>(p->compress));
 
diff --git a/php/src/IcePHP/Init.cpp b/php/src/IcePHP/Init.cpp
index 9da2f13db9a..5f2f3f7d3a0 100644
--- a/php/src/IcePHP/Init.cpp
+++ b/php/src/IcePHP/Init.cpp
@@ -74,13 +74,27 @@ ZEND_END_ARG_INFO()
 #define ICEPHP_UTIL_FUNCTIONS \
     ZEND_FE(Ice_stringVersion, NULL) \
     ZEND_FE(Ice_intVersion, NULL) \
-    ZEND_FE(Ice_generateUUID, NULL)
+    ZEND_FE(Ice_generateUUID, NULL) \
+    ZEND_FE(Ice_currentProtocol, NULL) \
+    ZEND_FE(Ice_currentProtocolEncoding, NULL) \
+    ZEND_FE(Ice_currentEncoding, NULL) \
+    ZEND_FE(Ice_protocolVersionToString, NULL) \
+    ZEND_FE(Ice_stringToProtocolVersion, NULL) \
+    ZEND_FE(Ice_encodingVersionToString, NULL) \
+    ZEND_FE(Ice_stringToEncodingVersion, NULL)
 
 #ifdef ICEPHP_USE_NAMESPACES
 #   define ICEPHP_UTIL_NS_FUNCTIONS \
     ZEND_NS_FALIAS("Ice", stringVersion, Ice_stringVersion, NULL) \
     ZEND_NS_FALIAS("Ice", intVersion, Ice_intVersion, NULL) \
-    ZEND_NS_FALIAS("Ice", generateUUID, Ice_generateUUID, NULL)
+    ZEND_NS_FALIAS("Ice", generateUUID, Ice_generateUUID, NULL) \
+    ZEND_NS_FALIAS("Ice", currentProtocol, Ice_currentProtocol, NULL) \
+    ZEND_NS_FALIAS("Ice", currentProtocolEncoding, Ice_currentProtocolEncoding, NULL) \
+    ZEND_NS_FALIAS("Ice", currentEncoding, Ice_currentEncoding, NULL) \
+    ZEND_NS_FALIAS("Ice", protocolVersionToString, Ice_protocolVersionToString, NULL) \
+    ZEND_NS_FALIAS("Ice", stringToProtocolVersion, Ice_stringToProtocolVersion, NULL) \
+    ZEND_NS_FALIAS("Ice", encodingVersionToString, Ice_encodingVersionToString, NULL) \
+    ZEND_NS_FALIAS("Ice", stringToEncodingVersion, Ice_stringToEncodingVersion, NULL)
 #else
 #   define ICEPHP_UTIL_NS_FUNCTIONS
 #endif
diff --git a/php/src/IcePHP/Operation.cpp b/php/src/IcePHP/Operation.cpp
index 5bdf6ddc20b..ff1ad8b7805 100644
--- a/php/src/IcePHP/Operation.cpp
+++ b/php/src/IcePHP/Operation.cpp
@@ -50,7 +50,8 @@ class OperationI : public Operation
 {
 public:
 
-    OperationI(const char*, Ice::OperationMode, Ice::OperationMode, zval*, zval*, zval*, zval* TSRMLS_DC);
+    OperationI(const char*, Ice::OperationMode, Ice::OperationMode, Ice::FormatType, zval*, zval*, zval*, zval*
+               TSRMLS_DC);
     ~OperationI();
 
     virtual zend_function* function();
@@ -58,6 +59,7 @@ public:
     string name; // On-the-wire name.
     Ice::OperationMode mode;
     Ice::OperationMode sendMode;
+    Ice::FormatType format;
     TypeInfoList inParams;
     TypeInfoList outParams;
     TypeInfoPtr returnType;
@@ -129,6 +131,35 @@ public:
     virtual void invoke(INTERNAL_FUNCTION_PARAMETERS);
 };
 
+class UserExceptionReaderFactoryI : public Ice::UserExceptionReaderFactory
+{
+public:
+
+    UserExceptionReaderFactoryI(const CommunicatorInfoPtr& communicator TSRMLS_DC) :
+        _communicator(communicator)
+    {
+#ifdef ZTS
+        this->TSRMLS_C = TSRMLS_C;
+#endif
+    }
+
+    virtual void createAndThrow(const string& id) const
+    {
+        ExceptionInfoPtr info = getExceptionInfo(id TSRMLS_CC);
+        if(info)
+        {
+            throw ExceptionReader(_communicator, info TSRMLS_CC);
+        }
+    }
+
+private:
+
+    const CommunicatorInfoPtr _communicator;
+#if ZTS
+    TSRMLS_D;
+#endif
+};
+
 }
 
 //
@@ -160,9 +191,9 @@ IcePHP::ResultCallback::unmarshaled(zval* val, zval*, void* TSRMLS_DC)
 //
 // OperationI implementation.
 //
-IcePHP::OperationI::OperationI(const char* n, Ice::OperationMode m, Ice::OperationMode sm, zval* in, zval* out,
-                               zval* ret, zval* ex TSRMLS_DC) :
-    name(n), mode(m), sendMode(sm), sendsClasses(false), returnsClasses(false), _zendFunction(0)
+IcePHP::OperationI::OperationI(const char* n, Ice::OperationMode m, Ice::OperationMode sm, Ice::FormatType f, zval* in,
+                               zval* out, zval* ret, zval* ex TSRMLS_DC) :
+    name(n), mode(m), sendMode(sm), format(f), sendsClasses(false), returnsClasses(false), _zendFunction(0)
 {
     //
     // inParams
@@ -361,6 +392,12 @@ IcePHP::TypedInvocation::prepareRequest(int argc, zval** args, Ice::ByteSeq& byt
             // Marshal the in parameters.
             //
             Ice::OutputStreamPtr os = Ice::createOutputStream(_communicator->getCommunicator());
+            os->startEncapsulation(_prx->ice_getEncodingVersion());
+
+            if(_op->sendsClasses && _op->format != Ice::DefaultFormat)
+            {
+                os->format(_op->format);
+            }
 
             ObjectMap objectMap;
             int i = 0;
@@ -380,6 +417,7 @@ IcePHP::TypedInvocation::prepareRequest(int argc, zval** args, Ice::ByteSeq& byt
                 os->writePendingObjects();
             }
 
+            os->endEncapsulation();
             os->finished(bytes);
         }
         catch(const AbortMarshaling&)
@@ -403,6 +441,16 @@ IcePHP::TypedInvocation::unmarshalResults(int argc, zval** args, zval* ret,
     Ice::InputStreamPtr is = Ice::createInputStream(_communicator->getCommunicator(), bytes);
 
     //
+    // Store a pointer to a local SlicedDataUtil object as the stream's closure.
+    // This is necessary to support object unmarshaling (see ObjectReader).
+    //
+    SlicedDataUtil util;
+    assert(!is->closure());
+    is->closure(&util);
+
+    is->startEncapsulation();
+
+    //
     // These callbacks collect references to the unmarshaled values. We copy them into
     // the argument list *after* any pending objects have been unmarshaled.
     //
@@ -433,6 +481,10 @@ IcePHP::TypedInvocation::unmarshalResults(int argc, zval** args, zval* ret,
         is->readPendingObjects();
     }
 
+    util.update(TSRMLS_C);
+
+    is->endEncapsulation();
+
     int i = static_cast<int>(_op->inParams.size());
     for(ResultCallbackList::iterator q = outParamCallbacks.begin(); q != outParamCallbacks.end(); ++q, ++i)
     {
@@ -458,71 +510,48 @@ IcePHP::TypedInvocation::unmarshalResults(int argc, zval** args, zval* ret,
 zval*
 IcePHP::TypedInvocation::unmarshalException(const pair<const Ice::Byte*, const Ice::Byte*>& bytes TSRMLS_DC)
 {
-    int traceSlicing = -1;
-
     Ice::InputStreamPtr is = Ice::createInputStream(_communicator->getCommunicator(), bytes);
 
-    bool usesClasses;
-    is->read(usesClasses);
+    //
+    // Store a pointer to a local SlicedDataUtil object as the stream's closure.
+    // This is necessary to support object unmarshaling (see ObjectReader).
+    //
+    SlicedDataUtil util;
+    assert(!is->closure());
+    is->closure(&util);
 
-    string id;
-    is->read(id);
-    const string origId = id;
+    is->startEncapsulation();
 
-    while(!id.empty())
+    try
     {
-        ExceptionInfoPtr info = getExceptionInfo(id TSRMLS_CC);
-        if(info)
-        {
-            zval* ex = info->unmarshal(is, _communicator TSRMLS_CC);
-            if(ex)
-            {
-                if(info->usesClasses)
-                {
-                    is->readPendingObjects();
-                }
+        Ice::UserExceptionReaderFactoryPtr factory = new UserExceptionReaderFactoryI(_communicator TSRMLS_CC);
+        is->throwException(factory);
+    }
+    catch(const ExceptionReader& r)
+    {
+        is->endEncapsulation();
 
-                if(validateException(info TSRMLS_CC))
-                {
-                    return ex;
-                }
-                else
-                {
-                    zval_ptr_dtor(&ex);
-                    Ice::UnknownUserException uue(__FILE__, __LINE__,
-                                                  "operation raised undeclared exception `" + id + "'");
-                    return convertException(uue TSRMLS_CC);
-                }
-            }
-        }
-        else
+        zval* ex = r.getException();
+        ExceptionInfoPtr info = r.getInfo();
+
+        if(validateException(info TSRMLS_CC))
         {
-            if(traceSlicing == -1)
-            {
-                traceSlicing =
-                    _communicator->getCommunicator()->getProperties()->getPropertyAsInt("Ice.Trace.Slicing") > 0;
-            }
+            util.update(TSRMLS_C);
 
-            if(traceSlicing > 0)
+            Ice::SlicedDataPtr slicedData = r.getSlicedData();
+            if(slicedData)
             {
-                _communicator->getCommunicator()->getLogger()->trace("Slicing", "unknown exception type `" + id + "'");
+                SlicedDataUtil::setMember(ex, slicedData TSRMLS_CC);
             }
 
-            is->skipSlice(); // Slice off what we don't understand.
-
-            try
-            {
-                is->read(id); // Read type id for next slice.
-            }
-            catch(Ice::UnmarshalOutOfBoundsException& ex)
-            {
-                //
-                // When readString raises this exception it means we've seen the last slice,
-                // so we set the reason member to a more helpful message.
-                //
-                ex.reason = "unknown exception type `" + origId + "'";
-                return convertException(ex TSRMLS_CC);
-            }
+            return ex;
+        }
+        else
+        {
+            zval_ptr_dtor(&ex);
+            Ice::UnknownUserException uue(__FILE__, __LINE__,
+                                          "operation raised undeclared exception `" + info->id + "'");
+            return convertException(uue TSRMLS_CC);
         }
     }
 
@@ -532,7 +561,7 @@ IcePHP::TypedInvocation::unmarshalException(const pair<const Ice::Byte*, const I
     // have a factory for. This means that sender and receiver disagree
     // about the Slice definitions they use.
     //
-    Ice::UnknownUserException uue(__FILE__, __LINE__, "unknown exception type `" + origId + "'");
+    Ice::UnknownUserException uue(__FILE__, __LINE__, "unknown exception");
     return convertException(uue TSRMLS_CC);
 }
 
@@ -675,13 +704,14 @@ ZEND_FUNCTION(IcePHP_defineOperation)
     int nameLen;
     long mode;
     long sendMode;
+    long format;
     zval* inParams;
     zval* outParams;
     zval* returnType;
     zval* exceptions;
 
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("oslla!a!o!a!"), &cls, &name, &nameLen, &mode,
-                             &sendMode, &inParams, &outParams, &returnType, &exceptions) == FAILURE)
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("osllla!a!o!a!"), &cls, &name, &nameLen,
+                             &mode, &sendMode, &format, &inParams, &outParams, &returnType, &exceptions) == FAILURE)
     {
         return;
     }
@@ -691,8 +721,8 @@ ZEND_FUNCTION(IcePHP_defineOperation)
     assert(c);
 
     OperationIPtr op = new OperationI(name, static_cast<Ice::OperationMode>(mode),
-                                      static_cast<Ice::OperationMode>(sendMode), inParams, outParams, returnType,
-                                      exceptions TSRMLS_CC);
+                                      static_cast<Ice::OperationMode>(sendMode), static_cast<Ice::FormatType>(format),
+                                      inParams, outParams, returnType, exceptions TSRMLS_CC);
 
     c->addOperation(name, op);
 }
diff --git a/php/src/IcePHP/Proxy.cpp b/php/src/IcePHP/Proxy.cpp
index a8dfcd18c07..f8dcfc88ec2 100644
--- a/php/src/IcePHP/Proxy.cpp
+++ b/php/src/IcePHP/Proxy.cpp
@@ -645,6 +645,62 @@ ZEND_METHOD(Ice_ObjectPrx, ice_secure)
     }
 }
 
+ZEND_METHOD(Ice_ObjectPrx, ice_getEncodingVersion)
+{
+    if(ZEND_NUM_ARGS() != 0)
+    {
+        WRONG_PARAM_COUNT;
+    }
+
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
+
+    try
+    {
+        if(!createEncodingVersion(return_value, _this->proxy->ice_getEncodingVersion() TSRMLS_CC))
+        {
+            RETURN_NULL();
+        }
+    }
+    catch(const IceUtil::Exception& ex)
+    {
+        throwException(ex TSRMLS_CC);
+        RETURN_NULL();
+    }
+}
+
+ZEND_METHOD(Ice_ObjectPrx, ice_encodingVersion)
+{
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
+
+    zend_class_entry* cls = idToClass("::Ice::EncodingVersion" TSRMLS_CC);
+    assert(cls);
+
+    zval *zv;
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O"), &zv, cls) == FAILURE)
+    {
+        RETURN_NULL();
+    }
+
+    Ice::EncodingVersion v;
+    if(extractEncodingVersion(zv, v TSRMLS_CC))
+    {
+        try
+        {
+            if(!_this->clone(return_value, _this->proxy->ice_encodingVersion(v) TSRMLS_CC))
+            {
+                RETURN_NULL();
+            }
+        }
+        catch(const IceUtil::Exception& ex)
+        {
+            throwException(ex TSRMLS_CC);
+            RETURN_NULL();
+        }
+    }
+}
+
 ZEND_METHOD(Ice_ObjectPrx, ice_isPreferSecure)
 {
     if(ZEND_NUM_ARGS() != 0)
@@ -1213,6 +1269,27 @@ ZEND_METHOD(Ice_ObjectPrx, ice_getCachedConnection)
     }
 }
 
+ZEND_METHOD(Ice_ObjectPrx, ice_flushBatchRequests)
+{
+    if(ZEND_NUM_ARGS() != 0)
+    {
+        WRONG_PARAM_COUNT;
+    }
+
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
+
+    try
+    {
+        _this->proxy->ice_flushBatchRequests();
+    }
+    catch(const IceUtil::Exception& ex)
+    {
+        throwException(ex TSRMLS_CC);
+        RETURN_NULL();
+    }
+}
+
 static ClassInfoPtr
 lookupClass(const string& id TSRMLS_DC)
 {
@@ -1570,6 +1647,8 @@ static zend_function_entry _proxyMethods[] =
     ZEND_ME(Ice_ObjectPrx, ice_endpointSelection, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_isSecure, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_secure, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getEncodingVersion, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_encodingVersion, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_isPreferSecure, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_preferSecure, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_getRouter, NULL, ZEND_ACC_PUBLIC)
@@ -1591,6 +1670,7 @@ static zend_function_entry _proxyMethods[] =
     ZEND_ME(Ice_ObjectPrx, ice_connectionId, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_getConnection, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_getCachedConnection, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_flushBatchRequests, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_uncheckedCast, NULL, ZEND_ACC_PUBLIC)
     ZEND_ME(Ice_ObjectPrx, ice_checkedCast, NULL, ZEND_ACC_PUBLIC)
     {0, 0, 0}
diff --git a/php/src/IcePHP/Types.cpp b/php/src/IcePHP/Types.cpp
index 21f6030009f..b1d392fa3a0 100644
--- a/php/src/IcePHP/Types.cpp
+++ b/php/src/IcePHP/Types.cpp
@@ -14,6 +14,7 @@
 #include <IceUtil/OutputUtil.h>
 #include <IceUtil/ScopedArray.h>
 #include <Slice/PHPUtil.h>
+#include <Ice/SlicedData.h>
 
 using namespace std;
 using namespace IcePHP;
@@ -139,6 +140,39 @@ getMostDerived(zend_class_entry* formal, zend_class_entry* cls, const ClassInfoP
     return curr;
 }
 
+static ClassInfoPtr
+getClassInfoByClass(zend_class_entry* cls, zend_class_entry* formal TSRMLS_DC)
+{
+    //
+    // See if there's a match in our class name => ClassInfo map.
+    //
+    ClassInfoPtr info = getClassInfoByName(cls->name TSRMLS_CC);
+
+    //
+    // Check the base class, assuming it's compatible with our formal type (if any).
+    //
+    if(!info && cls->parent && (!formal || checkClass(cls->parent, formal)))
+    {
+        info = getClassInfoByClass(cls->parent, formal TSRMLS_CC);
+    }
+
+    //
+    // Check interfaces.
+    //
+    if(!info)
+    {
+        for(zend_uint i = 0; i < cls->num_interfaces && !info; ++i)
+        {
+            if(!formal || checkClass(cls->interfaces[i], formal))
+            {
+                info = getClassInfoByClass(cls->interfaces[i], formal TSRMLS_CC);
+            }
+        }
+    }
+
+    return info;
+}
+
 //
 // getClassInfoById()
 //
@@ -233,6 +267,263 @@ zend_object_handle _h;
 }
 
 //
+// SlicedDataUtil implementation
+//
+zend_class_entry* IcePHP::SlicedDataUtil::_slicedDataType = 0;
+zend_class_entry* IcePHP::SlicedDataUtil::_sliceInfoType = 0;
+
+IcePHP::SlicedDataUtil::~SlicedDataUtil()
+{
+    //
+    // Make sure we break any cycles among the objects in preserved slices.
+    //
+    for(set<ObjectReaderPtr>::iterator p = _readers.begin(); p != _readers.end(); ++p)
+    {
+        (*p)->getSlicedData()->clearObjects();
+    }
+}
+
+void
+IcePHP::SlicedDataUtil::add(const ObjectReaderPtr& reader)
+{
+    assert(reader->getSlicedData());
+    _readers.insert(reader);
+}
+
+void
+IcePHP::SlicedDataUtil::update(TSRMLS_D)
+{
+    for(set<ObjectReaderPtr>::iterator p = _readers.begin(); p != _readers.end(); ++p)
+    {
+        setMember((*p)->getObject(), (*p)->getSlicedData() TSRMLS_CC);
+    }
+}
+
+void
+IcePHP::SlicedDataUtil::setMember(zval* obj, const Ice::SlicedDataPtr& slicedData TSRMLS_DC)
+{
+    //
+    // Create a PHP equivalent of the SlicedData object.
+    //
+
+    assert(slicedData);
+
+    if(!_slicedDataType)
+    {
+        _slicedDataType = idToClass("::Ice::SlicedData" TSRMLS_CC);
+        assert(_slicedDataType);
+    }
+    if(!_sliceInfoType)
+    {
+        _sliceInfoType = idToClass("::Ice::SliceInfo" TSRMLS_CC);
+        assert(_sliceInfoType);
+    }
+
+    zval* sd;
+    MAKE_STD_ZVAL(sd);
+    AutoDestroy sdDestroyer(sd);
+
+    if(object_init_ex(sd, _slicedDataType) != SUCCESS)
+    {
+        throw AbortMarshaling();
+    }
+
+    zval* slices;
+    MAKE_STD_ZVAL(slices);
+    array_init(slices);
+    AutoDestroy slicesDestroyer(slices);
+
+    if(add_property_zval(sd, STRCAST("slices"), slices) != SUCCESS)
+    {
+        throw AbortMarshaling();
+    }
+
+    //
+    // Translate each SliceInfo object into its PHP equivalent.
+    //
+    for(vector<Ice::SliceInfoPtr>::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
+    {
+        zval* slice;
+        MAKE_STD_ZVAL(slice);
+        AutoDestroy sliceDestroyer(slice);
+
+        if(object_init_ex(slice, _sliceInfoType) != SUCCESS)
+        {
+            throw AbortMarshaling();
+        }
+
+        add_next_index_zval(slices, slice); // Steals a reference.
+        Z_ADDREF_P(slice);
+
+        //
+        // typeId
+        //
+        zval* typeId;
+        MAKE_STD_ZVAL(typeId);
+        AutoDestroy typeIdDestroyer(typeId);
+        ZVAL_STRINGL(typeId, STRCAST((*p)->typeId.c_str()), (*p)->typeId.size(), 1);
+        if(add_property_zval(slice, STRCAST("typeId"), typeId) != SUCCESS)
+        {
+            throw AbortMarshaling();
+        }
+
+        //
+        // bytes
+        //
+        zval* bytes;
+        MAKE_STD_ZVAL(bytes);
+        array_init(bytes);
+        AutoDestroy bytesDestroyer(bytes);
+        for(vector<Ice::Byte>::const_iterator q = (*p)->bytes.begin(); q != (*p)->bytes.end(); ++q)
+        {
+            add_next_index_long(bytes, *q & 0xff);
+        }
+        if(add_property_zval(slice, STRCAST("bytes"), bytes) != SUCCESS)
+        {
+            throw AbortMarshaling();
+        }
+
+        //
+        // objects
+        //
+        zval* objects;
+        MAKE_STD_ZVAL(objects);
+        array_init(objects);
+        AutoDestroy objectsDestroyer(objects);
+        if(add_property_zval(slice, STRCAST("objects"), objects) != SUCCESS)
+        {
+            throw AbortMarshaling();
+        }
+
+        for(vector<Ice::ObjectPtr>::const_iterator q = (*p)->objects.begin(); q != (*p)->objects.end(); ++q)
+        {
+            //
+            // Each element in the objects list is an instance of ObjectReader that wraps a PHP object.
+            //
+            assert(*q);
+            ObjectReaderPtr r = ObjectReaderPtr::dynamicCast(*q);
+            assert(r);
+            zval* o = r->getObject();
+            assert(Z_TYPE_P(o) == IS_OBJECT); // Should be non-nil.
+            add_next_index_zval(objects, o); // Steals a reference.
+            Z_ADDREF_P(o);
+        }
+    }
+
+    if(add_property_zval(obj, STRCAST("_ice_slicedData"), sd) != SUCCESS)
+    {
+        throw AbortMarshaling();
+    }
+}
+
+//
+// Instances of preserved class and exception types may have a data member
+// named _ice_slicedData which is an instance of the PHP class Ice_SlicedData.
+//
+Ice::SlicedDataPtr
+IcePHP::SlicedDataUtil::getMember(zval* obj, ObjectMap* objectMap TSRMLS_DC)
+{
+    Ice::SlicedDataPtr slicedData;
+
+    string name = "_ice_slicedData";
+    void* data;
+    if(zend_hash_find(Z_OBJPROP_P(obj), STRCAST(name.c_str()), name.size() + 1, &data) == SUCCESS)
+    {
+        zval* sd = *(reinterpret_cast<zval**>(data));
+
+        if(Z_TYPE_P(sd) != IS_NULL)
+        {
+            int status;
+
+            //
+            // The "slices" member is an array of Ice_SliceInfo objects.
+            //
+            status = zend_hash_find(Z_OBJPROP_P(sd), STRCAST("slices"), sizeof("slices"), &data);
+            assert(status == SUCCESS);
+            zval* sl = *(reinterpret_cast<zval**>(data));
+            assert(Z_TYPE_P(sl) == IS_ARRAY);
+
+            Ice::SliceInfoSeq slices;
+
+            HashTable* arr = Z_ARRVAL_P(sl);
+            assert(arr);
+            HashPosition pos;
+            zend_hash_internal_pointer_reset_ex(arr, &pos);
+
+            while(zend_hash_get_current_data_ex(arr, &data, &pos) != FAILURE)
+            {
+                zval* s = *(reinterpret_cast<zval**>(data));
+                assert(Z_OBJCE_P(s) == _sliceInfoType);
+
+                Ice::SliceInfoPtr info = new Ice::SliceInfo;
+
+                status = zend_hash_find(Z_OBJPROP_P(s), STRCAST("typeId"), sizeof("typeId"), &data);
+                assert(status == SUCCESS);
+                zval* typeId = *(reinterpret_cast<zval**>(data));
+                assert(Z_TYPE_P(typeId) == IS_STRING);
+                info->typeId = string(Z_STRVAL_P(typeId), Z_STRLEN_P(typeId));
+
+                status = zend_hash_find(Z_OBJPROP_P(s), STRCAST("bytes"), sizeof("bytes"), &data);
+                assert(status == SUCCESS);
+                zval* bytes = *(reinterpret_cast<zval**>(data));
+                assert(Z_TYPE_P(bytes) == IS_ARRAY);
+                HashTable* barr = Z_ARRVAL_P(bytes);
+                HashPosition bpos;
+                zend_hash_internal_pointer_reset_ex(barr, &bpos);
+                info->bytes.resize(zend_hash_num_elements(barr));
+
+                vector<Ice::Byte>::size_type i = 0;
+                while(zend_hash_get_current_data_ex(barr, &data, &bpos) != FAILURE)
+                {
+                    zval* e = *(reinterpret_cast<zval**>(data));
+                    long l = Z_LVAL_P(e);
+                    assert(l >= 0 && l <= 255);
+                    info->bytes[i++] = static_cast<Ice::Byte>(l);
+                    zend_hash_move_forward_ex(barr, &bpos);
+                }
+
+                status = zend_hash_find(Z_OBJPROP_P(s), STRCAST("objects"), sizeof("objects"), &data);
+                assert(status == SUCCESS);
+                zval* objects = *(reinterpret_cast<zval**>(data));
+                assert(Z_TYPE_P(objects) == IS_ARRAY);
+                HashTable* oarr = Z_ARRVAL_P(objects);
+                HashPosition opos;
+                zend_hash_internal_pointer_reset_ex(oarr, &opos);
+
+                while(zend_hash_get_current_data_ex(oarr, &data, &opos) != FAILURE)
+                {
+                    zval* o = *(reinterpret_cast<zval**>(data));
+                    assert(Z_TYPE_P(o) == IS_OBJECT);
+
+                    Ice::ObjectPtr writer;
+
+                    ObjectMap::iterator i = objectMap->find(Z_OBJ_HANDLE_P(o));
+                    if(i == objectMap->end())
+                    {
+                        writer = new ObjectWriter(o, objectMap, 0 TSRMLS_CC);
+                        objectMap->insert(ObjectMap::value_type(Z_OBJ_HANDLE_P(o), writer));
+                    }
+                    else
+                    {
+                        writer = i->second;
+                    }
+
+                    info->objects.push_back(writer);
+                    zend_hash_move_forward_ex(oarr, &opos);
+                }
+
+                slices.push_back(info);
+                zend_hash_move_forward_ex(arr, &pos);
+            }
+
+            slicedData = new Ice::SlicedData(slices);
+        }
+    }
+
+    return slicedData;
+}
+
+//
 // UnmarshalCallback implementation.
 //
 IcePHP::UnmarshalCallback::~UnmarshalCallback()
@@ -1770,13 +2061,7 @@ IcePHP::ClassInfo::marshal(zval* zv, const Ice::OutputStreamPtr& os, ObjectMap*
     ObjectMap::iterator q = objectMap->find(Z_OBJ_HANDLE_P(zv));
     if(q == objectMap->end())
     {
-        //
-        // Determine the most-derived Slice type implemented by this object by scanning its
-        // inheritance hierarchy until we find a class or interface that we recognize.
-        //
-        ClassInfoPtr info = getMostDerived(zce, Z_OBJCE_P(zv), 0 TSRMLS_CC);
-        assert(info);
-        writer = new ObjectWriter(info, zv, objectMap TSRMLS_CC);
+        writer = new ObjectWriter(zv, objectMap, this TSRMLS_CC);
         objectMap->insert(ObjectMap::value_type(Z_OBJ_HANDLE_P(zv), writer));
     }
     else
@@ -2045,19 +2330,29 @@ IcePHP::ProxyInfo::destroy()
 //
 // ObjectWriter implementation.
 //
-IcePHP::ObjectWriter::ObjectWriter(const ClassInfoPtr& info, zval* object, ObjectMap* objectMap TSRMLS_DC) :
-    _info(info), _object(object), _map(objectMap)
+IcePHP::ObjectWriter::ObjectWriter(zval* object, ObjectMap* objectMap, const ClassInfoPtr& formal TSRMLS_DC) :
+    _object(object), _map(objectMap)
 {
 #ifdef ZTS
     this->TSRMLS_C = TSRMLS_C;
 #endif
 
-    Z_OBJ_HT_P(_object)->add_ref(_object TSRMLS_CC);
+    Z_ADDREF_P(_object);
+
+    //
+    // We need to determine the most-derived Slice type supported by this object.
+    // This is typically a Slice class, but it can also be an interface.
+    //
+    // The caller may have provided a ClassInfo representing the formal type, in
+    // which case we ensure that the actual type is compatible with the formal type.
+    //
+    _info = getClassInfoByClass(Z_OBJCE_P(object), formal ? formal->zce : 0 TSRMLS_CC);
+    assert(_info);
 }
 
 IcePHP::ObjectWriter::~ObjectWriter()
 {
-    Z_OBJ_HT_P(_object)->del_ref(_object TSRMLS_CC);
+    zval_ptr_dtor(&_object);
 }
 
 void
@@ -2076,12 +2371,24 @@ IcePHP::ObjectWriter::ice_preMarshal()
 void
 IcePHP::ObjectWriter::write(const Ice::OutputStreamPtr& os) const
 {
+    Ice::SlicedDataPtr slicedData;
+
+    if(_info->preserve)
+    {
+        //
+        // Retrieve the SlicedData object that we stored as a hidden member of the PHP object.
+        //
+        slicedData = SlicedDataUtil::getMember(_object, const_cast<ObjectMap*>(_map) TSRMLS_CC);
+    }
+
+    os->startObject(slicedData);
+
     ClassInfoPtr info = _info;
     while(info && info->id != Ice::Object::ice_staticId())
     {
-        os->writeTypeId(info->id);
-
-        os->startSlice();
+        assert(info->base); // All classes have the Ice::Object base type.
+        const bool lastSlice = info->base->id == Ice::Object::ice_staticId();
+        os->startSlice(info->id, lastSlice);
         for(DataMemberList::iterator q = info->members.begin(); q != info->members.end(); ++q)
         {
             DataMemberPtr member = *q;
@@ -2107,13 +2414,7 @@ IcePHP::ObjectWriter::write(const Ice::OutputStreamPtr& os) const
         info = info->base;
     }
 
-    //
-    // Marshal the Ice::Object slice.
-    //
-    os->writeTypeId(Ice::Object::ice_staticId());
-    os->startSlice();
-    os->writeSize(0); // For compatibility with the old AFM.
-    os->endSlice();
+    os->endObject();
 }
 
 //
@@ -2148,19 +2449,16 @@ IcePHP::ObjectReader::ice_postUnmarshal()
 }
 
 void
-IcePHP::ObjectReader::read(const Ice::InputStreamPtr& is, bool rid)
+IcePHP::ObjectReader::read(const Ice::InputStreamPtr& is)
 {
+    is->startObject();
+
     //
     // Unmarshal the slices of a user-defined class.
     //
     ClassInfoPtr info = _info;
     while(info && info->id != Ice::Object::ice_staticId())
     {
-        if(rid)
-        {
-            is->readTypeId();
-        }
-
         is->startSlice();
         for(DataMemberList::iterator p = info->members.begin(); p != info->members.end(); ++p)
         {
@@ -2169,27 +2467,17 @@ IcePHP::ObjectReader::read(const Ice::InputStreamPtr& is, bool rid)
         }
         is->endSlice();
 
-        rid = true;
-
         info = info->base;
     }
 
-    //
-    // Unmarshal the Ice::Object slice.
-    //
-    if(rid)
-    {
-        is->readTypeId();
-    }
+    _slicedData = is->endObject(_info->preserve);
 
-    is->startSlice();
-    // For compatibility with the old AFM.
-    Ice::Int sz = is->readSize();
-    if(sz != 0)
+    if(_slicedData)
     {
-        throw Ice::MarshalException(__FILE__, __LINE__);
+        SlicedDataUtil* util = reinterpret_cast<SlicedDataUtil*>(is->closure());
+        assert(util);
+        util->add(this);
     }
-    is->endSlice();
 }
 
 ClassInfoPtr
@@ -2204,6 +2492,12 @@ IcePHP::ObjectReader::getObject() const
     return _object;
 }
 
+Ice::SlicedDataPtr
+IcePHP::ObjectReader::getSlicedData() const
+{
+    return _slicedData;
+}
+
 //
 // ReadObjectCallback implementation.
 //
@@ -2297,11 +2591,6 @@ IcePHP::ExceptionInfo::unmarshal(const Ice::InputStreamPtr& is, const Communicat
         is->endSlice();
 
         info = info->base;
-        if(info)
-        {
-            string id;
-            is->read(id); // Read the ID of the next slice.
-        }
     }
 
     return destroy.release();
@@ -2378,6 +2667,81 @@ IcePHP::ExceptionInfo::isA(const string& typeId) const
     return false;
 }
 
+//
+// ExceptionReader implementation.
+//
+IcePHP::ExceptionReader::ExceptionReader(const CommunicatorInfoPtr& communicatorInfo, const ExceptionInfoPtr& info
+                                         TSRMLS_DC) :
+    Ice::UserExceptionReader(communicatorInfo->getCommunicator()), _communicatorInfo(communicatorInfo), _info(info)
+{
+#ifdef ZTS
+    this->TSRMLS_C = TSRMLS_C;
+#endif
+}
+
+IcePHP::ExceptionReader::~ExceptionReader()
+    throw()
+{
+}
+
+void
+IcePHP::ExceptionReader::read(const Ice::InputStreamPtr& is) const
+{
+    is->startException();
+
+    const_cast<zval*&>(_ex) = _info->unmarshal(is, _communicatorInfo TSRMLS_CC);
+
+    const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
+}
+
+bool
+IcePHP::ExceptionReader::usesClasses() const
+{
+    return _info->usesClasses;
+}
+
+void
+IcePHP::ExceptionReader::usesClasses(bool)
+{
+}
+
+string
+IcePHP::ExceptionReader::ice_name() const
+{
+    return _info->id;
+}
+
+Ice::Exception*
+IcePHP::ExceptionReader::ice_clone() const
+{
+    assert(false);
+    return 0;
+}
+
+void
+IcePHP::ExceptionReader::ice_throw() const
+{
+    throw *this;
+}
+
+ExceptionInfoPtr
+IcePHP::ExceptionReader::getInfo() const
+{
+    return _info;
+}
+
+zval*
+IcePHP::ExceptionReader::getException() const
+{
+    return _ex;
+}
+
+Ice::SlicedDataPtr
+IcePHP::ExceptionReader::getSlicedData() const
+{
+    return _slicedData;
+}
+
 #ifdef _WIN32
 extern "C"
 #endif
@@ -2631,12 +2995,13 @@ ZEND_FUNCTION(IcePHP_defineClass)
     char* name;
     int nameLen;
     zend_bool isAbstract;
+    zend_bool preserve;
     zval* base;
     zval* interfaces;
     zval* members;
 
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("ssbo!a!a!"), &id, &idLen, &name, &nameLen,
-                             &isAbstract, &base, &interfaces, &members) == FAILURE)
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("ssbbo!a!a!"), &id, &idLen, &name, &nameLen,
+                             &isAbstract, &preserve, &base, &interfaces, &members) == FAILURE)
     {
         return;
     }
@@ -2653,6 +3018,7 @@ ZEND_FUNCTION(IcePHP_defineClass)
     addClassInfoByName(type TSRMLS_CC);
 
     type->isAbstract = isAbstract ? true : false;
+    type->preserve = preserve ? true : false;
     if(base)
     {
         TypeInfoPtr p = Wrapper<TypeInfoPtr>::value(base TSRMLS_CC);
@@ -2746,11 +3112,12 @@ ZEND_FUNCTION(IcePHP_defineException)
     int idLen;
     char* name;
     int nameLen;
+    zend_bool preserve;
     zval* base;
     zval* members;
 
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("sso!a!"), &id, &idLen, &name, &nameLen,
-                             &base, &members) == FAILURE)
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("ssbo!a!"), &id, &idLen, &name, &nameLen,
+                             &preserve, &base, &members) == FAILURE)
     {
         return;
     }
@@ -2758,6 +3125,7 @@ ZEND_FUNCTION(IcePHP_defineException)
     ExceptionInfoPtr ex = new ExceptionInfo();
     ex->id = id;
     ex->name = name;
+    ex->preserve = preserve ? true : false;
     if(base)
     {
         ex->base = Wrapper<ExceptionInfoPtr>::value(base TSRMLS_CC);
diff --git a/php/src/IcePHP/Types.h b/php/src/IcePHP/Types.h
index 14ce1d0ec6d..917ad19c89b 100644
--- a/php/src/IcePHP/Types.h
+++ b/php/src/IcePHP/Types.h
@@ -45,6 +45,33 @@ class AbortMarshaling
 
 typedef std::map<unsigned int, Ice::ObjectPtr> ObjectMap;
 
+class ObjectReader;
+typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
+
+//
+// This class keeps track of PHP objects (instances of Slice classes
+// and exceptions) that have preserved slices.
+//
+class SlicedDataUtil
+{
+public:
+
+    ~SlicedDataUtil();
+
+    void add(const ObjectReaderPtr&);
+
+    void update(TSRMLS_D);
+
+    static void setMember(zval*, const Ice::SlicedDataPtr& TSRMLS_DC);
+    static Ice::SlicedDataPtr getMember(zval*, ObjectMap* TSRMLS_DC);
+
+private:
+
+    std::set<ObjectReaderPtr> _readers;
+    static zend_class_entry* _slicedDataType;
+    static zend_class_entry* _sliceInfoType;
+};
+
 struct PrintObjectHistory
 {
     int index;
@@ -329,6 +356,7 @@ public:
     std::string id;
     std::string name; // PHP class name
     bool isAbstract;
+    bool preserve;
     ClassInfoPtr base;
     ClassInfoList interfaces;
     DataMemberList members;
@@ -379,6 +407,7 @@ public:
 
     std::string id;
     std::string name; // PHP class name
+    bool preserve;
     ExceptionInfoPtr base;
     DataMemberList members;
     bool usesClasses;
@@ -400,7 +429,7 @@ class ObjectWriter : public Ice::ObjectWriter
 {
 public:
 
-    ObjectWriter(const ClassInfoPtr&, zval*, ObjectMap* TSRMLS_DC);
+    ObjectWriter(zval*, ObjectMap*, const ClassInfoPtr& TSRMLS_DC);
     ~ObjectWriter();
 
     virtual void ice_preMarshal();
@@ -409,9 +438,9 @@ public:
 
 private:
 
-    ClassInfoPtr _info;
     zval* _object;
     ObjectMap* _map;
+    ClassInfoPtr _info;
 #if ZTS
     TSRMLS_D;
 #endif
@@ -429,22 +458,59 @@ public:
 
     virtual void ice_postUnmarshal();
 
-    virtual void read(const Ice::InputStreamPtr&, bool);
+    virtual void read(const Ice::InputStreamPtr&);
 
     virtual ClassInfoPtr getInfo() const;
 
     zval* getObject() const;
 
+    Ice::SlicedDataPtr getSlicedData() const;
+
 private:
 
     zval* _object;
     ClassInfoPtr _info;
     CommunicatorInfoPtr _communicator;
+    Ice::SlicedDataPtr _slicedData;
+#if ZTS
+    TSRMLS_D;
+#endif
+};
+
+//
+// ExceptionReader creates a PHP user exception and unmarshals it.
+//
+class ExceptionReader : public Ice::UserExceptionReader
+{
+public:
+
+    ExceptionReader(const CommunicatorInfoPtr&, const ExceptionInfoPtr& TSRMLS_DC);
+    ~ExceptionReader() throw();
+
+    virtual void read(const Ice::InputStreamPtr&) const;
+    virtual bool usesClasses() const;
+    virtual void usesClasses(bool);
+
+    virtual std::string ice_name() const;
+    virtual Ice::Exception* ice_clone() const;
+    virtual void ice_throw() const;
+
+    ExceptionInfoPtr getInfo() const;
+
+    zval* getException() const;
+
+    Ice::SlicedDataPtr getSlicedData() const;
+
+private:
+
+    CommunicatorInfoPtr _communicatorInfo;
+    ExceptionInfoPtr _info;
+    zval* _ex;
+    Ice::SlicedDataPtr _slicedData;
 #if ZTS
     TSRMLS_D;
 #endif
 };
-typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
 
 } // End of namespace IcePHP
 
diff --git a/php/src/IcePHP/Util.cpp b/php/src/IcePHP/Util.cpp
index 60b52ac15a0..2bd1875bce5 100644
--- a/php/src/IcePHP/Util.cpp
+++ b/php/src/IcePHP/Util.cpp
@@ -17,6 +17,169 @@ using namespace std;
 using namespace IcePHP;
 using namespace Slice::PHP;
 
+namespace
+{
+
+bool
+getMember(zval* zv, const string& name, zval** member, int type, bool required TSRMLS_DC)
+{
+    *member = 0;
+
+    void* data = 0;
+    if(zend_hash_find(Z_OBJPROP_P(zv), STRCAST(name.c_str()), name.size() + 1, &data) == FAILURE)
+    {
+        if(required)
+        {
+            invalidArgument("object does not contain member `%s'" TSRMLS_CC, name.c_str());
+            return false;
+        }
+    }
+
+    if(data)
+    {
+        zval** val = reinterpret_cast<zval**>(data);
+
+        if(Z_TYPE_PP(val) != type)
+        {
+            string expected = zendTypeToString(type);
+            string actual = zendTypeToString(Z_TYPE_PP(val));
+            invalidArgument("expected value of type %s for member `%s' but received %s" TSRMLS_CC, expected.c_str(),
+                            name.c_str(), actual.c_str());
+            return false;
+        }
+
+        *member = *val;
+    }
+
+    return true;
+}
+
+void
+setStringMember(zval* obj, const string& name, const string& val TSRMLS_DC)
+{
+    zend_class_entry* cls = Z_OBJCE_P(obj);
+    assert(cls);
+    zend_update_property_stringl(cls, obj, const_cast<char*>(name.c_str()), static_cast<int>(name.size()),
+                                 const_cast<char*>(val.c_str()), static_cast<int>(val.size()) TSRMLS_CC);
+}
+
+template<typename T, const char* PT>
+bool
+getVersion(zval* zv, T& v TSRMLS_DC)
+{
+    if(Z_TYPE_P(zv) != IS_OBJECT)
+    {
+        invalidArgument("value does not contain an object" TSRMLS_CC);
+        return false;
+    }
+
+    zend_class_entry* cls = idToClass(PT TSRMLS_CC);
+    assert(cls);
+
+    zend_class_entry* ce = Z_OBJCE_P(zv);
+    if(ce != cls)
+    {
+        invalidArgument("expected an instance of %s" TSRMLS_CC, ce->name);
+        return false;
+    }
+
+    zval* majorVal;
+    if(!getMember(zv, "major", &majorVal, IS_LONG, true TSRMLS_CC))
+    {
+        return false;
+    }
+
+    zval* minorVal;
+    if(!getMember(zv, "minor", &minorVal, IS_LONG, true TSRMLS_CC))
+    {
+        return false;
+    }
+
+    long m;
+    m = Z_LVAL_P(majorVal);
+    if(m < 0 || m > 255)
+    {
+        invalidArgument("version major must be a value between 0 and 255" TSRMLS_CC);
+        return false;
+    }
+    v.major = m;
+
+    m = Z_LVAL_P(minorVal);
+    if(m < 0 || m > 255)
+    {
+        invalidArgument("version minor must be a value between 0 and 255" TSRMLS_CC);
+        return false;
+    }
+    v.minor = m;
+
+    return true;
+}
+
+template<typename T, const char* PT>
+bool
+createVersion(zval* zv, const T& version TSRMLS_DC)
+{
+    zend_class_entry* cls = idToClass(PT TSRMLS_CC);
+    assert(cls);
+
+    if(object_init_ex(zv, cls) != SUCCESS)
+    {
+        runtimeError("unable to initialize %s" TSRMLS_CC, cls->name);
+        return false;
+    }
+
+    zend_update_property_long(cls, zv, const_cast<char*>("major"), sizeof("major") - 1, version.major TSRMLS_CC);
+    zend_update_property_long(cls, zv, const_cast<char*>("minor"), sizeof("minor") - 1, version.minor TSRMLS_CC);
+
+    return true;
+}
+
+template<typename T, const char* PT>
+bool
+versionToString(zval* zv, zval* s TSRMLS_DC)
+{
+    T v;
+    if(!getVersion<T, PT>(zv, v TSRMLS_CC))
+    {
+        return false;
+    }
+
+    try
+    {
+        string str = IceInternal::versionToString<T>(v);
+        ZVAL_STRINGL(s, STRCAST(str.c_str()), str.length(), 1);
+    }
+    catch(const IceUtil::Exception& ex)
+    {
+        throwException(ex TSRMLS_CC);
+        return false;
+    }
+
+    return true;
+}
+
+template<typename T, const char* PT>
+bool
+stringToVersion(const string& s, zval* zv TSRMLS_DC)
+{
+    try
+    {
+        T v = IceInternal::stringToVersion<T>(s);
+        return createVersion<T, PT>(zv, v TSRMLS_CC);
+    }
+    catch(const IceUtil::Exception& ex)
+    {
+        throwException(ex TSRMLS_CC);
+    }
+
+    return false;
+}
+
+char Ice_ProtocolVersion[] = "::Ice::ProtocolVersion";
+char Ice_EncodingVersion[] = "::Ice::EncodingVersion";
+
+}
+
 #if PHP_VERSION_ID < 50400
 #ifdef _WIN32
 extern "C"
@@ -103,10 +266,8 @@ IcePHP::createIdentity(zval* zv, const Ice::Identity& id TSRMLS_DC)
         return false;
     }
 
-    zend_update_property_string(cls, zv, const_cast<char*>("name"), sizeof("name") - 1, STRCAST(id.name.c_str())
-                                TSRMLS_CC);
-    zend_update_property_string(cls, zv, const_cast<char*>("category"), sizeof("category") - 1,
-                                STRCAST(id.category.c_str()) TSRMLS_CC);
+    setStringMember(zv, "name", id.name TSRMLS_CC);
+    setStringMember(zv, "category", id.category TSRMLS_CC);
 
     return true;
 }
@@ -133,35 +294,19 @@ IcePHP::extractIdentity(zval* zv, Ice::Identity& id TSRMLS_DC)
     //
     // Category is optional, but name is required.
     //
-    void* categoryData = 0;
-    void* nameData;
-    if(zend_hash_find(Z_OBJPROP_P(zv), STRCAST("name"), sizeof("name"), &nameData) == FAILURE)
-    {
-        invalidArgument("identity value does not contain member `name'" TSRMLS_CC);
-        return false;
-    }
-    zend_hash_find(Z_OBJPROP_P(zv), STRCAST("category"), sizeof("category"), &categoryData);
-    zval** categoryVal = reinterpret_cast<zval**>(categoryData);
-    zval** nameVal = reinterpret_cast<zval**>(nameData);
+    zval* categoryVal;
+    zval* nameVal;
 
-    if(Z_TYPE_PP(nameVal) != IS_STRING)
+    if(!getMember(zv, "category", &categoryVal, IS_STRING, false TSRMLS_CC) ||
+       !getMember(zv, "name", &nameVal, IS_STRING, true TSRMLS_CC))
     {
-        string s = zendTypeToString(Z_TYPE_PP(nameVal));
-        invalidArgument("expected a string value for identity member `name' but received %s" TSRMLS_CC, s.c_str());
         return false;
     }
 
-    if(categoryVal && Z_TYPE_PP(categoryVal) != IS_STRING && Z_TYPE_PP(categoryVal) != IS_NULL)
+    id.name = Z_STRVAL_P(nameVal);
+    if(categoryVal)
     {
-        string s = zendTypeToString(Z_TYPE_PP(categoryVal));
-        invalidArgument("expected a string value for identity member `category' but received %s" TSRMLS_CC, s.c_str());
-        return false;
-    }
-
-    id.name = Z_STRVAL_PP(nameVal);
-    if(categoryVal && Z_TYPE_PP(categoryVal) == IS_STRING)
-    {
-        id.category = Z_STRVAL_PP(categoryVal);
+        id.category = Z_STRVAL_P(categoryVal);
     }
     else
     {
@@ -286,13 +431,22 @@ IcePHP::extractStringArray(zval* zv, Ice::StringSeq& seq TSRMLS_DC)
     return true;
 }
 
-static void
-setStringMember(zval* obj, const string& name, const string& val TSRMLS_DC)
+bool
+IcePHP::createProtocolVersion(zval* zv, const Ice::ProtocolVersion& v TSRMLS_DC)
 {
-    zend_class_entry* cls = Z_OBJCE_P(obj);
-    assert(cls);
-    zend_update_property_stringl(cls, obj, const_cast<char*>(name.c_str()), static_cast<int>(name.size()),
-                                 const_cast<char*>(val.c_str()), static_cast<int>(val.size()) TSRMLS_CC);
+    return createVersion<Ice::ProtocolVersion, Ice_ProtocolVersion>(zv, v TSRMLS_CC);
+}
+
+bool
+IcePHP::createEncodingVersion(zval* zv, const Ice::EncodingVersion& v TSRMLS_DC)
+{
+    return createVersion<Ice::EncodingVersion, Ice_EncodingVersion>(zv, v TSRMLS_CC);
+}
+
+bool
+IcePHP::extractEncodingVersion(zval* zv, Ice::EncodingVersion& v TSRMLS_DC)
+{
+    return getVersion<Ice::EncodingVersion, Ice_EncodingVersion>(zv, v TSRMLS_CC);
 }
 
 static bool
@@ -368,6 +522,7 @@ convertLocalException(const Ice::LocalException& ex, zval* zex TSRMLS_DC)
             return false;
         }
         zend_update_property(cls, zex, const_cast<char*>("id"), sizeof("id") - 1, id TSRMLS_CC);
+        zval_ptr_dtor(&id);
     }
     catch(const Ice::RequestFailedException& e)
     {
@@ -379,6 +534,7 @@ convertLocalException(const Ice::LocalException& ex, zval* zex TSRMLS_DC)
             return false;
         }
         zend_update_property(cls, zex, const_cast<char*>("id"), sizeof("id") - 1, id TSRMLS_CC);
+        zval_ptr_dtor(&id);
         setStringMember(zex, "facet", e.facet TSRMLS_CC);
         setStringMember(zex, "operation", e.operation TSRMLS_CC);
     }
@@ -398,21 +554,45 @@ convertLocalException(const Ice::LocalException& ex, zval* zex TSRMLS_DC)
     }
     catch(const Ice::UnsupportedProtocolException& e)
     {
-        zend_update_property_long(cls, zex, const_cast<char*>("badMajor"), sizeof("badMajor") - 1, e.badMajor
-                                  TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("badMinor"), sizeof("badMinor") - 1, e.badMinor
-                                  TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("major"), sizeof("major") - 1, e.major TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("minor"), sizeof("minor") - 1, e.minor TSRMLS_CC);
+        zval* v;
+        MAKE_STD_ZVAL(v);
+        if(!createProtocolVersion(v, e.bad TSRMLS_CC))
+        {
+            zval_ptr_dtor(&v);
+            return false;
+        }
+        zend_update_property(cls, zex, const_cast<char*>("bad"), sizeof("bad") - 1, v TSRMLS_CC);
+        zval_ptr_dtor(&v);
+
+        MAKE_STD_ZVAL(v);
+        if(!createProtocolVersion(v, e.supported TSRMLS_CC))
+        {
+            zval_ptr_dtor(&v);
+            return false;
+        }
+        zend_update_property(cls, zex, const_cast<char*>("supported"), sizeof("supported") - 1, v TSRMLS_CC);
+        zval_ptr_dtor(&v);
     }
     catch(const Ice::UnsupportedEncodingException& e)
     {
-        zend_update_property_long(cls, zex, const_cast<char*>("badMajor"), sizeof("badMajor") - 1, e.badMajor
-                                  TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("badMinor"), sizeof("badMinor") - 1, e.badMinor
-                                  TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("major"), sizeof("major") - 1, e.major TSRMLS_CC);
-        zend_update_property_long(cls, zex, const_cast<char*>("minor"), sizeof("minor") - 1, e.minor TSRMLS_CC);
+        zval* v;
+        MAKE_STD_ZVAL(v);
+        if(!createEncodingVersion(v, e.bad TSRMLS_CC))
+        {
+            zval_ptr_dtor(&v);
+            return false;
+        }
+        zend_update_property(cls, zex, const_cast<char*>("bad"), sizeof("bad") - 1, v TSRMLS_CC);
+        zval_ptr_dtor(&v);
+
+        MAKE_STD_ZVAL(v);
+        if(!createEncodingVersion(v, e.supported TSRMLS_CC))
+        {
+            zval_ptr_dtor(&v);
+            return false;
+        }
+        zend_update_property(cls, zex, const_cast<char*>("supported"), sizeof("supported") - 1, v TSRMLS_CC);
+        zval_ptr_dtor(&v);
     }
     catch(const Ice::NoObjectFactoryException& e)
     {
@@ -746,3 +926,108 @@ ZEND_FUNCTION(Ice_generateUUID)
     string uuid = IceUtil::generateUUID();
     RETURN_STRINGL(STRCAST(uuid.c_str()), uuid.size(), 1);
 }
+
+ZEND_FUNCTION(Ice_currentProtocol)
+{
+    if(ZEND_NUM_ARGS() > 0)
+    {
+        WRONG_PARAM_COUNT;
+    }
+
+    if(!createProtocolVersion(return_value, Ice::currentProtocol TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_currentProtocolEncoding)
+{
+    if(ZEND_NUM_ARGS() > 0)
+    {
+        WRONG_PARAM_COUNT;
+    }
+
+    if(!createEncodingVersion(return_value, Ice::currentProtocolEncoding TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_currentEncoding)
+{
+    if(ZEND_NUM_ARGS() > 0)
+    {
+        WRONG_PARAM_COUNT;
+    }
+
+    if(!createEncodingVersion(return_value, Ice::currentEncoding TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_protocolVersionToString)
+{
+    zend_class_entry* versionClass = idToClass(Ice_ProtocolVersion TSRMLS_CC);
+    assert(versionClass);
+
+    zval* zv;
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O"), &zv, versionClass) != SUCCESS)
+    {
+        RETURN_NULL();
+    }
+
+    if(!versionToString<Ice::ProtocolVersion, Ice_ProtocolVersion>(zv, return_value TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_stringToProtocolVersion)
+{
+    char* str;
+    int strLen;
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &str, &strLen) != SUCCESS)
+    {
+        RETURN_NULL();
+    }
+    string s(str, strLen);
+
+    if(!stringToVersion<Ice::ProtocolVersion, Ice_ProtocolVersion>(s, return_value TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_encodingVersionToString)
+{
+    zend_class_entry* versionClass = idToClass(Ice_EncodingVersion TSRMLS_CC);
+    assert(versionClass);
+
+    zval* zv;
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O"), &zv, versionClass) != SUCCESS)
+    {
+        RETURN_NULL();
+    }
+
+    if(!versionToString<Ice::EncodingVersion, Ice_EncodingVersion>(zv, return_value TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
+
+ZEND_FUNCTION(Ice_stringToEncodingVersion)
+{
+    char* str;
+    int strLen;
+    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &str, &strLen) != SUCCESS)
+    {
+        RETURN_NULL();
+    }
+    string s(str, strLen);
+
+    if(!stringToVersion<Ice::EncodingVersion, Ice_EncodingVersion>(s, return_value TSRMLS_CC))
+    {
+        RETURN_NULL();
+    }
+}
diff --git a/php/src/IcePHP/Util.h b/php/src/IcePHP/Util.h
index 8dde23d9969..e73bcfaf296 100644
--- a/php/src/IcePHP/Util.h
+++ b/php/src/IcePHP/Util.h
@@ -20,6 +20,13 @@ extern "C"
 ZEND_FUNCTION(Ice_stringVersion);
 ZEND_FUNCTION(Ice_intVersion);
 ZEND_FUNCTION(Ice_generateUUID);
+ZEND_FUNCTION(Ice_currentProtocol);
+ZEND_FUNCTION(Ice_currentProtocolEncoding);
+ZEND_FUNCTION(Ice_currentEncoding);
+ZEND_FUNCTION(Ice_protocolVersionToString);
+ZEND_FUNCTION(Ice_stringToProtocolVersion);
+ZEND_FUNCTION(Ice_encodingVersionToString);
+ZEND_FUNCTION(Ice_stringToEncodingVersion);
 }
 
 namespace IcePHP
@@ -73,6 +80,21 @@ bool createStringArray(zval*, const Ice::StringSeq& TSRMLS_DC);
 bool extractStringArray(zval*, Ice::StringSeq& TSRMLS_DC);
 
 //
+// Create a PHP instance of Ice_ProtocolVersion.
+//
+bool createProtocolVersion(zval*, const Ice::ProtocolVersion& TSRMLS_DC);
+
+//
+// Create a PHP instance of Ice_EncodingVersion.
+//
+bool createEncodingVersion(zval*, const Ice::EncodingVersion& TSRMLS_DC);
+
+//
+// Extracts the members of an encoding version.
+//
+bool extractEncodingVersion(zval*, Ice::EncodingVersion& TSRMLS_DC);
+
+//
 // Convert the given exception into its PHP equivalent.
 //
 zval* convertException(const Ice::Exception& TSRMLS_DC);
diff --git a/php/test/Ice/exceptions/junk.php b/php/test/Ice/exceptions/junk.php
deleted file mode 100644
index d6a44f5c74d..00000000000
--- a/php/test/Ice/exceptions/junk.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<!-- ********************************************************************** -->
-<!--                                                                        -->
-<!-- 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.                        -->
-<!--                                                                        -->
-<!-- ********************************************************************** -->
-
-<?
-echo "value = ",PHP_CONFIG_FILE_PATH,"\n";
-?>
diff --git a/php/test/Ice/exceptions/run.py b/php/test/Ice/exceptions/run.py
index 0248812b4bb..7732c33648e 100755
--- a/php/test/Ice/exceptions/run.py
+++ b/php/test/Ice/exceptions/run.py
@@ -20,7 +20,15 @@ if len(path) == 0:
 sys.path.append(os.path.join(path[0], "scripts"))
 import TestUtil
 
-print("tests with regular server.")
+print("Running test with compact (default) format.")
 TestUtil.clientServerTest()
-print("tests with AMD server.")
+print("Running test with sliced format.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.SlicedFormat", additionalServerOptions="--Ice.Default.SlicedFormat")
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
+print("Running test with compact (default) format and AMD server.")
 TestUtil.clientServerTest(server="serveramd")
+print("Running test with sliced format and AMD server.")
+TestUtil.clientServerTest(server="serveramd", additionalClientOptions="--Ice.Default.SlicedFormat", additionalServerOptions="--Ice.Default.SlicedFormat")
+print("Running test with 1.0 encoding and AMD server.")
+TestUtil.clientServerTest(server="serveramd", additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/php/test/Ice/info/Client.php b/php/test/Ice/info/Client.php
index b936100f942..4bded0b35b6 100644
--- a/php/test/Ice/info/Client.php
+++ b/php/test/Ice/info/Client.php
@@ -39,18 +39,22 @@ function allTests($communicator)
     $udpEndpointType = $NS ? constant("Ice\\UDPEndpointType") : constant("Ice_UDPEndpointType");
     $udpEndpointInfoClass = $NS ? "Ice\\UDPEndpointInfo" : "Ice_UDPEndpointInfo";
     $sslEndpointType = 2;
+    $protocolVersionClass = $NS ? "Ice\\ProtocolVersion" : "Ice_ProtocolVersion";
+    $encodingVersionClass = $NS ? "Ice\\EncodingVersion" : "Ice_EncodingVersion";
 
     echo "testing proxy endpoint information... ";
     flush();
     {
-        $p1 = $communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z:" .
+        $p1 = $communicator->stringToProxy("test -t:default -v 1.4 -e 1.3 -h tcphost -p 10000 -t 1200 -z:" .
                                            "udp -h udphost -p 10001 --interface eth0 --ttl 5:" .
-                                           "opaque -t 100 -v ABCD");
+                                           "opaque -e 1.8 -t 100 -v ABCD");
 
         $endps = $p1->ice_getEndpoints();
 
         $ipEndpoint = $endps[0]->getInfo();
         test($ipEndpoint instanceof $ipEndpointInfoClass);
+        test($ipEndpoint->protocol == eval("return new " . $protocolVersionClass . "(1, 4);"));
+        test($ipEndpoint->encoding == eval("return new " . $encodingVersionClass . "(1, 3);"));
         test($ipEndpoint->host == "tcphost");
         test($ipEndpoint->port == 10000);
         test($ipEndpoint->timeout == 1200);
@@ -63,6 +67,8 @@ function allTests($communicator)
 
         $udpEndpoint = $endps[1]->getInfo();
         test($udpEndpoint instanceof $udpEndpointInfoClass);
+        test($udpEndpoint->protocol == Ice_currentProtocol());
+        test($udpEndpoint->encoding == Ice_currentEncoding());
         test($udpEndpoint->host == "udphost");
         test($udpEndpoint->port == 10001);
         test($udpEndpoint->mcastInterface == "eth0");
diff --git a/php/test/Ice/ini/Client.php b/php/test/Ice/ini/Client.php
index fa09f2ead78..70c80181e24 100644
--- a/php/test/Ice/ini/Client.php
+++ b/php/test/Ice/ini/Client.php
@@ -32,9 +32,9 @@ $communicator = null;
 
 if($NS)
 {
-    $initData = eval("new Ice\\InitializationData;");
-    $initData->properties = eval("Ice\\getProperties();");
-    $communicator = eval("Ice\\initialize($initData);");
+    $initData = eval("return new Ice\\InitializationData;");
+    $initData->properties = eval("return Ice\\getProperties();");
+    $communicator = eval("return Ice\\initialize(\$initData);");
 }
 else
 {
diff --git a/php/test/Ice/ini/ClientWithProfile.php b/php/test/Ice/ini/ClientWithProfile.php
index b60fd3ed04a..7d8da674b7c 100644
--- a/php/test/Ice/ini/ClientWithProfile.php
+++ b/php/test/Ice/ini/ClientWithProfile.php
@@ -37,9 +37,9 @@ $communicator = null;
 
 if($NS)
 {
-    $initData = eval("new Ice\\InitializationData;");
-    $initData->properties = eval("Ice\\getProperties();");
-    $communicator = eval("Ice\\initialize($initData);");
+    $initData = eval("return new Ice\\InitializationData;");
+    $initData->properties = eval("return Ice\\getProperties();");
+    $communicator = eval("return Ice\\initialize(\$initData);");
 }
 else
 {
@@ -53,7 +53,7 @@ test($communicator != null);
 $properties = null;
 if($NS)
 {
-    $properties = eval("Ice\\getProperties(\"Test\");");
+    $properties = eval("return Ice\\getProperties(\"Test\");");
 }
 else
 {
diff --git a/php/test/Ice/objects/run.py b/php/test/Ice/objects/run.py
index 751a8e1d456..3d61174d3d1 100755
--- a/php/test/Ice/objects/run.py
+++ b/php/test/Ice/objects/run.py
@@ -20,4 +20,9 @@ if len(path) == 0:
 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")
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/php/test/Ice/proxy/Client.php b/php/test/Ice/proxy/Client.php
index 4747643ff0a..9991bdb6813 100644
--- a/php/test/Ice/proxy/Client.php
+++ b/php/test/Ice/proxy/Client.php
@@ -32,9 +32,12 @@ function test($b)
 function allTests($communicator)
 {
     global $NS;
+    global $Ice_Encoding_1_0;
+    global $Ice_Encoding_1_1;
 
     $random = $NS ? constant("Ice\\EndpointSelectionType::Random") : constant("Ice_EndpointSelectionType::Random");
     $ordered = $NS ? constant("Ice\\EndpointSelectionType::Ordered") : constant("Ice_EndpointSelectionType::Ordered");
+    $encodingVersion = $NS ? "Ice\\EncodingVersion" : "Ice_EncodingVersion";
 
     echo "testing stringToProxy... ";
     flush();
@@ -368,6 +371,42 @@ function allTests($communicator)
     //test(!$b1->ice_isCollocationOptimized());
     //$communicator->getProperties()->setProperty($property, "");
 
+    $property = $propertyPrefix . ".EncodingVersion";
+    test($b1->ice_getEncodingVersion() == Ice_currentEncoding());
+    $communicator->getProperties()->setProperty($property, "1.0");
+    $b1 = $communicator->propertyToProxy($propertyPrefix);
+    test($b1->ice_getEncodingVersion()->major == 1 && $b1->ice_getEncodingVersion()->minor == 0);
+    $communicator->getProperties()->setProperty($property, "6.5");
+    try
+    {
+        $communicator->propertyToProxy($propertyPrefix);
+        test(false);
+    }
+    catch(Exception $ex)
+    {
+        $cls = $NS ? "Ice\\UnsupportedEncodingException" : "Ice_UnsupportedEncodingException";
+        if(!($ex instanceof $cls))
+        {
+            throw $ex;
+        }
+    }
+
+    $communicator->getProperties()->setProperty($property, "1.2");
+    try
+    {
+        $communicator->propertyToProxy($propertyPrefix);
+        test(false);
+    }
+    catch(Exception $ex)
+    {
+        $cls = $NS ? "Ice\\UnsupportedEncodingException" : "Ice_UnsupportedEncodingException";
+        if(!($ex instanceof $cls))
+        {
+            throw $ex;
+        }
+    }
+    $communicator->getProperties()->setProperty($property, "");
+
     echo "ok\n";
 
     echo "testing proxyToProperty... ";
@@ -379,6 +418,7 @@ function allTests($communicator)
     $b1 = $b1->ice_preferSecure(false);
     $b1 = $b1->ice_endpointSelection($ordered);
     $b1 = $b1->ice_locatorCacheTimeout(100);
+    $b1 = $b1->ice_encodingVersion(eval("return new " . $encodingVersion . "(1, 0);"));
 
     $router = $communicator->stringToProxy("router");
     //$router = $router->ice_collocationOptimized(false);
@@ -398,10 +438,11 @@ function allTests($communicator)
     $b1 = $b1->ice_locator($locator->ice_uncheckedCast("::Ice::Locator"));
 
     $proxyProps = $communicator->proxyToProperty($b1, "Test");
-    test(count($proxyProps) == 18);
+    test(count($proxyProps) == 21);
 
     test($proxyProps["Test"] == "test -t");
     //test($proxyProps["Test.CollocationOptimized"] == "1");
+    test($proxyProps["Test.EncodingVersion"] == "1.0");
     test($proxyProps["Test.ConnectionCached"] == "1");
     test($proxyProps["Test.PreferSecure"] == "0");
     test($proxyProps["Test.EndpointSelection"] == "Ordered");
@@ -409,6 +450,7 @@ function allTests($communicator)
 
     test($proxyProps["Test.Locator"] == "locator -t");
     //test($proxyProps["Test.Locator.CollocationOptimized"] == "1");
+    test($proxyProps["Test.Locator.EncodingVersion"] == Ice_encodingVersionToString(Ice_currentEncoding()));
     test($proxyProps["Test.Locator.ConnectionCached"] == "0");
     test($proxyProps["Test.Locator.PreferSecure"] == "1");
     test($proxyProps["Test.Locator.EndpointSelection"] == "Random");
@@ -416,11 +458,31 @@ function allTests($communicator)
 
     test($proxyProps["Test.Locator.Router"] == "router -t");
     //test($proxyProps["Test.Locator.Router.CollocationOptimized"] == "0");
+    test($proxyProps["Test.Locator.Router.EncodingVersion"] == Ice_encodingVersionToString(Ice_currentEncoding()));
     test($proxyProps["Test.Locator.Router.ConnectionCached"] == "1");
     test($proxyProps["Test.Locator.Router.PreferSecure"] == "1");
     test($proxyProps["Test.Locator.Router.EndpointSelection"] == "Random");
     test($proxyProps["Test.Locator.Router.LocatorCacheTimeout"] == "200");
 
+    try
+    {
+        $b1->ice_encodingVersion(eval("return new " . $encodingVersion . "(3, 4);"));
+        test(false);
+    }
+    catch(Exception $ex)
+    {
+        $cls = $NS ? "Ice\\UnsupportedEncodingException" : "Ice_UnsupportedEncodingException";
+        if(!($ex instanceof $cls))
+        {
+            throw $ex;
+        }
+    }
+
+    echo "ok\n";
+
+    echo "testing ice_getCommunicator... ";
+    flush();
+    test($base->ice_getCommunicator() === $communicator);
     echo "ok\n";
 
     echo "testing proxy methods... ";
@@ -435,16 +497,16 @@ function allTests($communicator)
     test($base->ice_batchDatagram()->ice_isBatchDatagram());
     test($base->ice_secure(true)->ice_isSecure());
     test(!$base->ice_secure(false)->ice_isSecure());
+    test($base->ice_preferSecure(true)->ice_isPreferSecure());
+    test(!$base->ice_preferSecure(false)->ice_isPreferSecure());
     test($base->ice_connectionId("id1")->ice_getConnectionId() == "id1");
     test($base->ice_connectionId("id2")->ice_getConnectionId() == "id2");
+    test($base->ice_encodingVersion($Ice_Encoding_1_0)->ice_getEncodingVersion() == $Ice_Encoding_1_0);
+    test($base->ice_encodingVersion($Ice_Encoding_1_1)->ice_getEncodingVersion() == $Ice_Encoding_1_1);
+    test($base->ice_encodingVersion($Ice_Encoding_1_0)->ice_getEncodingVersion() != $Ice_Encoding_1_1);
 
     echo "ok\n";
 
-    echo "testing ice_getCommunicator... ";
-    flush();
-    test($base->ice_getCommunicator() === $communicator);
-    echo "ok\n";
-
     echo "testing checked cast... ";
     flush();
     $cl = $base->ice_checkedCast("::Test::MyClass");
@@ -637,11 +699,19 @@ function allTests($communicator)
         }
     }
 
-    // Legal TCP endpoint expressed as opaque endpoint
-    $p1 = $communicator->stringToProxy("test:opaque -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==");
+    // Legal TCP endpoint expressed as opaque endpoint.
+    $p1 = $communicator->stringToProxy("test:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==");
     $pstr = $communicator->proxyToString($p1);
     test($pstr == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000");
     
+    // 1.1 TCP endpoint encoded with 1.1 encoding.
+    $p2 = $communicator->stringToProxy("test:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAAEAAQE=");
+    test($communicator->proxyToString($p2) == "test -t:tcp -e 1.1 -h 127.0.0.1 -p 12010 -t 10000");
+
+    // 1.0 TCP endpoint encoded with 1.1 encoding.
+    $p2 = $communicator->stringToProxy("test: opaque -t 1 -e 1.1 -v CTEyNy4wLjAuMeouAAAQJwAAAAEAAQA=");
+    test($communicator->proxyToString($p2) == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000");
+
     // Working?
     if($communicator->getProperties()->getProperty("Ice.IPv6") == "" ||
        $communicator->getProperties()->getProperty("Ice.IPv6") == "0")
@@ -649,11 +719,11 @@ function allTests($communicator)
         $ssl = $communicator->getProperties()->getProperty("Ice.Default.Protocol") == "ssl";
         if(!$ssl)
         {
-            $p1->ice_ping();
+            $p1->ice_encodingVersion($Ice_Encoding_1_0)->ice_ping();
         }
 
         // Two legal TCP endpoints expressed as opaque endpoints
-        $p1 = $communicator->stringToProxy("test:opaque -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA==");
+        $p1 = $communicator->stringToProxy("test:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMusuAAAQJwAAAA==");
         $pstr = $communicator->proxyToString($p1);
         test($pstr == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000");
 
@@ -661,11 +731,11 @@ function allTests($communicator)
         // Test that an SSL endpoint and a nonsense endpoint get written
         // back out as an opaque endpoint.
         //
-        $p1 = $communicator->stringToProxy("test:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch");
+        $p1 = $communicator->stringToProxy("test:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch");
         $pstr = $communicator->proxyToString($p1);
         if(!$ssl)
         {
-            test($pstr == "test -t:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch");
+            test($pstr == "test -t:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch");
         }
         else
         {
@@ -679,7 +749,7 @@ function allTests($communicator)
         //
         try
         {
-            $p1->ice_ping();
+            $p1->ice_encodingVersion($Ice_Encoding_1_0)->ice_ping();
             test(false);
         }
         catch(Exception $ex)
@@ -710,11 +780,11 @@ function allTests($communicator)
         $pstr = $communicator->proxyToString($p2);
         if(!$ssl)
         {
-            test($pstr == "test -t:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch");
+            test($pstr == "test -t:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch");
         }
         else
         {
-            test($pstr == "test -t:ssl -h 127.0.0.1 -p 10001:opaque -t 99 -v abch");
+            test($pstr == "test -t:ssl -h 127.0.0.1 -p 10001:opaque -t 99 -e 1.0 -v abch");
         }
     }
     echo "ok\n";
diff --git a/php/test/Ice/slicing/exceptions/Client.php b/php/test/Ice/slicing/exceptions/Client.php
index ff114ac5b20..5646e7b4c78 100644
--- a/php/test/Ice/slicing/exceptions/Client.php
+++ b/php/test/Ice/slicing/exceptions/Client.php
@@ -23,11 +23,12 @@ function test($b)
 function allTests($communicator)
 {
     global $NS;
+    global $Ice_Encoding_1_0;
 
     $obj = $communicator->stringToProxy("Test:default -p 12010");
     $test = $obj->ice_checkedCast("::Test::TestIntf");
 
-    echo "testing throwing a base exception... ";
+    echo "base... ";
     flush();
     {
         try
@@ -40,7 +41,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\Base" : "Test_Base";
             if(!($b instanceof $excls))
             {
-                throw $ex;
+                throw $b;
             }
             test($b->b == "Base.b");
             test(get_class($b) == ($NS ? "Test\\Base" : "Test_Base"));
@@ -48,7 +49,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of unknown derived exception... ";
+    echo "unknown derived... ";
     flush();
     {
         try
@@ -61,7 +62,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\Base" : "Test_Base";
             if(!($b instanceof $excls))
             {
-                throw $ex;
+                throw $b;
             }
             test($b->b == "UnknownDerived.b");
             test(get_class($b) == ($NS ? "Test\\Base" : "Test_Base"));
@@ -69,7 +70,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing non-slicing of known derived exception thrown as base exception... ";
+    echo "non-slicing of known derived as base... ";
     flush();
     {
         try
@@ -82,7 +83,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownDerived" : "Test_KnownDerived";
             if(!($k instanceof $excls))
             {
-                throw $ex;
+                throw $k;
             }
             test($k->b == "KnownDerived.b");
             test($k->kd == "KnownDerived.kd");
@@ -91,7 +92,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing non-slicing of known derived exception thrown as derived exception... ";
+    echo "non-slicing of known derived as derived... ";
     flush();
     {
         try
@@ -104,7 +105,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownDerived" : "Test_KnownDerived";
             if(!($k instanceof $excls))
             {
-                throw $ex;
+                throw $k;
             }
             test($k->b == "KnownDerived.b");
             test($k->kd == "KnownDerived.kd");
@@ -113,7 +114,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of unknown intermediate exception thrown as base exception... ";
+    echo "slicing of unknown intermediate as base... ";
     flush();
     {
         try
@@ -126,7 +127,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\Base" : "Test_Base";
             if(!($b instanceof $excls))
             {
-                throw $ex;
+                throw $b;
             }
             test($b->b == "UnknownIntermediate.b");
             test(get_class($b) == ($NS ? "Test\\Base" : "Test_Base"));
@@ -134,7 +135,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of known intermediate exception thrown as base exception... ";
+    echo "slicing of known intermediate as base... ";
     flush();
     {
         try
@@ -147,7 +148,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownIntermediate" : "Test_KnownIntermediate";
             if(!($ki instanceof $excls))
             {
-                throw $ex;
+                throw $ki;
             }
             test($ki->b == "KnownIntermediate.b");
             test($ki->ki == "KnownIntermediate.ki");
@@ -156,7 +157,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of known most derived exception thrown as base exception... ";
+    echo "slicing of known most derived as base... ";
     flush();
     {
         try
@@ -169,7 +170,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownMostDerived" : "Test_KnownMostDerived";
             if(!($kmd instanceof $excls))
             {
-                throw $ex;
+                throw $kmd;
             }
             test($kmd->b == "KnownMostDerived.b");
             test($kmd->ki == "KnownMostDerived.ki");
@@ -179,7 +180,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing non-slicing of known intermediate exception thrown as intermediate exception... ";
+    echo "non-slicing of known intermediate as intermediate... ";
     flush();
     {
         try
@@ -192,7 +193,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownIntermediate" : "Test_KnownIntermediate";
             if(!($ki instanceof $excls))
             {
-                throw $ex;
+                throw $ki;
             }
             test($ki->b == "KnownIntermediate.b");
             test($ki->ki == "KnownIntermediate.ki");
@@ -201,7 +202,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing non-slicing of known most derived thrown as intermediate exception... ";
+    echo "non-slicing of known most derived as intermediate... ";
     flush();
     {
         try
@@ -214,7 +215,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownMostDerived" : "Test_KnownMostDerived";
             if(!($kmd instanceof $excls))
             {
-                throw $ex;
+                throw $kmd;
             }
             test($kmd->b == "KnownMostDerived.b");
             test($kmd->ki == "KnownMostDerived.ki");
@@ -224,7 +225,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing non-slicing of known most derived thrown as most derived exception... ";
+    echo "non-slicing of known most derived as most derived... ";
     flush();
     {
         try
@@ -237,7 +238,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownMostDerived" : "Test_KnownMostDerived";
             if(!($kmd instanceof $excls))
             {
-                throw $ex;
+                throw $kmd;
             }
             test($kmd->b == "KnownMostDerived.b");
             test($kmd->ki == "KnownMostDerived.ki");
@@ -247,7 +248,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of unknown most derived with known intermediate thrown as base exception... ";
+    echo "slicing of unknown most derived, known intermediate as base... ";
     flush();
     {
         try
@@ -260,7 +261,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownIntermediate" : "Test_KnownIntermediate";
             if(!($ki instanceof $excls))
             {
-                throw $ex;
+                throw $ki;
             }
             test($ki->b == "UnknownMostDerived1.b");
             test($ki->ki == "UnknownMostDerived1.ki");
@@ -269,7 +270,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of unknown most derived with known intermediate thrown as intermediate exception... ";
+    echo "slicing of unknown most derived, known intermediate as intermediate... ";
     flush();
     {
         try
@@ -282,7 +283,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\KnownIntermediate" : "Test_KnownIntermediate";
             if(!($ki instanceof $excls))
             {
-                throw $ex;
+                throw $ki;
             }
             test($ki->b == "UnknownMostDerived1.b");
             test($ki->ki == "UnknownMostDerived1.ki");
@@ -291,7 +292,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing slicing of unknown most derived with unknown intermediate thrown as base exception... ";
+    echo "slicing of unknown most derived, unknown intermediate as base... ";
     flush();
     {
         try
@@ -304,7 +305,7 @@ function allTests($communicator)
             $excls = $NS ? "Test\\Base" : "Test_Base";
             if(!($b instanceof $excls))
             {
-                throw $ex;
+                throw $b;
             }
             test($b->b == "UnknownMostDerived2.b");
             test(get_class($b) == ($NS ? "Test\\Base" : "Test_Base"));
@@ -312,6 +313,114 @@ function allTests($communicator)
     }
     echo "ok\n";
 
+    echo "unknown most derived in compact format... ";
+    flush();
+    {
+        try
+        {
+            $test->unknownMostDerived2AsBaseCompact();
+            test(false);
+        }
+        catch(Exception $b)
+        {
+            $excls = $NS ? "Test\\Base" : "Test_Base";
+            if(($b instanceof $excls))
+            if(get_class($b) == ($NS ? "Test\\Base" : "Test_Base"))
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to Base.
+                //
+                test($test->ice_getEncodingVersion() == $Ice_Encoding_1_0);
+            }
+            else if(get_class($b) == ($NS ? "Ice\\MarshalException" : "Ice_MarshalException"))
+            {
+                //
+                // A MarshalException is raised for the compact format because the
+                // most-derived type is unknown and the exception cannot be sliced.
+                //
+                test($test->ice_getEncodingVersion() != $Ice_Encoding_1_0);
+            }
+            else
+            {
+                throw $b;
+            }
+        }
+    }
+    echo "ok\n";
+
+    echo "preserved exceptions... ";
+    flush();
+    {
+        try
+        {
+            $test->knownPreservedAsBase();
+            test(false);
+        }
+        catch(Exception $b)
+        {
+            $excls = $NS ? "Test\\KnownPreservedDerived" : "Test_KnownPreservedDerived";
+            if(!($b instanceof $excls))
+            {
+                throw $b;
+            }
+            test($b->b == "base");
+            test($b->kp == "preserved");
+            test($b->kpd == "derived");
+        }
+
+        try
+        {
+            $test->knownPreservedAsKnownPreserved();
+            test(false);
+        }
+        catch(Exception $b)
+        {
+            $excls = $NS ? "Test\\KnownPreservedDerived" : "Test_KnownPreservedDerived";
+            if(!($b instanceof $excls))
+            {
+                throw $b;
+            }
+            test($b->b == "base");
+            test($b->kp == "preserved");
+            test($b->kpd == "derived");
+        }
+
+        try
+        {
+            $test->unknownPreservedAsBase();
+            test(false);
+        }
+        catch(Exception $b)
+        {
+            $excls = $NS ? "Test\\KnownPreservedDerived" : "Test_KnownPreservedDerived";
+            if(!($b instanceof $excls))
+            {
+                throw $b;
+            }
+            test($b->b == "base");
+            test($b->kp == "preserved");
+            test($b->kpd == "derived");
+        }
+
+        try
+        {
+            $test->unknownPreservedAsKnownPreserved();
+            test(false);
+        }
+        catch(Exception $b)
+        {
+            $excls = $NS ? "Test\\KnownPreservedDerived" : "Test_KnownPreservedDerived";
+            if(!($b instanceof $excls))
+            {
+                throw $b;
+            }
+            test($b->b == "base");
+            test($b->kp == "preserved");
+            test($b->kpd == "derived");
+        }
+    }
+    echo "ok\n";
+
     return $test;
 }
 
diff --git a/php/test/Ice/slicing/exceptions/Test.ice b/php/test/Ice/slicing/exceptions/Test.ice
index 1c92fe0fbcf..e558935d440 100644
--- a/php/test/Ice/slicing/exceptions/Test.ice
+++ b/php/test/Ice/slicing/exceptions/Test.ice
@@ -32,7 +32,35 @@ exception KnownMostDerived extends KnownIntermediate
     string kmd;
 };
 
-["ami"] interface TestIntf
+["preserve-slice"]
+exception KnownPreserved extends Base
+{
+    string kp;
+};
+
+exception KnownPreservedDerived extends KnownPreserved
+{
+    string kpd;
+};
+
+["preserve-slice"]
+class BaseClass
+{
+    string bc;
+};
+
+["format:sliced"]
+interface Relay
+{
+    void knownPreservedAsBase() throws Base;
+    void knownPreservedAsKnownPreserved() throws KnownPreserved;
+
+    void unknownPreservedAsBase() throws Base;
+    void unknownPreservedAsKnownPreserved() throws KnownPreserved;
+};
+
+["format:sliced"]
+interface TestIntf
 {
     void baseAsBase() throws Base;
     void unknownDerivedAsBase() throws Base;
@@ -50,6 +78,20 @@ exception KnownMostDerived extends KnownIntermediate
     void unknownMostDerived1AsKnownIntermediate() throws KnownIntermediate;
     void unknownMostDerived2AsBase() throws Base;
 
+    ["format:compact"] void unknownMostDerived2AsBaseCompact() throws Base;
+
+    void knownPreservedAsBase() throws Base;
+    void knownPreservedAsKnownPreserved() throws KnownPreserved;
+
+    void relayKnownPreservedAsBase(Relay* r) throws Base;
+    void relayKnownPreservedAsKnownPreserved(Relay* r) throws KnownPreserved;
+
+    void unknownPreservedAsBase() throws Base;
+    void unknownPreservedAsKnownPreserved() throws KnownPreserved;
+
+    void relayUnknownPreservedAsBase(Relay* r) throws Base;
+    void relayUnknownPreservedAsKnownPreserved(Relay* r) throws KnownPreserved;
+
     void shutdown();
 };
 
diff --git a/php/test/Ice/slicing/exceptions/run.py b/php/test/Ice/slicing/exceptions/run.py
index 286dd895700..9fde25714bd 100755
--- a/php/test/Ice/slicing/exceptions/run.py
+++ b/php/test/Ice/slicing/exceptions/run.py
@@ -20,4 +20,7 @@ if len(path) == 0:
 sys.path.append(os.path.join(path[0], "scripts"))
 import TestUtil
 
+print("Running test with sliced format.")
 TestUtil.clientServerTest()
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/php/test/Ice/slicing/objects/Client.php b/php/test/Ice/slicing/objects/Client.php
index 55d5ac1ad6e..e57f3b44269 100644
--- a/php/test/Ice/slicing/objects/Client.php
+++ b/php/test/Ice/slicing/objects/Client.php
@@ -24,6 +24,7 @@ function test($b)
 function allTests($communicator)
 {
     global $NS;
+    global $Ice_Encoding_1_0;
 
     $d1cls = $NS ? "Test\\D1" : "Test_D1";
     $d3cls = $NS ? "Test\\D3" : "Test_D3";
@@ -31,7 +32,7 @@ function allTests($communicator)
     $obj = $communicator->stringToProxy("Test:default -p 12010");
     $test = $obj->ice_checkedCast("::Test::TestIntf");
 
-    echo "testing base as Object... ";
+    echo "base as Object... ";
     flush();
     {
         $o = $test->SBaseAsObject();
@@ -41,7 +42,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing base as base... ";
+    echo "base as base... ";
     flush();
     {
         $o = $test->SBaseAsSBase();
@@ -49,7 +50,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing base with known derived as base... ";
+    echo "base with known derived as base... ";
     flush();
     {
         $sb = $test->SBSKnownDerivedAsSBase();
@@ -59,7 +60,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing base with known derived as known derived... ";
+    echo "base with known derived as known derived... ";
     flush();
     {
         $sbksd = $test->SBSKnownDerivedAsSBSKnownDerived();
@@ -67,15 +68,46 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing base with unknown derived as base... ";
+    echo "base with unknown derived as base... ";
     flush();
     {
         $sb = $test->SBSUnknownDerivedAsSBase();
         test($sb->sb == "SBSUnknownDerived.sb");
     }
+    if($test->ice_getEncodingVersion() == $Ice_Encoding_1_0)
+    {
+        try
+        {
+            //
+            // This test succeeds for the 1.0 encoding.
+            //
+            $sb = $test->SBSUnknownDerivedAsSBaseCompact();
+            test($sb->sb == "SBSUnknownDerived.sb");
+        }
+        catch(Exception $ex)
+        {
+            test(false);
+        }
+    }
+    else
+    {
+        try
+        {
+            //
+            // This test fails when using the compact format because the instance cannot
+            // be sliced to a known type.
+            //
+            $sb = $test->SBSUnknownDerivedAsSBaseCompact();
+            test(false);
+        }
+        catch(Exception $ex)
+        {
+            test(get_class($ex) == ($NS ? "Ice\\MarshalException" : "Ice_MarshalException"));
+        }
+    }
     echo "ok\n";
 
-    echo "testing unknown with Object as Object... ";
+    echo "unknown with Object as Object... ";
     flush();
     {
         try
@@ -94,7 +126,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing one-element cycle... ";
+    echo "one-element cycle... ";
     flush();
     {
         $b = $test->oneElementCycle();
@@ -110,7 +142,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing two-element cycle... ";
+    echo "two-element cycle... ";
     flush();
     {
         $b1 = $test->twoElementCycle();
@@ -131,7 +163,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing known derived pointer slicing as base... ";
+    echo "known derived pointer slicing as base... ";
     flush();
     {
         $b1 = $test->D1AsB();
@@ -159,7 +191,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing known derived pointer slicing as derived... ";
+    echo "known derived pointer slicing as derived... ";
     flush();
     {
         $d1 = $test->D1AsD1();
@@ -182,7 +214,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing unknown derived pointer slicing as base... ";
+    echo "unknown derived pointer slicing as base... ";
     flush();
     {
         $b2 = $test->D2AsB();
@@ -210,7 +242,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing parameter pointer slicing with known first... ";
+    echo "parameter pointer slicing with known first... ";
     flush();
     {
         $test->paramTest1($b1, $b2);
@@ -236,7 +268,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing parameter pointer slicing with unknown first... ";
+    echo "parameter pointer slicing with unknown first... ";
     flush();
     {
         $test->paramTest2($b2, $b1);
@@ -262,7 +294,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing return value identity with known first... ";
+    echo "return value identity with known first... ";
     flush();
     {
         $r = $test->returnTest1($p1, $p2);
@@ -275,7 +307,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing return value identity with unknown first... ";
+    echo "return value identity with unknown first... ";
     flush();
     {
         $r = $test->returnTest2($p1, $p2);
@@ -288,7 +320,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing return value identity for input params known first... ";
+    echo "return value identity for input params known first... ";
     flush();
     {
         $d1 = $NS ? eval("return new Test\\D1;") : eval("return new Test_D1;");
@@ -334,7 +366,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing return value identity for input params unknown first... ";
+    echo "return value identity for input params unknown first... ";
     flush();
     {
         $d1 = $NS ? eval("return new Test\\D1;") : eval("return new Test_D1;");
@@ -380,7 +412,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing return value identity for input params unknown first... ";
+    echo "return value identity for input params unknown first... ";
     flush();
     {
         $d1 = $NS ? eval("return new Test\\D1;") : eval("return new Test_D1;");
@@ -428,7 +460,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing remainder unmarshaling (3 instances)... ";
+    echo "remainder unmarshaling (3 instances)... ";
     flush();
     {
         $ret = $test->paramTest3($p1, $p2);
@@ -450,7 +482,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing remainder unmarshaling (4 instances)... ";
+    echo "remainder unmarshaling (4 instances)... ";
     flush();
     {
         $ret = $test->paramTest4($b);
@@ -467,7 +499,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing parameter pointer slicing with first instance marshaled in unknown derived as base... ";
+    echo "parameter pointer slicing with first instance marshaled in unknown derived as base... ";
     flush();
     {
         $b1 = $NS ? eval("return new Test\\B;") : eval("return new Test_B;");
@@ -501,7 +533,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing parameter pointer slicing with first instance marshaled in unknown derived as derived... ";
+    echo "parameter pointer slicing with first instance marshaled in unknown derived as derived... ";
     flush();
     {
         $d11 = $NS ? eval("return new Test\\D1;") : eval("return new Test_D1;");
@@ -540,7 +572,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing sequence slicing... ";
+    echo "sequence slicing... ";
     flush();
     {
         $ss = null;
@@ -632,7 +664,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing dictionary slicing... ";
+    echo "dictionary slicing... ";
     flush();
     {
         $bin = array();
@@ -695,7 +727,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing base exception thrown as base exception... ";
+    echo "base exception thrown as base exception... ";
     flush();
     {
         try
@@ -724,7 +756,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing derived exception thrown as base exception... ";
+    echo "derived exception thrown as base exception... ";
     flush();
     {
         try
@@ -761,7 +793,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing derived exception thrown as derived exception... ";
+    echo "derived exception thrown as derived exception... ";
     flush();
     {
         try
@@ -798,7 +830,7 @@ function allTests($communicator)
     }
     echo "ok\n";
 
-    echo "testing unknown derived exception thrown as base exception... ";
+    echo "unknown derived exception thrown as base exception... ";
     flush();
     {
         try
@@ -827,6 +859,173 @@ function allTests($communicator)
     }
     echo "ok\n";
 
+    echo "forward-declared class... ";
+    flush();
+    {
+        try
+        {
+            $f = null;
+            $test->useForward($f);
+            test($f != null);
+        }
+        catch(Exception $e)
+        {
+            test(false);
+        }
+    }
+    echo "ok\n";
+
+    echo "preserved classes... ";
+    flush();
+    {
+        //
+        // Server knows the most-derived class PDerived.
+        //
+        $pd = $NS ? eval("return new Test\\PDerived;") : eval("return new Test_PDerived;");
+        $pd->pi = 3;
+        $pd->ps = "preserved";
+        $pd->pb = $pd;
+
+        $r = $test->exchangePBase($pd);
+        test(get_class($r) == ($NS ? "Test\\PDerived" : "Test_PDerived"));
+        test($r->pi == 3);
+        test($r->ps == "preserved");
+        test($r->pb === $r); // Object identity comparison
+
+        //
+        // Server only knows the base (non-preserved) type, so the object is sliced.
+        //
+        $pu = $NS ? eval("return new Test\\PCUnknown;") : eval("return new Test_PCUnknown;");
+        $pu->pi = 3;
+        $pu->pu = "preserved";
+
+        $r = $test->exchangePBase($pu);
+        test(get_class($r) != ($NS ? "Test\\PCUnknown" : "Test_PCUnknown"));
+        test($r->pi == 3);
+
+        //
+        // Server only knows the intermediate type Preserved. The object will be sliced to
+        // Preserved for the 1.0 encoding; otherwise it should be returned intact.
+        //
+        $pcd = $NS ? eval("return new Test\\PCDerived;") : eval("return new Test_PCDerived;");
+        $pcd->pi = 3;
+        $pcd->pbs = array($pcd);
+
+        $r = $test->exchangePBase($pcd);
+        if($test->ice_getEncodingVersion() == $Ice_Encoding_1_0)
+        {
+            test(get_class($r) != ($NS ? "Test\\PCDerived" : "Test_PCDerived"));
+            test($r->pi == 3);
+        }
+        else
+        {
+            test(get_class($r) == ($NS ? "Test\\PCDerived" : "Test_PCDerived"));
+            test($r->pi == 3);
+            test($r->pbs[0] === $r); // Object identity comparison
+        }
+
+        //
+        // Send an object that will have multiple preserved slices in the server.
+        // The object will be sliced to Preserved for the 1.0 encoding.
+        //
+        $pcd = $NS ? eval("return new Test\\PCDerived3;") : eval("return new Test_PCDerived3;");
+        $pcd->pi = 3;
+        //
+        // Sending more than 254 objects exercises the encoding for object ids.
+        //
+        $pcd->pbs = array();
+        for($i = 0; $i < 300; ++$i)
+        {
+            $p2 = $NS ? eval("return new Test\\PCDerived2;") : eval("return new Test_PCDerived2;");
+            $p2->pi = $i;
+            $p2->pbs = array(null); // Nil reference. This slice should not have an indirection table.
+            $p2->pcd2 = $i;
+            array_push($pcd->pbs, $p2);
+        }
+        $pcd->pcd2 = $pcd->pi;
+        $pcd->pcd3 = $pcd->pbs[10];
+
+        $r = $test->exchangePBase($pcd);
+        if($test->ice_getEncodingVersion() == $Ice_Encoding_1_0)
+        {
+            test(get_class($r) != ($NS ? "Test\\PCDerived3" : "Test_PCDerived3"));
+            test(get_class($r) == ($NS ? "Test\\PDerived" : "Test_PDerived"));
+            test($r->pi == 3);
+        }
+        else
+        {
+            test(get_class($r) == ($NS ? "Test\\PCDerived3" : "Test_PCDerived3"));
+            test($r->pi == 3);
+            for($i = 0; $i < 300; ++$i)
+            {
+                $p2 = $r->pbs[$i];
+                test(get_class($p2) == ($NS ? "Test\\PCDerived2" : "Test_PCDerived2"));
+                test($p2->pi == $i);
+                test(count($p2->pbs) == 1);
+                test($p2->pbs[0] == null);
+                test($p2->pcd2 == $i);
+            }
+            test($r->pcd2 == $r->pi);
+            test($r->pcd3 === $r->pbs[10]); // Object identity comparison
+        }
+
+        //
+        // Obtain an object with preserved slices and send it back to the server.
+        // The preserved slices should be excluded for the 1.0 encoding, otherwise
+        // they should be included.
+        //
+        $p = $test->PBSUnknownAsPreserved();
+        $test->checkPBSUnknown($p);
+        if($test->ice_getEncodingVersion() != $Ice_Encoding_1_0)
+        {
+            $test->ice_encodingVersion($Ice_Encoding_1_0)->checkPBSUnknown($p);
+        }
+
+        //
+        // Relay a graph through the server. This test uses a preserved class
+        // with a class member.
+        //
+        $c = $NS ? eval("return new Test\\PNode;") : eval("return new Test_PNode;");
+        $c->next = $NS ? eval("return new Test\\PNode;") : eval("return new Test_PNode;");
+        $c->next->next = $NS ? eval("return new Test\\PNode;") : eval("return new Test_PNode;");
+        $c->next->next->next = $c;    // Create a cyclic graph.
+
+        $n = $test->exchangePNode($c);
+        test($n->next != null);
+        test($n->next !== $n->next->next); // Object identity comparison
+        test($n->next->next !== $n->next->next->next); // Object identity comparison
+        test($n->next->next->next === $n); // Object identity comparison
+        $n = null;      // Release reference.
+
+        //
+        // Obtain a preserved object from the server where the most-derived
+        // type is unknown. The preserved slice refers to a graph of PNode
+        // objects.
+        //
+        $p = $test->PBSUnknownAsPreservedWithGraph();
+        test($p != null);
+        $test->checkPBSUnknownWithGraph($p);
+        $p = null;      // Release reference.
+
+        //
+        // Obtain a preserved object from the server where the most-derived
+        // type is unknown. A data member in the preserved slice refers to the
+        // outer object, so the chain of references looks like this:
+        //
+        // outer->slicedData->outer
+        //
+        $p = $test->PBSUnknown2AsPreservedWithGraph();
+        test($p != null);
+        if($test->ice_getEncodingVersion() != $Ice_Encoding_1_0)
+        {
+            test($p->_ice_slicedData != null);
+        }
+        $test->checkPBSUnknown2WithGraph($p);
+        $p->_ice_slicedData = null;     // Break the cycle.
+        $p = null;                      // Release reference.
+    }
+    echo "ok\n";
+
     return $test;
 }
 
diff --git a/php/test/Ice/slicing/objects/ClientPrivate.ice b/php/test/Ice/slicing/objects/ClientPrivate.ice
index b4e22a0d495..f8708d424c3 100644
--- a/php/test/Ice/slicing/objects/ClientPrivate.ice
+++ b/php/test/Ice/slicing/objects/ClientPrivate.ice
@@ -20,4 +20,25 @@ class D3 extends B
     B pd3;
 };
 
+["preserve-slice"]
+class PCUnknown extends PBase
+{
+    string pu;
+};
+
+class PCDerived extends PDerived
+{
+    PBaseSeq pbs;
+};
+
+class PCDerived2 extends PCDerived
+{
+    int pcd2;
+};
+
+class PCDerived3 extends PCDerived2
+{
+    Object pcd3;
+};
+
 };
diff --git a/php/test/Ice/slicing/objects/Test.ice b/php/test/Ice/slicing/objects/Test.ice
index 509a6544f25..8e20db55def 100644
--- a/php/test/Ice/slicing/objects/Test.ice
+++ b/php/test/Ice/slicing/objects/Test.ice
@@ -46,7 +46,7 @@ class SS2
     BSeq s;
 };
 
-struct SS
+struct SS3
 {
     SS1 c1;
     SS2 c2;
@@ -66,9 +66,39 @@ exception DerivedException extends BaseException
     D1 pd1;
 };
 
-class Forward;          // Forward-declared class defined in another compilation unit
+class Forward;          /* Forward-declared class defined in another compilation unit */
 
-["ami"] interface TestIntf
+class PBase
+{
+    int pi;
+};
+
+sequence<PBase> PBaseSeq;
+
+["preserve-slice"]
+class Preserved extends PBase
+{
+    string ps;
+};
+
+class PDerived extends Preserved
+{
+    PBase pb;
+};
+
+["preserve-slice"]
+class PNode
+{
+    PNode next;
+};
+
+["preserve-slice"]
+exception PreservedException
+{
+};
+
+["format:sliced"]
+interface TestIntf
 {
     Object SBaseAsObject();
     SBase SBaseAsSBase();
@@ -77,6 +107,8 @@ class Forward;          // Forward-declared class defined in another compilation
 
     SBase SBSUnknownDerivedAsSBase();
 
+    ["format:compact"] SBase SBSUnknownDerivedAsSBaseCompact();
+
     Object SUnknownAsObject();
 
     B oneElementCycle();
@@ -94,14 +126,28 @@ class Forward;          // Forward-declared class defined in another compilation
     B returnTest2(out B p2, out B p1);
     B returnTest3(B p1, B p2);
 
-    SS sequenceTest(SS1 p1, SS2 p2);
+    SS3 sequenceTest(SS1 p1, SS2 p2);
 
     BDict dictionaryTest(BDict bin, out BDict bout);
 
+    PBase exchangePBase(PBase pb);
+
+    Preserved PBSUnknownAsPreserved();
+    void checkPBSUnknown(Preserved p);
+
+    ["amd"] Preserved PBSUnknownAsPreservedWithGraph();
+    void checkPBSUnknownWithGraph(Preserved p);
+
+    ["amd"] Preserved PBSUnknown2AsPreservedWithGraph();
+    void checkPBSUnknown2WithGraph(Preserved p);
+
+    PNode exchangePNode(PNode pn);
+
     void throwBaseAsBase() throws BaseException;
     void throwDerivedAsBase() throws BaseException;
     void throwDerivedAsDerived() throws DerivedException;
     void throwUnknownDerivedAsBase() throws BaseException;
+    ["amd"] void throwPreservedException() throws PreservedException;
 
     void useForward(out Forward f); /* Use of forward-declared class to verify that code is generated correctly. */
 
diff --git a/php/test/Ice/slicing/objects/run.py b/php/test/Ice/slicing/objects/run.py
index 286dd895700..9fde25714bd 100755
--- a/php/test/Ice/slicing/objects/run.py
+++ b/php/test/Ice/slicing/objects/run.py
@@ -20,4 +20,7 @@ if len(path) == 0:
 sys.path.append(os.path.join(path[0], "scripts"))
 import TestUtil
 
+print("Running test with sliced format.")
 TestUtil.clientServerTest()
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/php/test/Slice/structure/Client.php b/php/test/Slice/structure/Client.php
index 51c72baa3e3..d0c37f10e0a 100644
--- a/php/test/Slice/structure/Client.php
+++ b/php/test/Slice/structure/Client.php
@@ -40,9 +40,9 @@ function allTests($communicator)
     // Define some default values.
     //
     $def_s2 = $NS ?
-        eval("new Test\\S2(true, 98, 99, 100, 101, 1.0, 2.0, \"string\", array(\"one\", \"two\", \"three\"),
-                           array(\"abc\" => \"def\"), new Test\\S1(\"name\"), new Test\\C(5),
-                           $communicator->stringToProxy(\"test\"));") :
+        eval("return new Test\\S2(true, 98, 99, 100, 101, 1.0, 2.0, \"string\", array(\"one\", \"two\", \"three\"),
+                                  array(\"abc\" => \"def\"), new Test\\S1(\"name\"), new Test\\C(5),
+                                  \$communicator->stringToProxy(\"test\"));") :
         new Test_S2(true, 98, 99, 100, 101, 1.0, 2.0, "string", array("one", "two", "three"),
                     array("abc" => "def"), new Test_S1("name"), new Test_C(5),
                     $communicator->stringToProxy("test"));
@@ -50,7 +50,7 @@ function allTests($communicator)
     //
     // Compare default-constructed structures.
     //
-    test($NS ? eval("new Test\\S2 == new Test\\S2;") : new Test_S2 == new Test_S2);
+    test($NS ? eval("return new Test\\S2 == new Test\\S2;") : new Test_S2 == new Test_S2);
 
     //
     // Change one primitive member at a time.
@@ -167,11 +167,11 @@ function allTests($communicator)
     test($v1 == $def_s2);
 
     $v1 = clone $def_s2;
-    $v1->s = $NS ? eval("new Test\\S1(\"name\");") : new Test_S1("name");
+    $v1->s = $NS ? eval("return new Test\\S1(\"name\");") : new Test_S1("name");
     test($v1 == $def_s2);
 
     $v1 = clone $def_s2;
-    $v1->s = $NS ? eval("new Test\\S1(\"noname\");") : new Test_S1("noname");
+    $v1->s = $NS ? eval("return new Test\\S1(\"noname\");") : new Test_S1("noname");
     test($v1 != $def_s2);
 
     $v1 = clone $def_s2;
diff --git a/py/modules/IcePy/Operation.cpp b/py/modules/IcePy/Operation.cpp
index 401109e84b9..2c5931ba9ab 100644
--- a/py/modules/IcePy/Operation.cpp
+++ b/py/modules/IcePy/Operation.cpp
@@ -1563,6 +1563,8 @@ IcePy::TypedInvocation::unmarshalException(const pair<const Ice::Byte*, const Ic
     }
     catch(const ExceptionReader& r)
     {
+        is->endEncapsulation();
+
         PyObject* ex = r.getException();
 
         if(validateException(ex))
diff --git a/py/modules/IcePy/Types.cpp b/py/modules/IcePy/Types.cpp
index 97dbf7f989f..526ca3aa63e 100644
--- a/py/modules/IcePy/Types.cpp
+++ b/py/modules/IcePy/Types.cpp
@@ -370,8 +370,13 @@ IcePy::SlicedDataUtil::setMember(PyObject* obj, const Ice::SlicedDataPtr& sliced
         //
         // bytes
         //
+#if PY_VERSION_HEX >= 0x03000000
+        PyObjectHandle bytes =
+            PyBytes_FromStringAndSize(reinterpret_cast<const char*>(&(*p)->bytes[0]), (*p)->bytes.size());
+#else
         PyObjectHandle bytes =
             PyString_FromStringAndSize(reinterpret_cast<const char*>(&(*p)->bytes[0]), (*p)->bytes.size());
+#endif
         if(!bytes.get() || PyObject_SetAttrString(slice.get(), STRCAST("bytes"), bytes.get()) < 0)
         {
             assert(PyErr_Occurred());
@@ -446,14 +451,19 @@ IcePy::SlicedDataUtil::getMember(PyObject* obj, ObjectMap* objectMap)
 
                 PyObjectHandle typeId = PyObject_GetAttrString(s.get(), STRCAST("typeId"));
                 assert(typeId.get());
-                assert(PyString_Check(typeId.get()));
                 info->typeId = getString(typeId.get());
 
                 PyObjectHandle bytes = PyObject_GetAttrString(s.get(), STRCAST("bytes"));
                 assert(bytes.get());
+                char* str;
+                Py_ssize_t strsz;
+#if PY_VERSION_HEX >= 0x03000000
+                assert(PyBytes_Check(bytes.get()));
+                PyBytes_AsStringAndSize(bytes.get(), &str, &strsz);
+#else
                 assert(PyString_Check(bytes.get()));
-                const char* str = PyString_AS_STRING(bytes.get());
-                Py_ssize_t strsz = PyString_GET_SIZE(bytes.get());
+                PyString_AsStringAndSize(bytes.get(), &str, &strsz);
+#endif
                 vector<Ice::Byte> vtmp(str, str + strsz);
                 info->bytes.swap(vtmp);
 
diff --git a/py/modules/IcePy/Util.cpp b/py/modules/IcePy/Util.cpp
index 1aae7f471a6..e49bd332334 100644
--- a/py/modules/IcePy/Util.cpp
+++ b/py/modules/IcePy/Util.cpp
@@ -36,8 +36,8 @@ setVersion(PyObject* p, const T& version)
 {
     assert(checkIsInstance(p, PT));
 
-    PyObjectHandle major = PyInt_FromLong(version.major);
-    PyObjectHandle minor = PyInt_FromLong(version.minor);
+    PyObjectHandle major = PyLong_FromLong(version.major);
+    PyObjectHandle minor = PyLong_FromLong(version.minor);
     if(!major.get() || !minor.get())
     {
         return false;
@@ -58,12 +58,12 @@ getVersion(PyObject* p, T& v)
     PyObjectHandle minor = PyObject_GetAttrString(p, STRCAST("minor"));
     if(major.get())
     {
-        if(!PyInt_Check(major.get()))
+        if(!PyLong_Check(major.get()))
         {
             PyErr_Format(PyExc_ValueError, STRCAST("version major must be a numeric value"));
             return false;
         }
-        int m = PyInt_AsLong(major.get());
+        long m = PyLong_AsLong(major.get());
         if(m < 0 || m > 255)
         {
             PyErr_Format(PyExc_ValueError, STRCAST("version major must be a value between 0 and 255"));
@@ -73,12 +73,12 @@ getVersion(PyObject* p, T& v)
     }
     if(minor.get())
     {
-        if(!PyInt_Check(minor.get()))
+        if(!PyLong_Check(minor.get()))
         {
             PyErr_Format(PyExc_ValueError, STRCAST("version minor must be a numeric value"));
             return false;
         }
-        int m = PyInt_AsLong(minor.get());
+        long m = PyLong_AsLong(minor.get());
         if(m < 0 || m > 255)
         {
             PyErr_Format(PyExc_ValueError, STRCAST("version minor must be a value between 0 and 255"));
@@ -134,7 +134,7 @@ versionToString(PyObject* args)
         IcePy::setPythonException(ex);
         return NULL;
     }
-    return PyString_FromString(const_cast<char*>(s.c_str()));
+    return createString(s);
 }
 
 template<typename T, const char* PT> PyObject*
diff --git a/rb/src/IceRuby/Operation.cpp b/rb/src/IceRuby/Operation.cpp
index a8743a3145e..182f971626a 100644
--- a/rb/src/IceRuby/Operation.cpp
+++ b/rb/src/IceRuby/Operation.cpp
@@ -64,7 +64,7 @@ private:
     bool _returnsClasses;
     string _deprecateMessage;
 
-    void prepareRequest(const Ice::ObjectPrx&, VALUE, bool, vector<Ice::Byte>&);
+    void prepareRequest(const Ice::ObjectPrx&, VALUE, vector<Ice::Byte>&);
     VALUE unmarshalResults(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     VALUE unmarshalException(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     bool validateException(VALUE) const;
@@ -275,7 +275,7 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
     // Marshal the input parameters to a byte sequence.
     //
     Ice::ByteSeq params;
-    prepareRequest(proxy, args, false, params);
+    prepareRequest(proxy, args, params);
 
     if(!_deprecateMessage.empty())
     {
@@ -355,7 +355,7 @@ IceRuby::OperationI::deprecate(const string& msg)
 }
 
 void
-IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, bool async, vector<Ice::Byte>& bytes)
+IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, vector<Ice::Byte>& bytes)
 {
     //
     // Validate the number of arguments.
@@ -388,17 +388,9 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, boo
             volatile VALUE arg = RARRAY_PTR(args)[i];
             if(!(*p)->type->validate(arg))
             {
-                string opName;
-                if(async)
-                {
-                    opName = fixIdent(_name, IdentNormal) + "_async";
-                }
-                else
-                {
-                    opName = fixIdent(_name, IdentNormal);
-                }
-                throw RubyException(rb_eTypeError, "invalid value for argument %ld in operation `%s'",
-                                    async ? i + 2 : i + 1, opName.c_str());
+                string opName = fixIdent(_name, IdentNormal);
+                throw RubyException(rb_eTypeError, "invalid value for argument %ld in operation `%s'", i + 1,
+                                    opName.c_str());
             }
             (*p)->type->marshal(arg, os, &objectMap);
         }
@@ -483,12 +475,20 @@ IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ic
     }
     catch(const ExceptionReader& r)
     {
+        is->endEncapsulation();
+
         volatile VALUE ex = r.getException();
 
         if(validateException(ex))
         {
             util.update();
 
+            Ice::SlicedDataPtr slicedData = r.getSlicedData();
+            if(slicedData)
+            {
+                SlicedDataUtil::setMember(ex, slicedData);
+            }
+
             return ex;
         }
         else
diff --git a/rb/src/IceRuby/Types.cpp b/rb/src/IceRuby/Types.cpp
index 5c29dd817b1..bc028a3177a 100644
--- a/rb/src/IceRuby/Types.cpp
+++ b/rb/src/IceRuby/Types.cpp
@@ -271,7 +271,7 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
         for(vector<Ice::ObjectPtr>::iterator q = (*p)->objects.begin(); q != (*p)->objects.end(); ++q)
         {
             //
-            // Each element in the objects list is an instance of ObjectReader that wraps a Python object.
+            // Each element in the objects list is an instance of ObjectReader that wraps a Ruby object.
             //
             assert(*q);
             ObjectReaderPtr r = ObjectReaderPtr::dynamicCast(*q);
@@ -1869,7 +1869,7 @@ IceRuby::ObjectWriter::write(const Ice::OutputStreamPtr& os) const
     if(_info->preserve)
     {
         //
-        // Retrieve the SlicedData object that we stored as a hidden member of the Python object.
+        // Retrieve the SlicedData object that we stored as a hidden member of the Ruby object.
         //
         slicedData = SlicedDataUtil::getMember(_object, const_cast<ObjectMap*>(_map));
     }
@@ -2116,7 +2116,7 @@ IceRuby::ExceptionReader::read(const Ice::InputStreamPtr& is) const
 
     const_cast<VALUE&>(_ex) = _info->unmarshal(is);
 
-    is->endException(false);
+    const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
 }
 
 bool
@@ -2158,7 +2158,7 @@ IceRuby::ExceptionReader::getException() const
 Ice::SlicedDataPtr
 IceRuby::ExceptionReader::getSlicedData() const
 {
-    return 0;
+    return _slicedData;
 }
 
 extern "C"
@@ -2331,13 +2331,15 @@ IceRuby_declareLocalClass(VALUE /*self*/, VALUE id)
 
 extern "C"
 VALUE
-IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE base, VALUE members)
+IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE preserve, VALUE base, VALUE members)
 {
     ICE_RUBY_TRY
     {
         ExceptionInfoPtr info = new ExceptionInfo;
         info->id = getString(id);
 
+        info->preserve = preserve == Qtrue;
+
         if(!NIL_P(base))
         {
             info->base = ExceptionInfoPtr::dynamicCast(getException(base));
@@ -2540,7 +2542,7 @@ IceRuby::initTypes(VALUE iceModule)
     rb_define_module_function(iceModule, "__declareProxy", CAST_METHOD(IceRuby_declareProxy), 1);
     rb_define_module_function(iceModule, "__declareClass", CAST_METHOD(IceRuby_declareClass), 1);
     rb_define_module_function(iceModule, "__declareLocalClass", CAST_METHOD(IceRuby_declareLocalClass), 1);
-    rb_define_module_function(iceModule, "__defineException", CAST_METHOD(IceRuby_defineException), 4);
+    rb_define_module_function(iceModule, "__defineException", CAST_METHOD(IceRuby_defineException), 5);
 
     rb_define_method(_typeInfoClass, "defineClass", CAST_METHOD(IceRuby_TypeInfo_defineClass), 6);
     rb_define_method(_typeInfoClass, "defineProxy", CAST_METHOD(IceRuby_TypeInfo_defineProxy), 2);
diff --git a/rb/src/IceRuby/Types.h b/rb/src/IceRuby/Types.h
index 954272f8f02..96d3756616a 100644
--- a/rb/src/IceRuby/Types.h
+++ b/rb/src/IceRuby/Types.h
@@ -373,6 +373,7 @@ public:
     void printMembers(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
     std::string id;
+    bool preserve;
     ExceptionInfoPtr base;
     DataMemberList members;
     bool usesClasses;
@@ -424,7 +425,6 @@ private:
     ClassInfoPtr _info;
     Ice::SlicedDataPtr _slicedData;
 };
-typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
 
 //
 // ExceptionReader creates a Ruby user exception and unmarshals it.
diff --git a/rb/src/IceRuby/Util.cpp b/rb/src/IceRuby/Util.cpp
index b5333cbcbd1..6e62ee391d5 100644
--- a/rb/src/IceRuby/Util.cpp
+++ b/rb/src/IceRuby/Util.cpp
@@ -99,7 +99,7 @@ versionToString(VALUE p)
     T v;
     if(!getVersion<T, PT>(p, v))
     {
-        return NULL;
+        return Qnil;
     }
 
     ICE_RUBY_TRY
@@ -558,43 +558,6 @@ IceRuby::getEncodingVersion(VALUE p, Ice::EncodingVersion& v)
     return true;
 }
 
-#if 0
-VALUE
-IceRuby::currentProtocol(VALUE)
-{
-}
-
-VALUE
-IceRuby::currentProtocolEncoding(VALUE)
-{
-}
-
-VALUE
-IceRuby::currentEncoding(VALUE)
-{
-}
-
-VALUE
-IceRuby::protocolVersionToString(VALUE, VALUE)
-{
-}
-
-VALUE
-IceRuby::stringToProtocolVersion(VALUE, VALUE)
-{
-}
-
-VALUE
-IceRuby::encodingVersionToString(VALUE, VALUE)
-{
-}
-
-VALUE
-IceRuby::stringToEncodingVersion(VALUE, VALUE)
-{
-}
-#endif
-
 VALUE
 IceRuby::callProtected(RubyFunction func, VALUE arg)
 {
diff --git a/rb/test/Ice/exceptions/run.py b/rb/test/Ice/exceptions/run.py
index 152a9fbcccb..7732c33648e 100755
--- a/rb/test/Ice/exceptions/run.py
+++ b/rb/test/Ice/exceptions/run.py
@@ -20,9 +20,15 @@ if len(path) == 0:
 sys.path.append(os.path.join(path[0], "scripts"))
 import TestUtil
 
-print("tests with regular server.")
+print("Running test with compact (default) format.")
 TestUtil.clientServerTest()
-print("tests with AMD server.")
+print("Running test with sliced format.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.SlicedFormat", additionalServerOptions="--Ice.Default.SlicedFormat")
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
+print("Running test with compact (default) format and AMD server.")
 TestUtil.clientServerTest(server="serveramd")
-
-sys.exit(0)
+print("Running test with sliced format and AMD server.")
+TestUtil.clientServerTest(server="serveramd", additionalClientOptions="--Ice.Default.SlicedFormat", additionalServerOptions="--Ice.Default.SlicedFormat")
+print("Running test with 1.0 encoding and AMD server.")
+TestUtil.clientServerTest(server="serveramd", additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/rb/test/Ice/objects/run.py b/rb/test/Ice/objects/run.py
index 61d1af84e72..3d61174d3d1 100755
--- a/rb/test/Ice/objects/run.py
+++ b/rb/test/Ice/objects/run.py
@@ -20,5 +20,9 @@ if len(path) == 0:
 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")
+print("Running test with 1.0 encoding.")
+TestUtil.clientServerTest(additionalClientOptions="--Ice.Default.EncodingVersion=1.0", additionalServerOptions="--Ice.Default.EncodingVersion=1.0")
diff --git a/rb/test/Ice/proxy/AllTests.rb b/rb/test/Ice/proxy/AllTests.rb
index 23b28227b11..89f892186aa 100644
--- a/rb/test/Ice/proxy/AllTests.rb
+++ b/rb/test/Ice/proxy/AllTests.rb
@@ -451,7 +451,7 @@ def allTests(communicator)
     #test(!(compObj.ice_locator(loc1) < compObj.ice_locator(nil)))
     #test(compObj.ice_locator(loc1) < compObj.ice_locator(loc2))
     #test(!(compObj.ice_locator(loc2) < compObj.ice_locator(loc1)))
-    
+
     rtr1 = Ice::RouterPrx::uncheckedCast(communicator.stringToProxy("rtr1:default -p 10000"))
     rtr2 = Ice::RouterPrx::uncheckedCast(communicator.stringToProxy("rtr2:default -p 10000"))
     test(compObj.ice_router(nil) == compObj.ice_router(nil))
@@ -475,12 +475,12 @@ def allTests(communicator)
     test(compObj.ice_context(ctx1) != compObj.ice_context(ctx2))
     #test(compObj.ice_context(ctx1) < compObj.ice_context(ctx2))
     #test(!(compObj.ice_context(ctx2) < compObj.ice_context(ctx1)))
-    
+
     test(compObj.ice_preferSecure(true) == compObj.ice_preferSecure(true))
     test(compObj.ice_preferSecure(true) != compObj.ice_preferSecure(false))
     #test(compObj.ice_preferSecure(false) < compObj.ice_preferSecure(true))
     #test(!(compObj.ice_preferSecure(true) < compObj.ice_preferSecure(false)))
-    
+
     compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")
     compObj2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001")
     test(compObj1 != compObj2)
@@ -642,7 +642,7 @@ def allTests(communicator)
     rescue Ice::EndpointParseException
     end
 
-    # Legal TCP endpoint expressed as opaque endpoint
+    # Legal TCP endpoint expressed as opaque endpoint.
     p1 = communicator.stringToProxy("test:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==")
     pstr = communicator.proxyToString(p1)
     test(pstr == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000")
@@ -654,7 +654,7 @@ def allTests(communicator)
     # 1.0 TCP endpoint encoded with 1.1 encoding.
     p2 = communicator.stringToProxy("test: opaque -t 1 -e 1.1 -v CTEyNy4wLjAuMeouAAAQJwAAAAEAAQA=")
     test(communicator.proxyToString(p2) == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000")
-    
+
     # Working?
     if communicator.getProperties().getPropertyAsInt("Ice.IPv6") == 0
         ssl = communicator.getProperties().getProperty("Ice.Default.Protocol") == "ssl"
diff --git a/rb/test/Ice/slicing/exceptions/AllTests.rb b/rb/test/Ice/slicing/exceptions/AllTests.rb
index 489135ba803..26702ae5e4a 100644
--- a/rb/test/Ice/slicing/exceptions/AllTests.rb
+++ b/rb/test/Ice/slicing/exceptions/AllTests.rb
@@ -7,7 +7,7 @@
 #
 # **********************************************************************
 
-Ice::loadSlice('-I. --all ClientPrivate.ice')
+Ice::loadSlice('Test.ice')
 
 def test(b)
     if !b
diff --git a/rb/test/Ice/slicing/exceptions/ClientPrivate.ice b/rb/test/Ice/slicing/exceptions/ClientPrivate.ice
deleted file mode 100644
index 029e6d5d37e..00000000000
--- a/rb/test/Ice/slicing/exceptions/ClientPrivate.ice
+++ /dev/null
@@ -1,32 +0,0 @@
-// **********************************************************************
-//
-// 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
-
-#include <Test.ice>
-
-module Test
-{
-
-class PreservedClass extends BaseClass
-{
-    string pc;
-};
-
-exception Preserved1 extends KnownPreservedDerived
-{
-    BaseClass p1;
-};
-
-exception Preserved2 extends Preserved1
-{
-    BaseClass p2;
-};
-
-};
diff --git a/rb/test/Ice/slicing/objects/AllTests.rb b/rb/test/Ice/slicing/objects/AllTests.rb
index 8e753e18057..774e4702a12 100644
--- a/rb/test/Ice/slicing/objects/AllTests.rb
+++ b/rb/test/Ice/slicing/objects/AllTests.rb
@@ -728,7 +728,7 @@ def allTests(communicator)
 
     #
     # Send an object that will have multiple preserved slices in the server.
-    # The object will be sliced to Preserved for the 1.0 encoding.
+    # The object will be sliced to PDerived for the 1.0 encoding.
     #
     pcd = Test::PCDerived3.new()
     pcd.pi = 3
@@ -749,7 +749,7 @@ def allTests(communicator)
     r = t.exchangePBase(pcd)
     if t.ice_getEncodingVersion() == Ice::Encoding_1_0
         test(!r.is_a?(Test::PCDerived3))
-        test(r.is_a?(Test::Preserved))
+        test(r.is_a?(Test::PDerived))
         test(r.pi == 3)
     else
         test(r.is_a?(Test::PCDerived3))