PHP changes:

- static translation
- more traditional language mapping (multiple communicators, etc.)
- support for registered (persistent) communicators
- support for PHP namespaces (PHP 5.3 or later)

1 files changed, 409 insertions, 1585 deletions

diff --git a/php/src/IcePHP/Proxy.cpp b/php/src/IcePHP/Proxy.cpp
index 9b22aca798e..65bb3cd9e6d 100644
--- a/php/src/IcePHP/Proxy.cpp
+++ b/php/src/IcePHP/Proxy.cpp
@@ -7,11 +7,9 @@
 //
 // **********************************************************************
 
-#include <IceUtil/DisableWarnings.h>
 #include <Proxy.h>
-#include <Communicator.h>
-#include <Marshal.h>
-#include <Profile.h>
+#include <Connection.h>
+#include <Endpoint.h>
 #include <Util.h>
 
 using namespace std;
@@ -22,28 +20,25 @@ ZEND_EXTERN_MODULE_GLOBALS(ice)
 //
 // Here's a brief description of how proxies are handled by this extension.
 //
-// A single PHP class, Ice_ObjectPrx, is registered. This is an "internal" class,
+// A single PHP class, ObjectPrx, is registered. This is an "internal" class,
 // i.e., implemented by this extension, and it is used to represent all proxies
 // regardless of interface type.
 //
 // Like in C++, a proxy is only capable of invoking the Ice::ObjectPrx operations
 // until it is narrowed with a checked or unchecked cast. Unlike C++, no PHP classes
-// are created for proxies, because all marshaling activity is driven by the Slice
+// are created for proxies, because all marshaling activity is driven by the type
 // definitions, not by statically-generated code.
 //
-// In order to perform a checked or unchecked cast, the user invokes ice_checkedCast
-// or ice_uncheckedCast on the proxy to be narrowed, supplying a scoped name for the
-// desired type. Internally, the proxy validates the scoped name and returns a new
-// proxy containing the Slice class or interface definition. This proxy is considered
+// In order to perform a checked or unchecked cast, the generated code invokes
+// ice_checkedCast or ice_uncheckedCast on the proxy to be narrowed, supplying a scoped
+// name for the desired type. Internally, the proxy validates the scoped name and returns
+// a new proxy containing the class or interface definition. This proxy is considered
 // to be narrowed to that interface and therefore supports user-defined operations.
 //
-// Naturally, there are many predefined proxy methods (e.g., ice_isA, etc.), but
+// Naturally, there are many predefined proxy methods (e.g., ice_getIdentity, etc.), but
 // the proxy also needs to support user-defined operations (if it has type information).
 // We use a Zend API hook that allows us to intercept the invocation of unknown methods
-// on the proxy object. At this point, the proxy checks the interface definition for
-// an operation with the given name, and then creates an Operation object (see below)
-// that is responsible for invoking the operation. The proxy caches the Operation objects
-// for future reuse.
+// on the proxy object.
 //
 
 //
@@ -52,346 +47,73 @@ ZEND_EXTERN_MODULE_GLOBALS(ice)
 namespace IcePHP
 {
 zend_class_entry* proxyClassEntry = 0;
-zend_class_entry* endpointClassEntry = 0;
-zend_class_entry* connectionClassEntry = 0;
 }
 
 //
-// Ice::ObjectPrx and Ice::Endpoint support.
+// Ice::ObjectPrx support.
 //
-static zend_object_handlers _proxyHandlers;
-static zend_object_handlers _endpointHandlers;
-static zend_object_handlers _connectionHandlers;
+static zend_object_handlers _handlers;
 
 extern "C"
 {
-static zend_object_value handleProxyAlloc(zend_class_entry* TSRMLS_DC);
-static void handleProxyFreeStorage(void* TSRMLS_DC);
-static zend_object_value handleProxyClone(zval* TSRMLS_DC);
-static union _zend_function* handleProxyGetMethod(zval**, char*, int TSRMLS_DC);
-static int handleProxyCompare(zval*, zval* TSRMLS_DC);
-ZEND_FUNCTION(Ice_ObjectPrx_call);
-
-static zend_object_value handleEndpointAlloc(zend_class_entry* TSRMLS_DC);
-static void handleEndpointFreeStorage(void* TSRMLS_DC);
-
-static zend_object_value handleConnectionAlloc(zend_class_entry* TSRMLS_DC);
-static void handleConnectionFreeStorage(void* TSRMLS_DC);
-static int handleConnectionCompare(zval*, zval* TSRMLS_DC);
+static zend_object_value handleAlloc(zend_class_entry* TSRMLS_DC);
+static void handleFreeStorage(void* TSRMLS_DC);
+static zend_object_value handleClone(zval* TSRMLS_DC);
+static union _zend_function* handleGetMethod(zval**, char*, int TSRMLS_DC);
+static int handleCompare(zval*, zval* TSRMLS_DC);
 }
 
-static bool lookupClass(const string&, Slice::ClassDefPtr& TSRMLS_DC);
+static ClassInfoPtr lookupClass(const string& TSRMLS_DC);
 
 namespace IcePHP
 {
 
 //
-// Encapsulates an operation description.
-//
-class Operation : public IceUtil::SimpleShared
-{
-public:
-    Operation(const Ice::ObjectPrx&, const string&, const Slice::OperationPtr&, const Ice::CommunicatorPtr&
-              TSRMLS_DC);
-    virtual ~Operation();
-
-    zend_function* getZendFunction() const;
-    void invoke(INTERNAL_FUNCTION_PARAMETERS);
-
-private:
-    void throwUserException(Ice::InputStreamPtr& TSRMLS_DC);
-
-    Ice::ObjectPrx _proxy;
-    string _name; // Local name, not the on-the-wire name
-    Slice::OperationPtr _op;
-    Ice::CommunicatorPtr _communicator;
-#ifdef ZTS
-    TSRMLS_D;
-#endif
-    vector<string> _paramNames;
-    MarshalerPtr _result;
-    vector<MarshalerPtr> _inParams;
-    vector<MarshalerPtr> _outParams;
-    zend_internal_function* _zendFunction;
-};
-typedef IceUtil::Handle<Operation> OperationPtr;
-
-//
 // Encapsulates proxy and type information.
 //
-class Proxy
+class Proxy : public IceUtil::Shared
 {
 public:
-    Proxy(const Ice::ObjectPrx&, const Slice::ClassDefPtr& TSRMLS_DC);
-    ~Proxy();
 
-    const Ice::ObjectPrx& getProxy() const;
-    const Slice::ClassDefPtr& getClass() const;
-
-    OperationPtr getOperation(const string&);
+    Proxy(const Ice::ObjectPrx&, const ClassInfoPtr&, const CommunicatorInfoPtr& TSRMLS_DC);
+    ~Proxy();
 
-    string toString() const;
+    bool clone(zval*, const Ice::ObjectPrx& TSRMLS_DC);
+    bool cloneUntyped(zval*, const Ice::ObjectPrx& TSRMLS_DC);
+    static bool create(zval*, const Ice::ObjectPrx&, const ClassInfoPtr&, const CommunicatorInfoPtr& TSRMLS_DC);
 
-private:
-    Ice::ObjectPrx _proxy;
-    Slice::ClassDefPtr _class;
-#ifdef ZTS
+    Ice::ObjectPrx proxy;
+    ClassInfoPtr info;
+    CommunicatorInfoPtr communicator;
+    zval* connection;
+    zval* cachedConnection;
+#if ZTS
     TSRMLS_D;
 #endif
-    zval _communicatorZval;
-    Ice::CommunicatorPtr _communicator;
-    Slice::OperationList _classOps;
-    map<string, OperationPtr> _ops;
 };
+typedef IceUtil::Handle<Proxy> ProxyPtr;
 
 } // End of namespace IcePHP
 
-//
-// Predefined methods for Ice_ObjectPrx.
-//
-static function_entry _proxyMethods[] =
-{
-    {"__construct",                PHP_FN(Ice_ObjectPrx___construct),                0},
-    {"__tostring",                 PHP_FN(Ice_ObjectPrx___tostring),                 0},
-    {"ice_getCommunicator",        PHP_FN(Ice_ObjectPrx_ice_getCommunicator),        0},
-    {"ice_toString",               PHP_FN(Ice_ObjectPrx_ice_toString),               0},
-    {"ice_isA",                    PHP_FN(Ice_ObjectPrx_ice_isA),                    0},
-    {"ice_ping",                   PHP_FN(Ice_ObjectPrx_ice_ping),                   0},
-    {"ice_id",                     PHP_FN(Ice_ObjectPrx_ice_id),                     0},
-    {"ice_ids",                    PHP_FN(Ice_ObjectPrx_ice_ids),                    0},
-    {"ice_getIdentity",            PHP_FN(Ice_ObjectPrx_ice_getIdentity),            0},
-    {"ice_newIdentity",            PHP_FN(Ice_ObjectPrx_ice_identity),               0},
-    {"ice_identity",               PHP_FN(Ice_ObjectPrx_ice_identity),               0},
-    {"ice_getContext",             PHP_FN(Ice_ObjectPrx_ice_getContext),             0},
-    {"ice_newContext",             PHP_FN(Ice_ObjectPrx_ice_context),                0},
-    {"ice_context",                PHP_FN(Ice_ObjectPrx_ice_context),                0},
-    {"ice_getFacet",               PHP_FN(Ice_ObjectPrx_ice_getFacet),               0},
-    {"ice_newFacet",               PHP_FN(Ice_ObjectPrx_ice_facet),                  0},
-    {"ice_facet",                  PHP_FN(Ice_ObjectPrx_ice_facet),                  0},
-    {"ice_getAdapterId",           PHP_FN(Ice_ObjectPrx_ice_getAdapterId),           0},
-    {"ice_newAdapterId",           PHP_FN(Ice_ObjectPrx_ice_adapterId),              0},
-    {"ice_adapterId",              PHP_FN(Ice_ObjectPrx_ice_adapterId),              0},
-    {"ice_getEndpoints",           PHP_FN(Ice_ObjectPrx_ice_getEndpoints),           0},
-    {"ice_newEndpoints",           PHP_FN(Ice_ObjectPrx_ice_endpoints),              0},
-    {"ice_endpoints",              PHP_FN(Ice_ObjectPrx_ice_endpoints),              0},
-    {"ice_getLocatorCacheTimeout", PHP_FN(Ice_ObjectPrx_ice_getLocatorCacheTimeout), 0},
-    {"ice_locatorCacheTimeout",    PHP_FN(Ice_ObjectPrx_ice_locatorCacheTimeout),    0},
-    {"ice_isConnectionCached",     PHP_FN(Ice_ObjectPrx_ice_isConnectionCached),     0},
-    {"ice_connectionCached",       PHP_FN(Ice_ObjectPrx_ice_connectionCached),       0},
-    {"ice_getEndpointSelection",   PHP_FN(Ice_ObjectPrx_ice_getEndpointSelection),   0},
-    {"ice_endpointSelection",      PHP_FN(Ice_ObjectPrx_ice_endpointSelection),      0},
-    {"ice_isSecure",               PHP_FN(Ice_ObjectPrx_ice_isSecure),               0},
-    {"ice_secure",                 PHP_FN(Ice_ObjectPrx_ice_secure),                 0},
-    {"ice_isPreferSecure",         PHP_FN(Ice_ObjectPrx_ice_isPreferSecure),         0},
-    {"ice_preferSecure",           PHP_FN(Ice_ObjectPrx_ice_preferSecure),           0},
-    {"ice_getRouter",              PHP_FN(Ice_ObjectPrx_ice_getRouter),              0},
-    {"ice_router",                 PHP_FN(Ice_ObjectPrx_ice_router),                 0},
-    {"ice_getLocator",             PHP_FN(Ice_ObjectPrx_ice_getLocator),             0},
-    {"ice_locator",                PHP_FN(Ice_ObjectPrx_ice_locator),                0},
-    {"ice_twoway",                 PHP_FN(Ice_ObjectPrx_ice_twoway),                 0},
-    {"ice_isTwoway",               PHP_FN(Ice_ObjectPrx_ice_isTwoway),               0},
-    {"ice_oneway",                 PHP_FN(Ice_ObjectPrx_ice_oneway),                 0},
-    {"ice_isOneway",               PHP_FN(Ice_ObjectPrx_ice_isOneway),               0},
-    {"ice_batchOneway",            PHP_FN(Ice_ObjectPrx_ice_batchOneway),            0},
-    {"ice_isBatchOneway",          PHP_FN(Ice_ObjectPrx_ice_isBatchOneway),          0},
-    {"ice_datagram",               PHP_FN(Ice_ObjectPrx_ice_datagram),               0},
-    {"ice_isDatagram",             PHP_FN(Ice_ObjectPrx_ice_isDatagram),             0},
-    {"ice_batchDatagram",          PHP_FN(Ice_ObjectPrx_ice_batchDatagram),          0},
-    {"ice_isBatchDatagram",        PHP_FN(Ice_ObjectPrx_ice_isBatchDatagram),        0},
-    {"ice_compress",               PHP_FN(Ice_ObjectPrx_ice_compress),               0},
-    {"ice_timeout",                PHP_FN(Ice_ObjectPrx_ice_timeout),                0},
-    {"ice_connectionId",           PHP_FN(Ice_ObjectPrx_ice_connectionId),           0},
-    {"ice_getConnection",          PHP_FN(Ice_ObjectPrx_ice_getConnection),          0},
-    {"ice_getCachedConnection",    PHP_FN(Ice_ObjectPrx_ice_getCachedConnection),    0},
-    {"ice_uncheckedCast",          PHP_FN(Ice_ObjectPrx_ice_uncheckedCast),          0},
-    {"ice_checkedCast",            PHP_FN(Ice_ObjectPrx_ice_checkedCast),            0},
-    {0, 0, 0}
-};
-
-//
-// Predefined methods for Ice_Endpoint.
-//
-static function_entry _endpointMethods[] =
-{
-    {"__construct", PHP_FN(Ice_Endpoint___construct), 0},
-    {"__tostring",  PHP_FN(Ice_Endpoint___tostring),  0},
-    {"toString",    PHP_FN(Ice_Endpoint_toString),    0},
-    {0, 0, 0}
-};
-
-//
-// Predefined methods for Ice_Connection.
-//
-static function_entry _connectionMethods[] =
-{
-    {"__construct",         PHP_FN(Ice_Connection___construct),         0},
-    {"__tostring",          PHP_FN(Ice_Connection___tostring),          0},
-    {"close",               PHP_FN(Ice_Connection_close),               0},
-    {"flushBatchRequests",  PHP_FN(Ice_Connection_flushBatchRequests),  0},
-    {"type",                PHP_FN(Ice_Connection_type),                0},
-    {"timeout",             PHP_FN(Ice_Connection_timeout),             0},
-    {"toString",            PHP_FN(Ice_Connection_toString),            0},
-    {0, 0, 0}
-};
-
-bool
-IcePHP::proxyInit(TSRMLS_D)
-{
-    //
-    // Register the Ice_ObjectPrx class.
-    //
-    zend_class_entry ce;
-    INIT_CLASS_ENTRY(ce, "Ice_ObjectPrx", _proxyMethods);
-    ce.create_object = handleProxyAlloc;
-    proxyClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
-    memcpy(&_proxyHandlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-    _proxyHandlers.clone_obj = handleProxyClone;
-    _proxyHandlers.get_method = handleProxyGetMethod;
-    _proxyHandlers.compare_objects = handleProxyCompare;
-
-    //
-    // Register the Ice_Endpoint class.
-    //
-    INIT_CLASS_ENTRY(ce, "Ice_Endpoint", _endpointMethods);
-    ce.create_object = handleEndpointAlloc;
-    endpointClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
-    memcpy(&_endpointHandlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-
-    //
-    // Register the Ice_Connection class.
-    //
-    INIT_CLASS_ENTRY(ce, "Ice_Connection", _connectionMethods);
-    ce.create_object = handleConnectionAlloc;
-    connectionClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
-    memcpy(&_connectionHandlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-    _connectionHandlers.compare_objects = handleConnectionCompare;
-
-    return true;
-}
-
-bool
-IcePHP::createProxy(zval* zv, const Ice::ObjectPrx& p TSRMLS_DC)
-{
-    return createProxy(zv, p, 0 TSRMLS_CC);
-}
-
-bool
-IcePHP::createProxy(zval* zv, const Ice::ObjectPrx& p, const Slice::ClassDefPtr& def TSRMLS_DC)
-{
-    if(object_init_ex(zv, proxyClassEntry) != SUCCESS)
-    {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to initialize proxy");
-        return false;
-    }
-
-    ice_object* zprx = static_cast<ice_object*>(zend_object_store_get_object(zv TSRMLS_CC));
-    assert(!zprx->ptr);
-    zprx->ptr = new Proxy(p, def TSRMLS_CC);
-
-    return true;
-}
-
-bool
-IcePHP::fetchProxy(zval* zv, Ice::ObjectPrx& prx, Slice::ClassDefPtr& def TSRMLS_DC)
-{
-    if(!ZVAL_IS_NULL(zv))
-    {
-        void* p = zend_object_store_get_object(zv TSRMLS_CC);
-        if(!p)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to retrieve proxy object from object store");
-            return false;
-        }
-        if(Z_OBJCE_P(zv) != proxyClassEntry)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "value is not a proxy");
-            return false;
-        }
-        ice_object* obj = static_cast<ice_object*>(p);
-        assert(obj->ptr);
-        Proxy* proxy = static_cast<Proxy*>(obj->ptr);
-        prx = proxy->getProxy();
-        def = proxy->getClass();
-    }
-    return true;
-}
-
-static bool
-createEndpoint(zval* zv, const Ice::EndpointPtr& p TSRMLS_DC)
-{
-    if(object_init_ex(zv, endpointClassEntry) != SUCCESS)
-    {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to initialize endpoint");
-        return false;
-    }
-
-    ice_object* ze = static_cast<ice_object*>(zend_object_store_get_object(zv TSRMLS_CC));
-    assert(!ze->ptr);
-    ze->ptr = new Ice::EndpointPtr(p);
-
-    return true;
-}
-
-static bool
-fetchEndpoint(zval* zv, Ice::EndpointPtr& endpoint TSRMLS_DC)
-{
-    if(!ZVAL_IS_NULL(zv))
-    {
-        void* p = zend_object_store_get_object(zv TSRMLS_CC);
-        if(!p)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to retrieve endpoint object from object store");
-            return false;
-        }
-        if(Z_OBJCE_P(zv) != endpointClassEntry)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "value is not an endpoint");
-            return false;
-        }
-        ice_object* obj = static_cast<ice_object*>(p);
-        assert(obj->ptr);
-        Ice::EndpointPtr* pe = static_cast<Ice::EndpointPtr*>(obj->ptr);
-        endpoint = *pe;
-    }
-    return true;
-}
-
-static bool
-createConnection(zval* zv, const Ice::ConnectionPtr& p TSRMLS_DC)
-{
-    if(object_init_ex(zv, connectionClassEntry) != SUCCESS)
-    {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to initialize connection");
-        return false;
-    }
-
-    ice_object* ze = static_cast<ice_object*>(zend_object_store_get_object(zv TSRMLS_CC));
-    assert(!ze->ptr);
-    ze->ptr = new Ice::ConnectionPtr(p);
-
-    return true;
-}
-
-ZEND_FUNCTION(Ice_ObjectPrx___construct)
+ZEND_METHOD(Ice_ObjectPrx, __construct)
 {
-    php_error_docref(0 TSRMLS_CC, E_ERROR, "Ice_ObjectPrx cannot be instantiated, use $ICE->stringToProxy()");
+    runtimeError("proxies cannot be instantiated, use stringToProxy()" TSRMLS_CC);
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx___tostring)
+ZEND_METHOD(Ice_ObjectPrx, __toString)
 {
     if(ZEND_NUM_ARGS() > 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        string str = _this->toString();
-        RETURN_STRINGL(const_cast<char*>(str.c_str()), str.length(), 1);
+        string str = _this->proxy->ice_toString();
+        RETURN_STRINGL(STRCAST(str.c_str()), str.length(), 1);
     }
     catch(const IceUtil::Exception& ex)
     {
@@ -400,242 +122,43 @@ ZEND_FUNCTION(Ice_ObjectPrx___tostring)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getCommunicator)
-{
-    zval* zc = getCommunicatorZval(TSRMLS_C);
-
-    Z_TYPE_P(return_value) = IS_OBJECT;
-    return_value->value.obj = zc->value.obj;
-    Z_OBJ_HT_P(return_value)->add_ref(return_value TSRMLS_CC);
-}
-
-ZEND_FUNCTION(Ice_ObjectPrx_ice_toString)
-{
-    ZEND_FN(Ice_ObjectPrx___tostring)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-}
-
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isA)
-{
-    if(ZEND_NUM_ARGS() < 1 || ZEND_NUM_ARGS() > 2)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    char* id;
-    int len;
-    zval* arr = 0;
-
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &id, &len, &arr) == FAILURE)
-    {
-        RETURN_FALSE;
-    }
-
-    //
-    // Populate the context (if necessary).
-    //
-    Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
-    {
-        RETURN_FALSE;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    try
-    {
-        bool b;
-        if(arr)
-        {
-            b = _this->getProxy()->ice_isA(id, ctx);
-        }
-        else
-        {
-            b = _this->getProxy()->ice_isA(id);
-        }
-
-        RETURN_BOOL(b ? 1 : 0);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETVAL_FALSE;
-    }
-}
-
-ZEND_FUNCTION(Ice_ObjectPrx_ice_ping)
+ZEND_METHOD(Ice_ObjectPrx, ice_getCommunicator)
 {
-    if(ZEND_NUM_ARGS() > 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    zval* arr = 0;
-
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &arr) == FAILURE)
-    {
-        RETURN_NULL();
-    }
-
-    //
-    // Populate the context (if necessary).
-    //
-    Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
-    {
-        RETURN_NULL();
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    try
-    {
-        if(arr)
-        {
-            _this->getProxy()->ice_ping(ctx);
-        }
-        else
-        {
-            _this->getProxy()->ice_ping();
-        }
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-    }
-
-    RETURN_NULL();
-}
-
-ZEND_FUNCTION(Ice_ObjectPrx_ice_id)
-{
-    if(ZEND_NUM_ARGS() > 1)
+    if(ZEND_NUM_ARGS() > 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    zval* arr = 0;
-
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &arr) == FAILURE)
-    {
-        RETURN_NULL();
-    }
-
-    //
-    // Populate the context (if necessary).
-    //
-    Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
-    {
-        RETURN_NULL();
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
-    try
-    {
-        string id;
-        if(arr)
-        {
-            id = _this->getProxy()->ice_id(ctx);
-        }
-        else
-        {
-            id = _this->getProxy()->ice_id();
-        }
-        RETURN_STRINGL(const_cast<char*>(id.c_str()), id.length(), 1);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
+    _this->communicator->getZval(return_value TSRMLS_CC);
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_ids)
+ZEND_METHOD(Ice_ObjectPrx, ice_toString)
 {
-    if(ZEND_NUM_ARGS() > 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    zval* arr = 0;
-
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &arr) == FAILURE)
-    {
-        RETURN_NULL();
-    }
-
-    //
-    // Populate the context (if necessary).
-    //
-    Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
-    {
-        RETURN_NULL();
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    try
-    {
-        vector<string> ids;
-        if(arr)
-        {
-            ids = _this->getProxy()->ice_ids(ctx);
-        }
-        else
-        {
-            ids = _this->getProxy()->ice_ids();
-        }
-
-        array_init(return_value);
-        uint idx = 0;
-        for(vector<string>::const_iterator p = ids.begin(); p != ids.end(); ++p, ++idx)
-        {
-            add_index_stringl(return_value, idx, const_cast<char*>((*p).c_str()), (*p).length(), 1);
-        }
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
+    ZEND_MN(Ice_ObjectPrx___toString)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getIdentity)
+ZEND_METHOD(Ice_ObjectPrx, ice_getIdentity)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
-    createIdentity(return_value, _this->getProxy()->ice_getIdentity() TSRMLS_CC);
+    createIdentity(return_value, _this->proxy->ice_getIdentity() TSRMLS_CC);
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_identity)
+ZEND_METHOD(Ice_ObjectPrx, ice_identity)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
-    zend_class_entry* cls = findClass("Ice_Identity" TSRMLS_CC);
+    zend_class_entry* cls = idToClass("::Ice::Identity" TSRMLS_CC);
     assert(cls);
 
     zval *zid;
@@ -650,8 +173,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_identity)
     {
         try
         {
-            Ice::ObjectPrx prx = _this->getProxy()->ice_identity(id);
-            if(!createProxy(return_value, prx TSRMLS_CC))
+            if(!_this->cloneUntyped(return_value, _this->proxy->ice_identity(id) TSRMLS_CC))
             {
                 RETURN_NULL();
             }
@@ -664,27 +186,24 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_identity)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getContext)
+ZEND_METHOD(Ice_ObjectPrx, ice_getContext)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    createContext(return_value, _this->getProxy()->ice_getContext() TSRMLS_CC);
-}
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_context)
-{
-    if(ZEND_NUM_ARGS() != 1)
+    if(!createStringMap(return_value, _this->proxy->ice_getContext() TSRMLS_CC))
     {
-        WRONG_PARAM_COUNT;
+        RETURN_NULL();
     }
+}
 
+ZEND_METHOD(Ice_ObjectPrx, ice_context)
+{
     zval* arr = 0;
 
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arr) == FAILURE)
@@ -696,19 +215,17 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_context)
     // Populate the context.
     //
     Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
+    if(arr && !extractStringMap(arr, ctx TSRMLS_CC))
     {
         RETURN_NULL();
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_context(ctx);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_context(ctx) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -720,21 +237,20 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_context)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getFacet)
+ZEND_METHOD(Ice_ObjectPrx, ice_getFacet)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        string facet = _this->getProxy()->ice_getFacet();
-        ZVAL_STRINGL(return_value, const_cast<char*>(facet.c_str()), facet.length(), 1);
+        string facet = _this->proxy->ice_getFacet();
+        ZVAL_STRINGL(return_value, STRCAST(facet.c_str()), facet.length(), 1);
     }
     catch(const IceUtil::Exception& ex)
     {
@@ -743,13 +259,8 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getFacet)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_facet)
+ZEND_METHOD(Ice_ObjectPrx, ice_facet)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
     char* name;
     int len;
 
@@ -758,14 +269,12 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_facet)
         RETURN_NULL();
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_facet(name);
-        if(!createProxy(return_value, prx TSRMLS_CC))
+        if(!_this->cloneUntyped(return_value, _this->proxy->ice_facet(name) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -777,21 +286,20 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_facet)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getAdapterId)
+ZEND_METHOD(Ice_ObjectPrx, ice_getAdapterId)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        string id = _this->getProxy()->ice_getAdapterId();
-        ZVAL_STRINGL(return_value, const_cast<char*>(id.c_str()), id.length(), 1);
+        string id = _this->proxy->ice_getAdapterId();
+        ZVAL_STRINGL(return_value, STRCAST(id.c_str()), id.length(), 1);
     }
     catch(const IceUtil::Exception& ex)
     {
@@ -800,16 +308,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getAdapterId)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_adapterId)
+ZEND_METHOD(Ice_ObjectPrx, ice_adapterId)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     char* id;
     int len;
@@ -821,8 +323,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_adapterId)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_adapterId(id);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_adapterId(id) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -834,20 +335,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_adapterId)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getEndpoints)
+ZEND_METHOD(Ice_ObjectPrx, ice_getEndpoints)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::EndpointSeq endpoints = _this->getProxy()->ice_getEndpoints();
+        Ice::EndpointSeq endpoints = _this->proxy->ice_getEndpoints();
 
         array_init(return_value);
         uint idx = 0;
@@ -870,16 +370,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getEndpoints)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_endpoints)
+ZEND_METHOD(Ice_ObjectPrx, ice_endpoints)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zval* zv;
 
@@ -901,7 +395,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_endpoints)
 
         if(Z_TYPE_PP(val) != IS_OBJECT)
         {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "expected an element of type Ice_Endpoint");
+            runtimeError("expected an element of type Ice::Endpoint" TSRMLS_CC);
             RETURN_NULL();
         }
 
@@ -918,8 +412,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_endpoints)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_endpoints(seq);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_endpoints(seq) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -931,20 +424,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_endpoints)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getLocatorCacheTimeout)
+ZEND_METHOD(Ice_ObjectPrx, ice_getLocatorCacheTimeout)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::Int timeout = _this->getProxy()->ice_getLocatorCacheTimeout();
+        Ice::Int timeout = _this->proxy->ice_getLocatorCacheTimeout();
         ZVAL_LONG(return_value, static_cast<long>(timeout));
     }
     catch(const IceUtil::Exception& ex)
@@ -954,16 +446,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getLocatorCacheTimeout)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_locatorCacheTimeout)
+ZEND_METHOD(Ice_ObjectPrx, ice_locatorCacheTimeout)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     long l;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &l) != SUCCESS)
@@ -973,8 +459,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locatorCacheTimeout)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_locatorCacheTimeout(l);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_locatorCacheTimeout(l) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -986,20 +471,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locatorCacheTimeout)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isConnectionCached)
+ZEND_METHOD(Ice_ObjectPrx, ice_isConnectionCached)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isConnectionCached();
+        bool b = _this->proxy->ice_isConnectionCached();
         ZVAL_BOOL(return_value, b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1009,16 +493,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isConnectionCached)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionCached)
+ZEND_METHOD(Ice_ObjectPrx, ice_connectionCached)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zend_bool b;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &b) != SUCCESS)
@@ -1028,8 +506,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionCached)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_connectionCached(b ? true : false);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_connectionCached(b ? true : false) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1041,20 +518,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionCached)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getEndpointSelection)
+ZEND_METHOD(Ice_ObjectPrx, ice_getEndpointSelection)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::EndpointSelectionType type = _this->getProxy()->ice_getEndpointSelection();
+        Ice::EndpointSelectionType type = _this->proxy->ice_getEndpointSelection();
         ZVAL_LONG(return_value, type == Ice::Random ? 0 : 1);
     }
     catch(const IceUtil::Exception& ex)
@@ -1064,16 +540,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getEndpointSelection)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_endpointSelection)
+ZEND_METHOD(Ice_ObjectPrx, ice_endpointSelection)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     long l;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &l) != SUCCESS)
@@ -1083,14 +553,14 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_endpointSelection)
 
     if(l < 0 || l > 1)
     {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "expecting Random or Ordered");
+        runtimeError("expecting Random or Ordered" TSRMLS_CC);
         RETURN_NULL();
     }
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_endpointSelection(l == 0 ? Ice::Random : Ice::Ordered);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        Ice::EndpointSelectionType type = l == 0 ? Ice::Random : Ice::Ordered;
+        if(!_this->clone(return_value, _this->proxy->ice_endpointSelection(type) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1102,20 +572,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_endpointSelection)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isSecure)
+ZEND_METHOD(Ice_ObjectPrx, ice_isSecure)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isSecure();
+        bool b = _this->proxy->ice_isSecure();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1125,16 +594,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isSecure)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_secure)
+ZEND_METHOD(Ice_ObjectPrx, ice_secure)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zend_bool b;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &b TSRMLS_CC) != SUCCESS)
@@ -1144,8 +607,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_secure)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_secure(b ? true : false);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_secure(b ? true : false) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1157,20 +619,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_secure)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isPreferSecure)
+ZEND_METHOD(Ice_ObjectPrx, ice_isPreferSecure)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isPreferSecure();
+        bool b = _this->proxy->ice_isPreferSecure();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1180,16 +641,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isPreferSecure)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_preferSecure)
+ZEND_METHOD(Ice_ObjectPrx, ice_preferSecure)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zend_bool b;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &b TSRMLS_CC) != SUCCESS)
@@ -1199,8 +654,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_preferSecure)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_preferSecure(b ? true : false);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_preferSecure(b ? true : false) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1212,31 +666,30 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_preferSecure)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getRouter)
+ZEND_METHOD(Ice_ObjectPrx, ice_getRouter)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::RouterPrx router = _this->getProxy()->ice_getRouter();
+        Ice::RouterPrx router = _this->proxy->ice_getRouter();
         if(router)
         {
-            Slice::ClassDefPtr def;
-            if(!lookupClass("Ice::Router", def TSRMLS_CC))
+            ClassInfoPtr info = lookupClass("::Ice::Router" TSRMLS_CC);
+            if(!info)
             {
                 RETURN_NULL();
             }
 
-            assert(def);
+            assert(info);
 
-            if(!createProxy(return_value, router, def TSRMLS_CC))
+            if(!createProxy(return_value, router, info, _this->communicator TSRMLS_CC))
             {
                 RETURN_NULL();
             }
@@ -1253,16 +706,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getRouter)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_router)
+ZEND_METHOD(Ice_ObjectPrx, ice_router)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zval* zprx;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O!", &zprx, proxyClassEntry TSRMLS_CC) != SUCCESS)
@@ -1271,7 +718,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_router)
     }
 
     Ice::ObjectPrx proxy;
-    Slice::ClassDefPtr def;
+    ClassInfoPtr def;
     if(zprx && !fetchProxy(zprx, proxy, def TSRMLS_CC))
     {
         RETURN_NULL();
@@ -1282,7 +729,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_router)
     {
         if(!def || !def->isA("::Ice::Router"))
         {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "ice_router requires a proxy narrowed to Ice::Router");
+            runtimeError("ice_router requires a proxy narrowed to Ice::Router" TSRMLS_CC);
             RETURN_NULL();
         }
         router = Ice::RouterPrx::uncheckedCast(proxy);
@@ -1290,8 +737,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_router)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_router(router);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_router(router) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1303,31 +749,28 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_router)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getLocator)
+ZEND_METHOD(Ice_ObjectPrx, ice_getLocator)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::LocatorPrx locator = _this->getProxy()->ice_getLocator();
+        Ice::LocatorPrx locator = _this->proxy->ice_getLocator();
         if(locator)
         {
-            Slice::ClassDefPtr def;
-            if(!lookupClass("Ice::Locator", def TSRMLS_CC))
+            ClassInfoPtr info = lookupClass("::Ice::Locator" TSRMLS_CC);
+            if(!info)
             {
                 RETURN_NULL();
             }
 
-            assert(def);
-
-            if(!createProxy(return_value, locator, def TSRMLS_CC))
+            if(!createProxy(return_value, locator, info, _this->communicator TSRMLS_CC))
             {
                 RETURN_NULL();
             }
@@ -1344,16 +787,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getLocator)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_locator)
+ZEND_METHOD(Ice_ObjectPrx, ice_locator)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zval* zprx;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O!", &zprx, proxyClassEntry TSRMLS_CC) != SUCCESS)
@@ -1362,7 +799,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locator)
     }
 
     Ice::ObjectPrx proxy;
-    Slice::ClassDefPtr def;
+    ClassInfoPtr def;
     if(zprx && !fetchProxy(zprx, proxy, def TSRMLS_CC))
     {
         RETURN_NULL();
@@ -1373,7 +810,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locator)
     {
         if(!def || !def->isA("::Ice::Locator"))
         {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "ice_locator requires a proxy narrowed to Ice::Locator");
+            runtimeError("ice_locator requires a proxy narrowed to Ice::Locator" TSRMLS_CC);
             RETURN_NULL();
         }
         locator = Ice::LocatorPrx::uncheckedCast(proxy);
@@ -1381,8 +818,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locator)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_locator(locator);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_locator(locator) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1394,21 +830,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_locator)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_twoway)
+ZEND_METHOD(Ice_ObjectPrx, ice_twoway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_twoway();
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_twoway() TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1420,20 +854,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_twoway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isTwoway)
+ZEND_METHOD(Ice_ObjectPrx, ice_isTwoway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isTwoway();
+        bool b = _this->proxy->ice_isTwoway();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1443,21 +876,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isTwoway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_oneway)
+ZEND_METHOD(Ice_ObjectPrx, ice_oneway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_oneway();
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_oneway() TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1469,20 +900,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_oneway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isOneway)
+ZEND_METHOD(Ice_ObjectPrx, ice_isOneway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isOneway();
+        bool b = _this->proxy->ice_isOneway();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1492,21 +922,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isOneway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_batchOneway)
+ZEND_METHOD(Ice_ObjectPrx, ice_batchOneway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_batchOneway();
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_batchOneway() TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1518,20 +946,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_batchOneway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isBatchOneway)
+ZEND_METHOD(Ice_ObjectPrx, ice_isBatchOneway)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isBatchOneway();
+        bool b = _this->proxy->ice_isBatchOneway();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1541,21 +968,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isBatchOneway)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_datagram)
+ZEND_METHOD(Ice_ObjectPrx, ice_datagram)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_datagram();
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_datagram() TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1567,20 +992,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_datagram)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isDatagram)
+ZEND_METHOD(Ice_ObjectPrx, ice_isDatagram)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isDatagram();
+        bool b = _this->proxy->ice_isDatagram();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1590,21 +1014,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isDatagram)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_batchDatagram)
+ZEND_METHOD(Ice_ObjectPrx, ice_batchDatagram)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_batchDatagram();
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_batchDatagram() TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1616,20 +1038,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_batchDatagram)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_isBatchDatagram)
+ZEND_METHOD(Ice_ObjectPrx, ice_isBatchDatagram)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        bool b = _this->getProxy()->ice_isBatchDatagram();
+        bool b = _this->proxy->ice_isBatchDatagram();
         RETURN_BOOL(b ? 1 : 0);
     }
     catch(const IceUtil::Exception& ex)
@@ -1639,16 +1060,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_isBatchDatagram)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_compress)
+ZEND_METHOD(Ice_ObjectPrx, ice_compress)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     zend_bool b;
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &b) != SUCCESS)
@@ -1658,8 +1073,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_compress)
 
     try
     {
-        Ice::ObjectPrx prx = _this->getProxy()->ice_compress(b ? true : false);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_compress(b ? true : false) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1671,16 +1085,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_compress)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_timeout)
+ZEND_METHOD(Ice_ObjectPrx, ice_timeout)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
@@ -1690,8 +1098,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_timeout)
             RETURN_NULL();
         }
         // TODO: range check?
-        Ice::ObjectPrx prx = _this->getProxy()->ice_timeout(l);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_timeout(l) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1703,16 +1110,10 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_timeout)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionId)
+ZEND_METHOD(Ice_ObjectPrx, ice_connectionId)
 {
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
@@ -1722,8 +1123,7 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionId)
         {
             RETURN_NULL();
         }
-        Ice::ObjectPrx prx = _this->getProxy()->ice_connectionId(id);
-        if(!createProxy(return_value, prx, _this->getClass() TSRMLS_CC))
+        if(!_this->clone(return_value, _this->proxy->ice_connectionId(id) TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1735,20 +1135,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_connectionId)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getConnection)
+ZEND_METHOD(Ice_ObjectPrx, ice_getConnection)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ConnectionPtr con = _this->getProxy()->ice_getConnection();
+        Ice::ConnectionPtr con = _this->proxy->ice_getConnection();
         if(!createConnection(return_value, con TSRMLS_CC))
         {
             RETURN_NULL();
@@ -1761,20 +1160,19 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getConnection)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_getCachedConnection)
+ZEND_METHOD(Ice_ObjectPrx, ice_getCachedConnection)
 {
     if(ZEND_NUM_ARGS() != 0)
     {
         WRONG_PARAM_COUNT;
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     try
     {
-        Ice::ConnectionPtr con = _this->getProxy()->ice_getCachedConnection();
+        Ice::ConnectionPtr con = _this->proxy->ice_getCachedConnection();
         if(!con || !createConnection(return_value, con TSRMLS_CC))
         {
             RETURN_NULL();
@@ -1787,88 +1185,28 @@ ZEND_FUNCTION(Ice_ObjectPrx_ice_getCachedConnection)
     }
 }
 
-static bool
-lookupClass(const string& id, Slice::ClassDefPtr& def TSRMLS_DC)
+static ClassInfoPtr
+lookupClass(const string& id TSRMLS_DC)
 {
-    def = 0;
-
-    try
+    ClassInfoPtr info = getClassInfoById(id TSRMLS_CC);
+    if(!info)
     {
-        Slice::TypePtr type;
-        Profile* profile = static_cast<Profile*>(ICE_G(profile));
-        if(profile)
-        {
-            type = profile->lookupType(id);
-        }
-
-        if(!type)
+        if(!id.empty() && id[id.size() - 1] == '*')
         {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "no Slice definition found for type %s", id.c_str());
-            return false;
+            info = getClassInfoById(id.substr(0, id.size() - 1) TSRMLS_CC);
         }
+    }
 
-        Slice::BuiltinPtr b = Slice::BuiltinPtr::dynamicCast(type);
-        if(b && b->kind() != Slice::Builtin::KindObject && b->kind() != Slice::Builtin::KindObjectProxy)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "type %s is not a class or interface", id.c_str());
-            return false;
-        }
-
-        if(!b)
-        {
-            //
-            // Allow the use of "::Type" (ClassDecl) or "::Type*" (Proxy).
-            //
-            Slice::ClassDeclPtr decl;
-            Slice::ProxyPtr proxy = Slice::ProxyPtr::dynamicCast(type);
-            if(proxy)
-            {
-                decl = proxy->_class();
-            }
-            else
-            {
-                decl = Slice::ClassDeclPtr::dynamicCast(type);
-            }
-
-            if(!decl)
-            {
-                php_error_docref(0 TSRMLS_CC, E_ERROR, "type %s is not a class or interface", id.c_str());
-                return false;
-            }
-
-            if(decl->isLocal())
-            {
-                php_error_docref(0 TSRMLS_CC, E_ERROR, "%s is a local type", id.c_str());
-                return false;
-            }
-
-            def = decl->definition();
-            if(!def)
-            {
-                php_error_docref(0 TSRMLS_CC, E_ERROR, "%s is declared but not defined", id.c_str());
-                return false;
-            }
-
-            string scoped = decl->scoped();
-
-            //
-            // Verify that the script has compiled the Slice definition for this type.
-            //
-            if(findClassScoped(scoped TSRMLS_CC) == 0)
-            {
-                php_error_docref(0 TSRMLS_CC, E_ERROR, "the Slice definition for type %s has not been compiled",
-                                 scoped.c_str());
-                return false;
-            }
-        }
+    if(info && !info->defined)
+    {
+        runtimeError("%s is declared but not defined" TSRMLS_CC, id.c_str());
     }
-    catch(const IceUtil::Exception& ex)
+    else if(!info)
     {
-        throwException(ex TSRMLS_CC);
-        return false;
+        runtimeError("no definition found for class or interface %s" TSRMLS_CC, id.c_str());
     }
 
-    return true;
+    return info;
 }
 
 static void
@@ -1889,11 +1227,11 @@ do_cast(INTERNAL_FUNCTION_PARAMETERS, bool check)
     int facetLen;
     zval* arr = 0;
 
-    if(zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|sa", &id, &idLen, &facet,
+    if(zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|s!a!", &id, &idLen, &facet,
                                 &facetLen, &arr) == FAILURE)
     {
         facet = 0;
-        if(zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &id, &idLen, &arr) ==
+        if(zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|a!", &id, &idLen, &arr) ==
                                     FAILURE)
         {
             php_error(E_ERROR, "%s() requires a type id followed by an optional facet and/or context",
@@ -1902,28 +1240,27 @@ do_cast(INTERNAL_FUNCTION_PARAMETERS, bool check)
         }
     }
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC);
+    assert(_this);
 
     //
     // Populate the context.
     //
     Ice::Context ctx;
-    if(arr && !extractContext(arr, ctx TSRMLS_CC))
+    if(arr && !extractStringMap(arr, ctx TSRMLS_CC))
     {
         RETURN_NULL();
     }
 
     try
     {
-        Slice::ClassDefPtr def;
-        if(!lookupClass(id, def TSRMLS_CC))
+        ClassInfoPtr info = lookupClass(id TSRMLS_CC);
+        if(!info)
         {
             RETURN_NULL();
         }
 
-        Ice::ObjectPrx prx = _this->getProxy();
+        Ice::ObjectPrx prx = _this->proxy;
         if(facet)
         {
             prx = prx->ice_facet(facet);
@@ -1936,19 +1273,16 @@ do_cast(INTERNAL_FUNCTION_PARAMETERS, bool check)
 
         if(check)
         {
-            string scoped = def ? def->declaration()->scoped() : "::Ice::Object";
-
             //
-            // Verify that the object supports the requested type. We don't use id here,
-            // because it might contain a proxy type (e.g., "::MyClass*").
+            // Verify that the object supports the requested type.
             //
-            if(!prx->ice_isA(scoped))
+            if(!prx->ice_isA(info->id))
             {
                 RETURN_NULL();
             }
         }
 
-        if(!createProxy(return_value, prx, def TSRMLS_CC))
+        if(!createProxy(return_value, prx, info, _this->communicator TSRMLS_CC))
         {
             RETURN_NULL();
         }
@@ -1960,601 +1294,94 @@ do_cast(INTERNAL_FUNCTION_PARAMETERS, bool check)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_uncheckedCast)
+ZEND_METHOD(Ice_ObjectPrx, ice_uncheckedCast)
 {
     do_cast(INTERNAL_FUNCTION_PARAM_PASSTHRU, false);
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_ice_checkedCast)
+ZEND_METHOD(Ice_ObjectPrx, ice_checkedCast)
 {
     do_cast(INTERNAL_FUNCTION_PARAM_PASSTHRU, true);
 }
 
-ZEND_FUNCTION(Ice_Endpoint___construct)
-{
-    php_error_docref(0 TSRMLS_CC, E_ERROR, "Ice_Endpoint cannot be instantiated");
-}
-
-ZEND_FUNCTION(Ice_Endpoint___tostring)
-{
-    if(ZEND_NUM_ARGS() > 0)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::EndpointPtr* _this = static_cast<Ice::EndpointPtr*>(obj->ptr);
-
-    try
-    {
-        string str = (*_this)->toString();
-        RETURN_STRINGL(const_cast<char*>(str.c_str()), str.length(), 1);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Endpoint_toString)
-{
-    ZEND_FN(Ice_Endpoint___tostring)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-}
-
-ZEND_FUNCTION(Ice_Connection___construct)
-{
-    php_error_docref(0 TSRMLS_CC, E_ERROR, "Ice_Connection cannot be instantiated");
-}
-
-ZEND_FUNCTION(Ice_Connection___tostring)
-{
-    if(ZEND_NUM_ARGS() > 0)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    try
-    {
-        string str = (*_this)->toString();
-        RETURN_STRINGL(const_cast<char*>(str.c_str()), str.length(), 1);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Connection_close)
-{
-    if(ZEND_NUM_ARGS() != 1)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    zend_bool b;
-    if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &b TSRMLS_CC) != SUCCESS)
-    {
-        RETURN_NULL();
-    }
-
-    try
-    {
-        (*_this)->close(b ? true : false);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Connection_flushBatchRequests)
-{
-    if(ZEND_NUM_ARGS() > 0)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    try
-    {
-        (*_this)->flushBatchRequests();
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Connection_type)
-{
-    if(ZEND_NUM_ARGS() > 0)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    try
-    {
-        string str = (*_this)->type();
-        RETURN_STRINGL(const_cast<char*>(str.c_str()), str.length(), 1);
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Connection_timeout)
-{
-    if(ZEND_NUM_ARGS() != 0)
-    {
-        WRONG_PARAM_COUNT;
-    }
-
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    try
-    {
-        Ice::Int timeout = (*_this)->timeout();
-        ZVAL_LONG(return_value, static_cast<long>(timeout));
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-        RETURN_NULL();
-    }
-}
-
-ZEND_FUNCTION(Ice_Connection_toString)
-{
-    ZEND_FN(Ice_Connection___tostring)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-}
-
-IcePHP::Operation::Operation(const Ice::ObjectPrx& proxy, const string& name, const Slice::OperationPtr& op,
-                             const Ice::CommunicatorPtr& communicator TSRMLS_DC) :
-    _proxy(proxy), _name(name), _op(op), _communicator(communicator), _zendFunction(0)
+IcePHP::Proxy::Proxy(const Ice::ObjectPrx& p, const ClassInfoPtr& i, const CommunicatorInfoPtr& comm TSRMLS_DC) :
+    proxy(p), info(i), communicator(comm), connection(0), cachedConnection(0)
 {
 #ifdef ZTS
     this->TSRMLS_C = TSRMLS_C;
 #endif
-    //
-    // Create Marshaler objects for return type and parameters.
-    //
-    Slice::TypePtr ret = op->returnType();
-    if(ret)
-    {
-        _result = Marshaler::createMarshaler(ret TSRMLS_CC);
-        if(!_result)
-        {
-            return;
-        }
-    }
 
-    Slice::ParamDeclList params = op->parameters();
-
-    //
-    // Create an array that indicates how arguments are passed to the operation.
     //
-    zend_arg_info* argInfo = new zend_arg_info[params.size()];
-
-    int i;
-    Slice::ParamDeclList::const_iterator p;
-    for(p = params.begin(), i = 0; p != params.end(); ++p, ++i)
-    {
-        Slice::TypePtr paramType = (*p)->type();
-        MarshalerPtr m = Marshaler::createMarshaler(paramType TSRMLS_CC);
-        if(!m)
-        {
-            break;
-        }
-        _paramNames.push_back((*p)->name());
-        argInfo[i].name = 0;
-        argInfo[i].class_name = 0;
-        argInfo[i].allow_null = 1;
-        Slice::ContainedPtr cont = Slice::ContainedPtr::dynamicCast(paramType);
-        if(cont)
-        {
-            argInfo[i].array_type_hint = ((cont->containedType() == Slice::Contained::ContainedTypeSequence ||
-                                           cont->containedType() == Slice::Contained::ContainedTypeDictionary) ? 1 : 0);
-        }
-        else
-        {
-            argInfo[i].array_type_hint = 0;
-        }
-        argInfo[i].return_reference = 0;
-        argInfo[i].required_num_args = static_cast<zend_uint>(params.size());
-        if((*p)->isOutParam())
-        {
-            argInfo[i].pass_by_reference = 1;
-            _outParams.push_back(m);
-        }
-        else
-        {
-            argInfo[i].pass_by_reference = 0;
-            _inParams.push_back(m);
-        }
-    }
-
-    _zendFunction = static_cast<zend_internal_function*>(emalloc(sizeof(zend_internal_function)));
-    _zendFunction->type = ZEND_INTERNAL_FUNCTION;
-    _zendFunction->function_name = estrndup(const_cast<char*>(name.c_str()), name.length());
-    _zendFunction->scope = proxyClassEntry;
-    _zendFunction->fn_flags = ZEND_ACC_PUBLIC;
-    _zendFunction->prototype = 0;
-    _zendFunction->num_args = static_cast<zend_uint>(params.size());
-    _zendFunction->arg_info = argInfo;
-    _zendFunction->pass_rest_by_reference = 0;
-    _zendFunction->required_num_args = _zendFunction->num_args;
-    _zendFunction->return_reference = 0;
-    _zendFunction->handler = ZEND_FN(Ice_ObjectPrx_call);
-}
-
-IcePHP::Operation::~Operation()
-{
-    if(_zendFunction)
-    {
-        delete []_zendFunction->arg_info;
-        efree(_zendFunction->function_name);
-        efree(_zendFunction);
-    }
-}
-
-zend_function*
-IcePHP::Operation::getZendFunction() const
-{
-    return reinterpret_cast<zend_function*>(_zendFunction);
-}
-
-void
-IcePHP::Operation::invoke(INTERNAL_FUNCTION_PARAMETERS)
-{
-    Ice::OperationMode mode = (Ice::OperationMode)_op->sendMode();
-    int i;
-
-    //
-    // Verify that the expected number of arguments are supplied. The context argument is optional.
-    //
-    int numParams = static_cast<int>(_inParams.size() + _outParams.size());
-    if(ZEND_NUM_ARGS() != numParams && ZEND_NUM_ARGS() != numParams + 1)
-    {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "incorrect number of parameters (%d)", numParams);
-        return;
-    }
-
-    //
-    // Retrieve the arguments.
-    //
-    zval*** args = static_cast<zval***>(emalloc(ZEND_NUM_ARGS() * sizeof(zval**)));
-    AutoEfree autoArgs(args); // Call efree on return
-    if(zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE)
-    {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to get arguments");
-        return;
-    }
-
-    //
-    // Verify that the zvals for out parameters are passed by reference.
+    // We want to ensure that the PHP object corresponding to the communicator is
+    // not destroyed until after this proxy is destroyed.
     //
-    for(i = static_cast<int>(_inParams.size()); i < numParams; ++i)
-    {
-        if(!PZVAL_IS_REF(*args[i]))
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "argument for out parameter %s must be passed by reference",
-                             _paramNames[i].c_str());
-            return;
-        }
-    }
-
-    try
-    {
-        //
-        // Marshal the arguments.
-        //
-        Ice::OutputStreamPtr os = Ice::createOutputStream(_communicator);
-        ObjectMap objectMap;
-        vector<MarshalerPtr>::iterator p;
-        for(i = 0, p = _inParams.begin(); p != _inParams.end(); ++i, ++p)
-        {
-            if(!(*p)->marshal(*args[i], os, objectMap TSRMLS_CC))
-            {
-                return;
-            }
-        }
-
-        if(_op->sendsClasses())
-        {
-            os->writePendingObjects();
-        }
-
-        Ice::ByteSeq params;
-        os->finished(params);
-
-        //
-        // Populate the context (if necessary).
-        //
-        Ice::Context ctx;
-        bool haveContext = false;
-        if(ZEND_NUM_ARGS() == numParams + 1)
-        {
-            if(extractContext(*args[numParams], ctx TSRMLS_CC))
-            {
-                haveContext = true;
-            }
-            else
-            {
-                return;
-            }
-        }
-
-        //
-        // Invoke the operation. Don't use _name here.
-        //
-        Ice::ByteSeq result;
-        bool status;
-        if(haveContext)
-        {
-            status = _proxy->ice_invoke(_op->name(), mode, params, result, ctx);
-        }
-        else
-        {
-            status = _proxy->ice_invoke(_op->name(), mode, params, result);
-        }
-
-        //
-        // Process the reply.
-        //
-        if(_proxy->ice_isTwoway())
-        {
-            Ice::InputStreamPtr is = Ice::createInputStream(_communicator, result);
-
-            if(status)
-            {
-                //
-                // Unmarshal the results.
-                //
-                // TODO: Check for oneway/datagram errors
-                //
-                for(i = _inParams.size(), p = _outParams.begin(); p != _outParams.end(); ++i, ++p)
-                {
-                    //
-                    // We must explicitly destroy the existing contents of all zvals passed
-                    // as out parameters, otherwise leaks occur.
-                    //
-                    zval_dtor(*args[i]);
-                    if(!(*p)->unmarshal(*args[i], is TSRMLS_CC))
-                    {
-                        return;
-                    }
-                }
-                if(_result)
-                {
-                    if(!_result->unmarshal(return_value, is TSRMLS_CC))
-                    {
-                        return;
-                    }
-                }
-                if(_op->returnsClasses())
-                {
-                    is->readPendingObjects();
-                }
-            }
-            else
-            {
-                //
-                // Unmarshal and "throw" a user exception.
-                //
-                throwUserException(is TSRMLS_CC);
-            }
-        }
-    }
-    catch(const AbortMarshaling&)
-    {
-        //
-        // We use AbortMarshaling to escape from any nesting depth if
-        // a PHP exception has already been set.
-        //
-        assert(EG(exception));
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        throwException(ex TSRMLS_CC);
-    }
+    communicator->addRef(TSRMLS_C);
 }
 
-void
-IcePHP::Operation::throwUserException(Ice::InputStreamPtr& is TSRMLS_DC)
+IcePHP::Proxy::~Proxy()
 {
-    Slice::UnitPtr unit = _op->unit();
-
-    is->readBool(); // usesClasses
-
-    string id = is->readString();
-    const string origId = id;
-
-    while(!id.empty())
+    communicator->decRef(TSRMLS_C);
+    if(connection)
     {
-        //
-        // Look for a definition of this type.
-        //
-        Slice::ExceptionPtr ex = unit->lookupException(id, false);
-        if(ex)
-        {
-            if(ex->isLocal())
-            {
-                php_error_docref(0 TSRMLS_CC, E_ERROR, "cannot unmarshal local exception %s", id.c_str());
-                return;
-            }
-
-            MarshalerPtr m = Marshaler::createExceptionMarshaler(ex TSRMLS_CC);
-            assert(m);
-
-            zval* zex;
-            MAKE_STD_ZVAL(zex);
-            if(m->unmarshal(zex, is TSRMLS_CC))
-            {
-                if(ex->usesClasses())
-                {
-                    is->readPendingObjects();
-                }
-                zend_throw_exception_object(zex TSRMLS_CC);
-            }
-            else
-            {
-                zval_dtor(zex);
-            }
-
-            return;
-        }
-        else
-        {
-            is->skipSlice();
-
-            try
-            {
-                id = is->readString();
-            }
-            catch(Ice::UnmarshalOutOfBoundsException& ex)
-            {
-                //
-                // When readString raises this exception it means we've reached the last slice,
-                // so we set the reason member to a more helpful value.
-                //
-                ex.reason = "unknown exception type `" + origId + "'";
-                throw;
-            }
-        }
+        zval_ptr_dtor(&connection);
     }
-    //
-    // Getting here should be impossible: we can get here only if the
-    // sender has marshaled a sequence of type IDs, none of which we
-    // have a factory for. This means that sender and receiver disagree
-    // about the Slice definitions they use.
-    //
-    throw Ice::UnknownUserException(__FILE__, __LINE__);
-}
-
-IcePHP::Proxy::Proxy(const Ice::ObjectPrx& proxy, const Slice::ClassDefPtr& cls TSRMLS_DC) :
-    _proxy(proxy), _class(cls)
-{
-#ifdef ZTS
-    this->TSRMLS_C = TSRMLS_C;
-#endif
-
-    //
-    // We want to ensure that the PHP object corresponding to the communicator is
-    // not destroyed until after this proxy is destroyed. We keep a copy of the
-    // communicator's zval because the symbol table holding the communicator's zval
-    // may be destroyed before this proxy, therefore our destructor cannot rely on
-    // symbol table lookup when it needs to decrement the reference count.
-    //
-    zval* zc = getCommunicatorZval(TSRMLS_C);
-    _communicatorZval = *zc; // This is legal - it simply copies the object's handle
-    Z_OBJ_HT(_communicatorZval)->add_ref(&_communicatorZval TSRMLS_CC);
-
-    _communicator = getCommunicator(TSRMLS_C);
-
-    if(cls)
+    if(cachedConnection)
     {
-        _classOps = _class->allOperations();
+        zval_ptr_dtor(&cachedConnection);
     }
 }
 
-IcePHP::Proxy::~Proxy()
-{
-    //
-    // In order to avoid the communicator's "leak warning", we have to ensure that we
-    // remove any references to the communicator or its supporting objects. This must
-    // be done prior to invoking del_ref(), because the C++ communicator object may
-    // be destroyed during this call.
-    // 
-    _communicator = 0;
-    _ops.clear();
-    _proxy = 0;
-    Z_OBJ_HT(_communicatorZval)->del_ref(&_communicatorZval TSRMLS_CC);
-}
-
-const Ice::ObjectPrx&
-IcePHP::Proxy::getProxy() const
+bool
+IcePHP::Proxy::clone(zval* zv, const Ice::ObjectPrx& p TSRMLS_DC)
 {
-    return _proxy;
+    return create(zv, p, info, communicator TSRMLS_CC);
 }
 
-const Slice::ClassDefPtr&
-IcePHP::Proxy::getClass() const
+bool
+IcePHP::Proxy::cloneUntyped(zval* zv, const Ice::ObjectPrx& p TSRMLS_DC)
 {
-    return _class;
+    return create(zv, p, 0, communicator TSRMLS_CC);
 }
 
-OperationPtr
-IcePHP::Proxy::getOperation(const string& name)
+bool
+IcePHP::Proxy::create(zval* zv, const Ice::ObjectPrx& p, const ClassInfoPtr& info, const CommunicatorInfoPtr& comm
+                      TSRMLS_DC)
 {
-    OperationPtr result;
-
-    string n = lowerCase(name);
-    map<string, OperationPtr>::const_iterator p = _ops.find(n);
-    if(p == _ops.end())
+    ClassInfoPtr cls = info;
+    if(!cls)
     {
-        for(Slice::OperationList::const_iterator q = _classOps.begin(); q != _classOps.end(); ++q)
-        {
-            string opName = lowerCase(fixIdent((*q)->name()));
-            if(n == opName)
-            {
-                result = new Operation(_proxy, opName, *q, _communicator TSRMLS_CC);
-                _ops[opName] = result;
-                break;
-            }
-        }
+        cls = getClassInfoById("::Ice::Object" TSRMLS_CC);
+        assert(cls);
     }
-    else
+
+    if(object_init_ex(zv, proxyClassEntry) != SUCCESS)
     {
-        result = p->second;
+        runtimeError("unable to initialize proxy" TSRMLS_CC);
+        return false;
     }
 
-    return result;
-}
+    Wrapper<ProxyPtr>* obj = Wrapper<ProxyPtr>::extract(zv TSRMLS_CC);
+    ProxyPtr proxy = new Proxy(p, cls, comm TSRMLS_CC);
+    assert(!obj->ptr);
+    obj->ptr = new ProxyPtr(proxy);
 
-string
-IcePHP::Proxy::toString() const
-{
-    return _communicator->proxyToString(_proxy);
+    return true;
 }
 
 #ifdef _WIN32
 extern "C"
 #endif
 static zend_object_value
-handleProxyAlloc(zend_class_entry* ce TSRMLS_DC)
+handleAlloc(zend_class_entry* ce TSRMLS_DC)
 {
     zend_object_value result;
 
-    ice_object* obj = newObject(ce TSRMLS_CC);
+    Wrapper<ProxyPtr>* obj = Wrapper<ProxyPtr>::create(ce TSRMLS_CC);
     assert(obj);
 
-    result.handle = zend_objects_store_put(obj, 0, (zend_objects_free_object_storage_t)handleProxyFreeStorage,
+    result.handle = zend_objects_store_put(obj, 0, (zend_objects_free_object_storage_t)handleFreeStorage,
                                            0 TSRMLS_CC);
-    result.handlers = &_proxyHandlers;
+    result.handlers = &_handlers;
 
     return result;
 }
@@ -2563,13 +1390,10 @@ handleProxyAlloc(zend_class_entry* ce TSRMLS_DC)
 extern "C"
 #endif
 static void
-handleProxyFreeStorage(void* p TSRMLS_DC)
+handleFreeStorage(void* p TSRMLS_DC)
 {
-    ice_object* obj = static_cast<ice_object*>(p);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    delete _this;
-
+    Wrapper<ProxyPtr>* obj = static_cast<Wrapper<ProxyPtr>*>(p);
+    delete obj->ptr;
     zend_objects_free_object_storage(static_cast<zend_object*>(p) TSRMLS_CC);
 }
 
@@ -2577,7 +1401,7 @@ handleProxyFreeStorage(void* p TSRMLS_DC)
 extern "C"
 #endif
 static zend_object_value
-handleProxyClone(zval* zv TSRMLS_DC)
+handleClone(zval* zv TSRMLS_DC)
 {
     //
     // Create a new object that shares a C++ proxy instance with this object.
@@ -2586,22 +1410,16 @@ handleProxyClone(zval* zv TSRMLS_DC)
     zend_object_value result;
     memset(&result, 0, sizeof(zend_object_value));
 
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(zv TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
+    ProxyPtr obj = Wrapper<ProxyPtr>::value(zv TSRMLS_CC);
+    assert(obj);
 
     zval* clone;
     MAKE_STD_ZVAL(clone);
-    if(object_init_ex(clone, IcePHP::proxyClassEntry) != SUCCESS)
+    if(!obj->clone(clone, obj->proxy TSRMLS_CC))
     {
-        php_error_docref(0 TSRMLS_CC, E_ERROR, "unable to initialize proxy");
         return result;
     }
 
-    ice_object* cobj = static_cast<ice_object*>(zend_object_store_get_object(clone TSRMLS_CC));
-    assert(!cobj->ptr);
-    cobj->ptr = new Proxy(_this->getProxy(), _this->getClass() TSRMLS_CC);
-
     //
     // We only need to return the new object's handle, so we must destroy the zval containing
     // a reference to the new object. We increment the object's reference count to ensure it
@@ -2619,7 +1437,7 @@ handleProxyClone(zval* zv TSRMLS_DC)
 extern "C"
 #endif
 static union _zend_function*
-handleProxyGetMethod(zval** zv, char* method, int len TSRMLS_DC)
+handleGetMethod(zval** zv, char* method, int len TSRMLS_DC)
 {
     zend_function* result;
 
@@ -2631,27 +1449,23 @@ handleProxyGetMethod(zval** zv, char* method, int len TSRMLS_DC)
     result = zend_get_std_object_handlers()->get_method(zv, method, len TSRMLS_CC);
     if(!result)
     {
-        ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(*zv TSRMLS_CC));
+        Wrapper<ProxyPtr>* obj = Wrapper<ProxyPtr>::extract(*zv TSRMLS_CC);
         assert(obj->ptr);
-        Proxy* _this = static_cast<Proxy*>(obj->ptr);
+        ProxyPtr _this = *obj->ptr;
 
-        Slice::ClassDefPtr def = _this->getClass();
-        if(!def)
-        {
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "unknown method %s invoked on untyped proxy", method);
-            return 0;
-        }
+        ClassInfoPtr info = _this->info;
+        assert(info);
 
-        OperationPtr op = _this->getOperation(method);
+        OperationPtr op = info->getOperation(method);
         if(!op)
         {
-            string scoped = def->scoped();
-            php_error_docref(0 TSRMLS_CC, E_ERROR, "unknown operation %s invoked on proxy of type %s", method,
-                             scoped.c_str());
+            //
+            // Returning 0 causes PHP to report an "undefined method" error.
+            //
             return 0;
         }
 
-        result = op->getZendFunction();
+        result = op->function();
     }
 
     return result;
@@ -2661,21 +1475,21 @@ handleProxyGetMethod(zval** zv, char* method, int len TSRMLS_DC)
 extern "C"
 #endif
 static int
-handleProxyCompare(zval* zobj1, zval* zobj2 TSRMLS_DC)
+handleCompare(zval* zobj1, zval* zobj2 TSRMLS_DC)
 {
     //
     // PHP guarantees that the objects have the same class.
     //
 
-    ice_object* obj1 = static_cast<ice_object*>(zend_object_store_get_object(zobj1 TSRMLS_CC));
+    Wrapper<ProxyPtr>* obj1 = Wrapper<ProxyPtr>::extract(zobj1 TSRMLS_CC);
     assert(obj1->ptr);
-    Proxy* _this1 = static_cast<Proxy*>(obj1->ptr);
-    Ice::ObjectPrx prx1 = _this1->getProxy();
+    ProxyPtr _this1 = *obj1->ptr;
+    Ice::ObjectPrx prx1 = _this1->proxy;
 
-    ice_object* obj2 = static_cast<ice_object*>(zend_object_store_get_object(zobj2 TSRMLS_CC));
+    Wrapper<ProxyPtr>* obj2 = Wrapper<ProxyPtr>::extract(zobj2 TSRMLS_CC);
     assert(obj2->ptr);
-    Proxy* _this2 = static_cast<Proxy*>(obj2->ptr);
-    Ice::ObjectPrx prx2 = _this2->getProxy();
+    ProxyPtr _this2 = *obj2->ptr;
+    Ice::ObjectPrx prx2 = _this2->proxy;
 
     if(prx1 == prx2)
     {
@@ -2691,112 +1505,122 @@ handleProxyCompare(zval* zobj1, zval* zobj2 TSRMLS_DC)
     }
 }
 
-ZEND_FUNCTION(Ice_ObjectPrx_call)
+//
+// Predefined methods for ObjectPrx.
+//
+static function_entry _proxyMethods[] =
 {
-    ice_object* obj = static_cast<ice_object*>(zend_object_store_get_object(getThis() TSRMLS_CC));
-    assert(obj->ptr);
-    Proxy* _this = static_cast<Proxy*>(obj->ptr);
-
-    OperationPtr op = _this->getOperation(get_active_function_name(TSRMLS_C));
-    assert(op); // handleGetethod should have already verified the operation's existence.
-
-    op->invoke(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-}
+    ZEND_ME(Ice_ObjectPrx, __construct, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
+    ZEND_ME(Ice_ObjectPrx, __toString, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getCommunicator, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_toString, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getIdentity, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_identity, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getContext, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_context, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getFacet, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_facet, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getAdapterId, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_adapterId, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getEndpoints, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_endpoints, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getLocatorCacheTimeout, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_locatorCacheTimeout, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isConnectionCached, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_connectionCached, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getEndpointSelection, NULL, ZEND_ACC_PUBLIC)
+    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_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)
+    ZEND_ME(Ice_ObjectPrx, ice_router, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_getLocator, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_locator, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_twoway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isTwoway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_oneway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isOneway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_batchOneway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isBatchOneway, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_datagram, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isDatagram, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_batchDatagram, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_isBatchDatagram, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_compress, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_timeout, NULL, ZEND_ACC_PUBLIC)
+    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_uncheckedCast, NULL, ZEND_ACC_PUBLIC)
+    ZEND_ME(Ice_ObjectPrx, ice_checkedCast, NULL, ZEND_ACC_PUBLIC)
+    {0, 0, 0}
+};
 
-#ifdef _WIN32
-extern "C"
-#endif
-static zend_object_value
-handleEndpointAlloc(zend_class_entry* ce TSRMLS_DC)
+bool
+IcePHP::proxyInit(TSRMLS_D)
 {
-    zend_object_value result;
-
-    ice_object* obj = newObject(ce TSRMLS_CC);
-    assert(obj);
-
-    result.handle = zend_objects_store_put(obj, 0, (zend_objects_free_object_storage_t)handleEndpointFreeStorage,
-                                           0 TSRMLS_CC);
-    result.handlers = &_endpointHandlers;
+    //
+    // Register the ObjectPrx class.
+    //
+    zend_class_entry ce;
+#ifdef ICEPHP_USE_NAMESPACES
+    INIT_NS_CLASS_ENTRY(ce, STRCAST("Ice"), STRCAST("ObjectPrx"), _proxyMethods);
+#else
+    INIT_CLASS_ENTRY(ce, "Ice_ObjectPrx", _proxyMethods);
+#endif
+    ce.create_object = handleAlloc;
+    proxyClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
+    //proxyClassEntry->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
+    memcpy(&_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+    _handlers.clone_obj = handleClone;
+    _handlers.get_method = handleGetMethod;
+    _handlers.compare_objects = handleCompare;
 
-    return result;
+    return true;
 }
 
-#ifdef _WIN32
-extern "C"
-#endif
-static void
-handleEndpointFreeStorage(void* p TSRMLS_DC)
+bool
+IcePHP::createProxy(zval* zv, const Ice::ObjectPrx& p, const CommunicatorInfoPtr& comm TSRMLS_DC)
 {
-    ice_object* obj = static_cast<ice_object*>(p);
-    Ice::EndpointPtr* _this = static_cast<Ice::EndpointPtr*>(obj->ptr);
-
-    delete _this;
-
-    zend_objects_free_object_storage(static_cast<zend_object*>(p) TSRMLS_CC);
+    return Proxy::create(zv, p, 0, comm TSRMLS_CC);
 }
 
-#ifdef _WIN32
-extern "C"
-#endif
-static zend_object_value
-handleConnectionAlloc(zend_class_entry* ce TSRMLS_DC)
+bool
+IcePHP::createProxy(zval* zv, const Ice::ObjectPrx& p, const ClassInfoPtr& info, const CommunicatorInfoPtr& comm
+                    TSRMLS_DC)
 {
-    zend_object_value result;
-
-    ice_object* obj = newObject(ce TSRMLS_CC);
-    assert(obj);
-
-    result.handle = zend_objects_store_put(obj, 0, (zend_objects_free_object_storage_t)handleConnectionFreeStorage,
-                                           0 TSRMLS_CC);
-    result.handlers = &_connectionHandlers;
-
-    return result;
+    return Proxy::create(zv, p, info, comm TSRMLS_CC);
 }
 
-#ifdef _WIN32
-extern "C"
-#endif
-static void
-handleConnectionFreeStorage(void* p TSRMLS_DC)
+bool
+IcePHP::fetchProxy(zval* zv, Ice::ObjectPrx& prx, ClassInfoPtr& cls TSRMLS_DC)
 {
-    ice_object* obj = static_cast<ice_object*>(p);
-    Ice::ConnectionPtr* _this = static_cast<Ice::ConnectionPtr*>(obj->ptr);
-
-    delete _this;
-
-    zend_objects_free_object_storage(static_cast<zend_object*>(p) TSRMLS_CC);
+    CommunicatorInfoPtr comm;
+    return fetchProxy(zv, prx, cls, comm TSRMLS_CC);
 }
 
-#ifdef _WIN32
-extern "C"
-#endif
-static int
-handleConnectionCompare(zval* zobj1, zval* zobj2 TSRMLS_DC)
+bool
+IcePHP::fetchProxy(zval* zv, Ice::ObjectPrx& prx, ClassInfoPtr& cls, CommunicatorInfoPtr& comm TSRMLS_DC)
 {
-    //
-    // PHP guarantees that the objects have the same class.
-    //
-
-    ice_object* obj1 = static_cast<ice_object*>(zend_object_store_get_object(zobj1 TSRMLS_CC));
-    assert(obj1->ptr);
-    Ice::ConnectionPtr* _this1 = static_cast<Ice::ConnectionPtr*>(obj1->ptr);
-    Ice::ConnectionPtr con1 = *_this1;
-
-    ice_object* obj2 = static_cast<ice_object*>(zend_object_store_get_object(zobj2 TSRMLS_CC));
-    assert(obj2->ptr);
-    Ice::ConnectionPtr* _this2 = static_cast<Ice::ConnectionPtr*>(obj2->ptr);
-    Ice::ConnectionPtr con2 = *_this2;
-
-    if(con1 == con2)
-    {
-        return 0;
-    }
-    else if(con1 < con2)
-    {
-        return -1;
-    }
-    else
+    if(!ZVAL_IS_NULL(zv))
     {
-        return 1;
+        if(Z_TYPE_P(zv) != IS_OBJECT || Z_OBJCE_P(zv) != proxyClassEntry)
+        {
+            invalidArgument("value is not a proxy" TSRMLS_CC);
+            return false;
+        }
+        Wrapper<ProxyPtr>* obj = Wrapper<ProxyPtr>::extract(zv TSRMLS_CC);
+        if(!obj)
+        {
+            runtimeError("unable to retrieve proxy object from object store" TSRMLS_CC);
+            return false;
+        }
+        assert(obj->ptr);
+        prx = (*obj->ptr)->proxy;
+        cls = (*obj->ptr)->info;
+        comm = (*obj->ptr)->communicator;
     }
+    return true;
 }