Fixed (ICE-5654) - Update JS mapping to not use global types in NodeJS

1 files changed, 2479 insertions, 2478 deletions

diff --git a/js/src/Ice/BasicStream.js b/js/src/Ice/BasicStream.js
index d0bdb325076..5699993d6af 100644
--- a/js/src/Ice/BasicStream.js
+++ b/js/src/Ice/BasicStream.js
@@ -7,2955 +7,2956 @@
 //
 // **********************************************************************
 
-(function(global){
-    require("Ice/Class");
-    require("Ice/Debug");
-    require("Ice/ExUtil");
-    require("Ice/FormatType");
-    require("Ice/HashMap");
-    require("Ice/Object");
-    require("Ice/OptionalFormat");
-    require("Ice/Protocol");
-    require("Ice/TraceUtil");
-    require("Ice/Buffer");
-    require("Ice/Exception");
-    require("Ice/LocalException");
-    require("Ice/Version");
-    require("Ice/CompactIdRegistry");
-    require("Ice/ArrayUtil");
-    require("Ice/UnknownSlicedObject");
-    
-    var Ice = global.Ice || {};
-    
-    var Debug = Ice.Debug;
-    var ExUtil = Ice.ExUtil;
-    var FormatType = Ice.FormatType;
-    var HashMap = Ice.HashMap;
-    var IceObject = Ice.Object;
-    var OptionalFormat = Ice.OptionalFormat;
-    var Protocol = Ice.Protocol;
-    var TraceUtil = Ice.TraceUtil;
-    var ArrayUtil = Ice.ArrayUtil;
-    var SlicedData = Ice.SlicedData;
-    
-    var SliceType = {};
-    SliceType.NoSlice = 0;
-    SliceType.ObjectSlice = 1;
-    SliceType.ExceptionSlice = 2;
-
-    var OPTIONAL_END_MARKER           = 0xFF;
-    var FLAG_HAS_TYPE_ID_STRING       = (1<<0);
-    var FLAG_HAS_TYPE_ID_INDEX        = (1<<1);
-    var FLAG_HAS_TYPE_ID_COMPACT      = (1<<1 | 1<<0);
-    var FLAG_HAS_OPTIONAL_MEMBERS     = (1<<2);
-    var FLAG_HAS_INDIRECTION_TABLE    = (1<<3);
-    var FLAG_HAS_SLICE_SIZE           = (1<<4);
-    var FLAG_IS_LAST_SLICE            = (1<<5);
-
-    var IndirectPatchEntry = function(index, patcher)
-    {
-        this.index = index;
-        this.patcher = patcher;
-    };
-    
-    var Class = Ice.Class;
-
-    var EncapsDecoder = Class({
-        __init__: function(stream, encaps, sliceObjects, f)
-        {
-            this._stream = stream;
-            this._encaps = encaps;
-            this._sliceObjects = sliceObjects;
-            this._servantFactoryManager = f;
-            this._patchMap = null; // Lazy initialized, HashMap<int, Patcher[] >()
-            this._unmarshaledMap = new HashMap(); // HashMap<int, Ice.Object>()
-            this._typeIdMap = null; // Lazy initialized, HashMap<int, String> 
-            this._typeIdIndex = 0;
-            this._objectList = null; // Lazy initialized. Ice.Object[]
-        },
-        readOpt: function()
-        {
-            return false;
-        },
-        readPendingObjects: function()
-        {
-        },
-        readTypeId: function(isIndex)
+var Ice = require("../Ice/ModuleRegistry").Ice;
+var __M = Ice.__M;
+__M.require(module, "Ice",
+    [
+        "../Ice/Class",
+        "../Ice/Debug",
+        "../Ice/ExUtil",
+        "../Ice/FormatType",
+        "../Ice/HashMap",
+        "../Ice/Object",
+        "../Ice/OptionalFormat",
+        "../Ice/Protocol",
+        "../Ice/TraceUtil",
+        "../Ice/Buffer",
+        "../Ice/Exception",
+        "../Ice/LocalException",
+        "../Ice/Version",
+        "../Ice/CompactIdRegistry",
+        "../Ice/ArrayUtil",
+        "../Ice/UnknownSlicedObject"
+    ]);
+
+var Debug = Ice.Debug;
+var ExUtil = Ice.ExUtil;
+var FormatType = Ice.FormatType;
+var HashMap = Ice.HashMap;
+var IceObject = Ice.Object;
+var OptionalFormat = Ice.OptionalFormat;
+var Protocol = Ice.Protocol;
+var TraceUtil = Ice.TraceUtil;
+var ArrayUtil = Ice.ArrayUtil;
+var SlicedData = Ice.SlicedData;
+
+var SliceType = {};
+SliceType.NoSlice = 0;
+SliceType.ObjectSlice = 1;
+SliceType.ExceptionSlice = 2;
+
+var OPTIONAL_END_MARKER           = 0xFF;
+var FLAG_HAS_TYPE_ID_STRING       = (1<<0);
+var FLAG_HAS_TYPE_ID_INDEX        = (1<<1);
+var FLAG_HAS_TYPE_ID_COMPACT      = (1<<1 | 1<<0);
+var FLAG_HAS_OPTIONAL_MEMBERS     = (1<<2);
+var FLAG_HAS_INDIRECTION_TABLE    = (1<<3);
+var FLAG_HAS_SLICE_SIZE           = (1<<4);
+var FLAG_IS_LAST_SLICE            = (1<<5);
+
+var IndirectPatchEntry = function(index, patcher)
+{
+    this.index = index;
+    this.patcher = patcher;
+};
+
+var Class = Ice.Class;
+
+var EncapsDecoder = Class({
+    __init__: function(stream, encaps, sliceObjects, f)
+    {
+        this._stream = stream;
+        this._encaps = encaps;
+        this._sliceObjects = sliceObjects;
+        this._servantFactoryManager = f;
+        this._patchMap = null; // Lazy initialized, HashMap<int, Patcher[] >()
+        this._unmarshaledMap = new HashMap(); // HashMap<int, Ice.Object>()
+        this._typeIdMap = null; // Lazy initialized, HashMap<int, String> 
+        this._typeIdIndex = 0;
+        this._objectList = null; // Lazy initialized. Ice.Object[]
+    },
+    readOpt: function()
+    {
+        return false;
+    },
+    readPendingObjects: function()
+    {
+    },
+    readTypeId: function(isIndex)
+    {
+        var typeId, index;
+        if(this._typeIdMap === null) // Lazy initialization
         {
-            var typeId, index;
-            if(this._typeIdMap === null) // Lazy initialization
-            {
-                this._typeIdMap = new HashMap(); // Map<int, String>();
-            }
+            this._typeIdMap = new HashMap(); // Map<int, String>();
+        }
 
-            if(isIndex)
-            {
-                index = this._stream.readSize();
-                typeId = this._typeIdMap.get(index);
-                if(typeId === undefined)
-                {
-                    throw new Ice.UnmarshalOutOfBoundsException();
-                }
-            }
-            else
+        if(isIndex)
+        {
+            index = this._stream.readSize();
+            typeId = this._typeIdMap.get(index);
+            if(typeId === undefined)
             {
-                typeId = this._stream.readString();
-                this._typeIdMap.set(++this._typeIdIndex, typeId);
+                throw new Ice.UnmarshalOutOfBoundsException();
             }
-            return typeId;
-        },
-        newInstance: function(typeId)
+        }
+        else
         {
-            //
-            // Try to find a factory registered for the specific type.
-            //
-            var userFactory = this._servantFactoryManager.find(typeId);
-            var v = null;
-            
+            typeId = this._stream.readString();
+            this._typeIdMap.set(++this._typeIdIndex, typeId);
+        }
+        return typeId;
+    },
+    newInstance: function(typeId)
+    {
+        //
+        // Try to find a factory registered for the specific type.
+        //
+        var userFactory = this._servantFactoryManager.find(typeId);
+        var v = null;
+        
+        if(userFactory !== undefined)
+        {
+            v = userFactory.create(typeId);
+        }
+        
+        //
+        // If that fails, invoke the default factory if one has been
+        // registered.
+        //
+        if(v === null || v === undefined)
+        {
+            userFactory = this._servantFactoryManager.find("");
             if(userFactory !== undefined)
             {
                 v = userFactory.create(typeId);
             }
-            
-            //
-            // If that fails, invoke the default factory if one has been
-            // registered.
-            //
-            if(v === null || v === undefined)
-            {
-                userFactory = this._servantFactoryManager.find("");
-                if(userFactory !== undefined)
-                {
-                    v = userFactory.create(typeId);
-                }
-            }
-            
-            //
-            // Last chance: try to instantiate the class dynamically.
-            //
-            if(v === null || v === undefined)
-            {
-                v = this._stream.createObject(typeId);
-            }
+        }
+        
+        //
+        // Last chance: try to instantiate the class dynamically.
+        //
+        if(v === null || v === undefined)
+        {
+            v = this._stream.createObject(typeId);
+        }
 
-            return v;
-        },
-        addPatchEntry: function(index, patcher)
+        return v;
+    },
+    addPatchEntry: function(index, patcher)
+    {
+        Debug.assert(index > 0);
+        //
+        // Check if already un-marshalled the object. If that's the case,
+        // just patch the object smart pointer and we're done.
+        //
+        var obj = this._unmarshaledMap.get(index);
+        if(obj !== undefined && obj !== null)
         {
-            Debug.assert(index > 0);
-            //
-            // Check if already un-marshalled the object. If that's the case,
-            // just patch the object smart pointer and we're done.
-            //
-            var obj = this._unmarshaledMap.get(index);
-            if(obj !== undefined && obj !== null)
-            {
-                patcher.call(null, obj);
-                return;
-            }
+            patcher.call(null, obj);
+            return;
+        }
 
-            if(this._patchMap === null) // Lazy initialization
-            {
-                this._patchMap = new HashMap(); // HashMap<Integer, Patcher[] >();
-            }
+        if(this._patchMap === null) // Lazy initialization
+        {
+            this._patchMap = new HashMap(); // HashMap<Integer, Patcher[] >();
+        }
 
+        //
+        // Add patch entry if the object isn't un-marshalled yet,
+        // the smart pointer will be patched when the instance is
+        // un-marshalled.
+        //
+        var l = this._patchMap.get(index);
+        if(l === undefined)
+        {
             //
-            // Add patch entry if the object isn't un-marshalled yet,
-            // the smart pointer will be patched when the instance is
-            // un-marshalled.
+            // We have no outstanding instances to be patched for this
+            // index, so make a new entry in the patch map.
             //
-            var l = this._patchMap.get(index);
-            if(l === undefined)
-            {
-                //
-                // We have no outstanding instances to be patched for this
-                // index, so make a new entry in the patch map.
-                //
-                l = []; // Patcher[];
-                this._patchMap.set(index, l);
-            }
+            l = []; // Patcher[];
+            this._patchMap.set(index, l);
+        }
 
-            //
-            // Append a patch entry for this instance.
-            //
-            l.push(patcher);
-        },
-        unmarshal: function(index, v)
+        //
+        // Append a patch entry for this instance.
+        //
+        l.push(patcher);
+    },
+    unmarshal: function(index, v)
+    {
+        var i, length, l;
+        //
+        // Add the object to the map of un-marshalled objects, this must
+        // be done before reading the objects (for circular references).
+        //
+        this._unmarshaledMap.set(index, v);
+        
+        //
+        // Read the object.
+        //
+        v.__read(this._stream);
+        if(this._patchMap !== null)
         {
-            var i, length, l;
             //
-            // Add the object to the map of un-marshalled objects, this must
-            // be done before reading the objects (for circular references).
+            // Patch all instances now that the object is un-marshalled.
             //
-            this._unmarshaledMap.set(index, v);
-            
-            //
-            // Read the object.
-            //
-            v.__read(this._stream);
-            if(this._patchMap !== null)
+            l = this._patchMap.get(index);
+            if(l !== undefined)
             {
+                Debug.assert(l.length > 0);
                 //
-                // Patch all instances now that the object is un-marshalled.
+                // Patch all pointers that refer to the instance.
                 //
-                l = this._patchMap.get(index);
-                if(l !== undefined)
-                {
-                    Debug.assert(l.length > 0);
-                    //
-                    // Patch all pointers that refer to the instance.
-                    //
-                    for(i = 0, length = l.length; i < length; ++i)
-                    {
-                        l[i](v);
-                    }
-                    //
-                    // Clear out the patch map for that index -- there is nothing left
-                    // to patch for that index for the time being.
-                    //
-                    this._patchMap.delete(index);
-                }
-            }
-            
-            if((this._patchMap === null || this._patchMap.size === 0) && this._objectList === null)
-            {
-                try
-                {
-                    v.ice_postUnmarshal();
-                }
-                catch(ex)
+                for(i = 0, length = l.length; i < length; ++i)
                 {
-                    this._stream.instance.initializationData().logger.warning("exception raised by ice_postUnmarshal:\n" + 
-                                                                            ExUtil.toString(ex));
-                }
-            }
-            else
-            {
-                if(this._objectList === null) // Lazy initialization
-                {
-                    this._objectList = []; // Ice.Object[]
-                }
-                this._objectList.push(v);
-                
-                if(this._patchMap === null || this._patchMap.size === 0)
-                {
-                    //
-                    // Iterate over the object list and invoke ice_postUnmarshal on
-                    // each object.  We must do this after all objects have been
-                    // unmarshaled in order to ensure that any object data members
-                    // have been properly patched.
-                    //
-                    for(i = 0, length = this._objectList.length; i < length; i++)
-                    {
-                        try
-                        {
-                            this._objectList[i].ice_postUnmarshal();
-                        }
-                        catch(ex)
-                        {
-                            this._stream.instance.initializationData().logger.warning(
-                                                                "exception raised by ice_postUnmarshal:\n" + ExUtil.toString(ex));
-                        }
-                    }
-                    this._objectList = [];
+                    l[i](v);
                 }
+                //
+                // Clear out the patch map for that index -- there is nothing left
+                // to patch for that index for the time being.
+                //
+                this._patchMap.delete(index);
             }
         }
-    });
-    
-    var EncapsDecoder10 = Class(EncapsDecoder, {
-        __init__: function(stream, encaps, sliceObjects, f)
-        {
-            EncapsDecoder.call(this, stream, encaps, sliceObjects, f);
-            this._sliceType = SliceType.NoSlice;
-        },
-        readObject: function(patcher)
+        
+        if((this._patchMap === null || this._patchMap.size === 0) && this._objectList === null)
         {
-            Debug.assert(patcher !== null);
-            
-            //
-            // Object references are encoded as a negative integer in 1.0.
-            //
-            var index = this._stream.readInt();
-            if(index > 0)
+            try
             {
-                throw new Ice.MarshalException("invalid object id");
+                v.ice_postUnmarshal();
             }
-            index = -index;
-
-            if(index === 0)
+            catch(ex)
             {
-                patcher.call(null, null);
+                this._stream.instance.initializationData().logger.warning("exception raised by ice_postUnmarshal:\n" + 
+                                                                        ExUtil.toString(ex));
             }
-            else
+        }
+        else
+        {
+            if(this._objectList === null) // Lazy initialization
             {
-                this.addPatchEntry(index, patcher);
+                this._objectList = []; // Ice.Object[]
             }
-        },
-        throwException: function()
-        {
-            Debug.assert(this._sliceType === SliceType.NoSlice);
-
-            //
-            // User exception with the 1.0 encoding start with a boolean flag
-            // that indicates whether or not the exception has classes.
-            //
-            // This allows reading the pending objects even if some part of
-            // the exception was sliced.
-            //
-            var usesClasses = this._stream.readBool();
-            this._sliceType = SliceType.ExceptionSlice;
-            this._skipFirstSlice = false;
-
-            //
-            // Read the first slice header.
-            //
-            this.startSlice();
-            var mostDerivedId = this._typeId;
-            while(true)
+            this._objectList.push(v);
+            
+            if(this._patchMap === null || this._patchMap.size === 0)
             {
-                var userEx = this._stream.createUserException(this._typeId);
-
                 //
-                // We found the exception.
+                // Iterate over the object list and invoke ice_postUnmarshal on
+                // each object.  We must do this after all objects have been
+                // unmarshaled in order to ensure that any object data members
+                // have been properly patched.
                 //
-                if(userEx !== null)
+                for(i = 0, length = this._objectList.length; i < length; i++)
                 {
-                    userEx.__read(this._stream);
-                    if(usesClasses)
+                    try
                     {
-                        this.readPendingObjects();
+                        this._objectList[i].ice_postUnmarshal();
                     }
-                    throw userEx;
-
-                    // Never reached.
-                }
-
-                //
-                // Slice off what we don't understand.
-                //
-                this.skipSlice();
-                try
-                {
-                    this.startSlice();
-                }
-                catch(ex)
-                {
-                    //
-                    // An oversight in the 1.0 encoding means there is no marker to indicate
-                    // the last slice of an exception. As a result, we just try to read the
-                    // next type ID, which raises UnmarshalOutOfBoundsException when the
-                    // input buffer underflows.
-                    //
-                    // Set the reason member to a more helpful message.
-                    //
-                    if(ex instanceof Ice.UnmarshalOutOfBoundsException)
+                    catch(ex)
                     {
-                        ex.reason = "unknown exception type `" + mostDerivedId + "'";
+                        this._stream.instance.initializationData().logger.warning(
+                                                            "exception raised by ice_postUnmarshal:\n" + ExUtil.toString(ex));
                     }
-                    throw ex;
                 }
+                this._objectList = [];
             }
-        },
-        startInstance: function(sliceType)
+        }
+    }
+});
+
+var EncapsDecoder10 = Class(EncapsDecoder, {
+    __init__: function(stream, encaps, sliceObjects, f)
+    {
+        EncapsDecoder.call(this, stream, encaps, sliceObjects, f);
+        this._sliceType = SliceType.NoSlice;
+    },
+    readObject: function(patcher)
+    {
+        Debug.assert(patcher !== null);
+        
+        //
+        // Object references are encoded as a negative integer in 1.0.
+        //
+        var index = this._stream.readInt();
+        if(index > 0)
         {
-            Debug.assert(this._sliceType === sliceType);
-            this._skipFirstSlice = true;
-        },
-        endInstance: function(/*preserve*/)
+            throw new Ice.MarshalException("invalid object id");
+        }
+        index = -index;
+
+        if(index === 0)
+        {
+            patcher.call(null, null);
+        }
+        else
         {
-            var sz;
+            this.addPatchEntry(index, patcher);
+        }
+    },
+    throwException: function()
+    {
+        Debug.assert(this._sliceType === SliceType.NoSlice);
+
+        //
+        // User exception with the 1.0 encoding start with a boolean flag
+        // that indicates whether or not the exception has classes.
+        //
+        // This allows reading the pending objects even if some part of
+        // the exception was sliced.
+        //
+        var usesClasses = this._stream.readBool();
+        this._sliceType = SliceType.ExceptionSlice;
+        this._skipFirstSlice = false;
+
+        //
+        // Read the first slice header.
+        //
+        this.startSlice();
+        var mostDerivedId = this._typeId;
+        while(true)
+        {
+            var userEx = this._stream.createUserException(this._typeId);
+
             //
-            // Read the Ice::Object slice.
+            // We found the exception.
             //
-            if(this._sliceType === SliceType.ObjectSlice)
+            if(userEx !== null)
             {
-                this.startSlice();
-                sz = this._stream.readSize(); // For compatibility with the old AFM.
-                if(sz !== 0)
+                userEx.__read(this._stream);
+                if(usesClasses)
                 {
-                    throw new Ice.MarshalException("invalid Object slice");
+                    this.readPendingObjects();
                 }
-                this.endSlice();
-            }
+                throw userEx;
 
-            this._sliceType = SliceType.NoSlice;
-            return null;
-        },
-        startSlice: function()
-        {
-            var isIndex;
-            //
-            // If first slice, don't read the header, it was already read in
-            // readInstance or throwException to find the factory.
-            //
-            if(this._skipFirstSlice)
-            {
-                this._skipFirstSlice = false;
-                return this._typeId;
+                // Never reached.
             }
 
             //
-            // For objects, first read the type ID boolean which indicates
-            // whether or not the type ID is encoded as a string or as an
-            // index. For exceptions, the type ID is always encoded as a 
-            // string.
+            // Slice off what we don't understand.
             //
-            if(this._sliceType === SliceType.ObjectSlice) // For exceptions, the type ID is always encoded as a string
+            this.skipSlice();
+            try
             {
-                isIndex = this._stream.readBool();
-                this._typeId = this.readTypeId(isIndex);
+                this.startSlice();
             }
-            else
+            catch(ex)
             {
-                this._typeId = this._stream.readString();
+                //
+                // An oversight in the 1.0 encoding means there is no marker to indicate
+                // the last slice of an exception. As a result, we just try to read the
+                // next type ID, which raises UnmarshalOutOfBoundsException when the
+                // input buffer underflows.
+                //
+                // Set the reason member to a more helpful message.
+                //
+                if(ex instanceof Ice.UnmarshalOutOfBoundsException)
+                {
+                    ex.reason = "unknown exception type `" + mostDerivedId + "'";
+                }
+                throw ex;
             }
-
-            this._sliceSize = this._stream.readInt();
-            if(this._sliceSize < 4)
+        }
+    },
+    startInstance: function(sliceType)
+    {
+        Debug.assert(this._sliceType === sliceType);
+        this._skipFirstSlice = true;
+    },
+    endInstance: function(/*preserve*/)
+    {
+        var sz;
+        //
+        // Read the Ice::Object slice.
+        //
+        if(this._sliceType === SliceType.ObjectSlice)
+        {
+            this.startSlice();
+            sz = this._stream.readSize(); // For compatibility with the old AFM.
+            if(sz !== 0)
             {
-                throw new Ice.UnmarshalOutOfBoundsException();
+                throw new Ice.MarshalException("invalid Object slice");
             }
+            this.endSlice();
+        }
 
+        this._sliceType = SliceType.NoSlice;
+        return null;
+    },
+    startSlice: function()
+    {
+        var isIndex;
+        //
+        // If first slice, don't read the header, it was already read in
+        // readInstance or throwException to find the factory.
+        //
+        if(this._skipFirstSlice)
+        {
+            this._skipFirstSlice = false;
             return this._typeId;
-        },
-        endSlice: function()
+        }
+
+        //
+        // For objects, first read the type ID boolean which indicates
+        // whether or not the type ID is encoded as a string or as an
+        // index. For exceptions, the type ID is always encoded as a 
+        // string.
+        //
+        if(this._sliceType === SliceType.ObjectSlice) // For exceptions, the type ID is always encoded as a string
         {
-        },
-        skipSlice: function()
+            isIndex = this._stream.readBool();
+            this._typeId = this.readTypeId(isIndex);
+        }
+        else
         {
-            if(this._stream.instance.traceLevels().slicing > 0)
-            {
-                var logger = this._stream.instance.initializationData().logger;
-                if(this._sliceType === SliceType.ObjectSlice)
-                {
-                    TraceUtil.traceSlicing("object", this._typeId, this._stream.instance.traceLevels().slicingCat, logger);
-                }
-                else
-                {
-                    TraceUtil.traceSlicing("exception", this._typeId, this._stream.instance.traceLevels().slicingCat, logger);
-                }
-            }
-            Debug.assert(this._sliceSize >= 4);
-            this._stream.skip(this._sliceSize - 4);
-        },
-        readPendingObjects: function()
+            this._typeId = this._stream.readString();
+        }
+
+        this._sliceSize = this._stream.readInt();
+        if(this._sliceSize < 4)
+        {
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+
+        return this._typeId;
+    },
+    endSlice: function()
+    {
+    },
+    skipSlice: function()
+    {
+        if(this._stream.instance.traceLevels().slicing > 0)
         {
-            var k, num;
-            do
+            var logger = this._stream.instance.initializationData().logger;
+            if(this._sliceType === SliceType.ObjectSlice)
             {
-                num = this._stream.readSize();
-                for(k = num; k > 0; --k)
-                {
-                    this.readInstance();
-                }
+                TraceUtil.traceSlicing("object", this._typeId, this._stream.instance.traceLevels().slicingCat, logger);
             }
-            while(num > 0);
-
-            if(this._patchMap !== null && this._patchMap.size !== 0)
+            else
             {
-                //
-                // If any entries remain in the patch map, the sender has sent an index for an object, but failed
-                // to supply the object.
-                //
-                throw new Ice.MarshalException("index for class received, but no instance");
+                TraceUtil.traceSlicing("exception", this._typeId, this._stream.instance.traceLevels().slicingCat, logger);
             }
-        },
-        readInstance: function()
+        }
+        Debug.assert(this._sliceSize >= 4);
+        this._stream.skip(this._sliceSize - 4);
+    },
+    readPendingObjects: function()
+    {
+        var k, num;
+        do
         {
-            var index = this._stream.readInt(),
-                mostDerivedId,
-                v = null;
-
-            if(index <= 0)
+            num = this._stream.readSize();
+            for(k = num; k > 0; --k)
             {
-                throw new Ice.MarshalException("invalid object id");
+                this.readInstance();
             }
+        }
+        while(num > 0);
 
-            this._sliceType = SliceType.ObjectSlice;
-            this._skipFirstSlice = false;
+        if(this._patchMap !== null && this._patchMap.size !== 0)
+        {
+            //
+            // If any entries remain in the patch map, the sender has sent an index for an object, but failed
+            // to supply the object.
+            //
+            throw new Ice.MarshalException("index for class received, but no instance");
+        }
+    },
+    readInstance: function()
+    {
+        var index = this._stream.readInt(),
+            mostDerivedId,
+            v = null;
+
+        if(index <= 0)
+        {
+            throw new Ice.MarshalException("invalid object id");
+        }
+
+        this._sliceType = SliceType.ObjectSlice;
+        this._skipFirstSlice = false;
 
+        //
+        // Read the first slice header.
+        //
+        this.startSlice();
+        mostDerivedId = this._typeId;
+        while(true)
+        {
             //
-            // Read the first slice header.
+            // For the 1.0 encoding, the type ID for the base Object class
+            // marks the last slice.
             //
-            this.startSlice();
-            mostDerivedId = this._typeId;
-            while(true)
+            if(this._typeId == IceObject.ice_staticId())
             {
-                //
-                // For the 1.0 encoding, the type ID for the base Object class
-                // marks the last slice.
-                //
-                if(this._typeId == IceObject.ice_staticId())
-                {
-                    throw new Ice.NoObjectFactoryException("", mostDerivedId);
-                }
+                throw new Ice.NoObjectFactoryException("", mostDerivedId);
+            }
 
-                v = this.newInstance(this._typeId);
+            v = this.newInstance(this._typeId);
 
-                //
-                // We found a factory, we get out of this loop.
-                //
-                if(v)
-                {
-                    break;
-                }
-
-                //
-                // If object slicing is disabled, stop un-marshalling.
-                //
-                if(!this._sliceObjects)
-                {
-                    throw new Ice.NoObjectFactoryException("object slicing is disabled", this._typeId);
-                }
+            //
+            // We found a factory, we get out of this loop.
+            //
+            if(v)
+            {
+                break;
+            }
 
-                //
-                // Slice off what we don't understand.
-                //
-                this.skipSlice();
-                this.startSlice(); // Read next Slice header for next iteration.
+            //
+            // If object slicing is disabled, stop un-marshalling.
+            //
+            if(!this._sliceObjects)
+            {
+                throw new Ice.NoObjectFactoryException("object slicing is disabled", this._typeId);
             }
 
             //
-            // Un-marshal the object and add-it to the map of un-marshaled objects.
+            // Slice off what we don't understand.
             //
-            this.unmarshal(index, v);
+            this.skipSlice();
+            this.startSlice(); // Read next Slice header for next iteration.
         }
-    });
 
-    var EncapsDecoder11 = Class(EncapsDecoder, {
-        __init__: function(stream, encaps, sliceObjects, f)
+        //
+        // Un-marshal the object and add-it to the map of un-marshaled objects.
+        //
+        this.unmarshal(index, v);
+    }
+});
+
+var EncapsDecoder11 = Class(EncapsDecoder, {
+    __init__: function(stream, encaps, sliceObjects, f)
+    {
+        EncapsDecoder.call(this, stream, encaps, sliceObjects, f);
+        this._current = null;
+        this._objectIdIndex = 1;
+    },
+    readObject: function(patcher)
+    {
+        Debug.assert(patcher !== undefined);
+        var index = this._stream.readSize();
+            
+        if(index < 0)
         {
-            EncapsDecoder.call(this, stream, encaps, sliceObjects, f);
-            this._current = null;
-            this._objectIdIndex = 1;
-        },
-        readObject: function(patcher)
+            throw new Ice.MarshalException("invalid object id");
+        }
+        
+        if(index === 0)
         {
-            Debug.assert(patcher !== undefined);
-            var index = this._stream.readSize();
-                
-            if(index < 0)
-            {
-                throw new Ice.MarshalException("invalid object id");
-            }
-            
-            if(index === 0)
+            if(patcher !== null)
             {
-                if(patcher !== null)
-                {
-                    patcher.call(null, null);
-                }
+                patcher.call(null, null);
             }
-            else if(this._current !== null && (this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
+        }
+        else if(this._current !== null && (this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
+        {
+            //
+            // When reading an object within a slice and there's an
+            // indirect object table, always read an indirect reference
+            // that points to an object from the indirect object table
+            // marshaled at the end of the Slice.
+            //
+            // Maintain a list of indirect references. Note that the
+            // indirect index starts at 1, so we decrement it by one to
+            // derive an index into the indirection table that we'll read
+            // at the end of the slice.
+            //
+            if(patcher !== null)
             {
-                //
-                // When reading an object within a slice and there's an
-                // indirect object table, always read an indirect reference
-                // that points to an object from the indirect object table
-                // marshaled at the end of the Slice.
-                //
-                // Maintain a list of indirect references. Note that the
-                // indirect index starts at 1, so we decrement it by one to
-                // derive an index into the indirection table that we'll read
-                // at the end of the slice.
-                //
-                if(patcher !== null)
+                if(this._current.indirectPatchList === null) // Lazy initialization
                 {
-                    if(this._current.indirectPatchList === null) // Lazy initialization
-                    {
-                        this._current.indirectPatchList = []; // IndirectPatchEntry[]
-                    }
-                    var e = new IndirectPatchEntry();
-                    e.index = index - 1;
-                    e.patcher = patcher;
-                    this._current.indirectPatchList.push(e);
+                    this._current.indirectPatchList = []; // IndirectPatchEntry[]
                 }
+                var e = new IndirectPatchEntry();
+                e.index = index - 1;
+                e.patcher = patcher;
+                this._current.indirectPatchList.push(e);
             }
-            else
-            {
-                this.readInstance(index, patcher);
-            }
-        },
-        throwException: function()
+        }
+        else
         {
-            Debug.assert(this._current === null);
-            this.push(SliceType.ExceptionSlice);
+            this.readInstance(index, patcher);
+        }
+    },
+    throwException: function()
+    {
+        Debug.assert(this._current === null);
+        this.push(SliceType.ExceptionSlice);
+
+        //
+        // Read the first slice header.
+        //
+        this.startSlice();
+        var mostDerivedId = this._current.typeId;
+        while(true)
+        {
+            
+            var userEx = this._stream.createUserException(this._current.typeId);
 
             //
-            // Read the first slice header.
+            // We found the exception.
             //
-            this.startSlice();
-            var mostDerivedId = this._current.typeId;
-            while(true)
+            if(userEx !== null)
             {
-                
-                var userEx = this._stream.createUserException(this._current.typeId);
-
-                //
-                // We found the exception.
-                //
-                if(userEx !== null)
-                {
-                    userEx.__read(this._stream);
-                    throw userEx;
+                userEx.__read(this._stream);
+                throw userEx;
 
-                    // Never reached.
-                }
+                // Never reached.
+            }
 
-                //
-                // Slice off what we don't understand.
-                //
-                this.skipSlice();
+            //
+            // Slice off what we don't understand.
+            //
+            this.skipSlice();
 
-                if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0)
+            if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0)
+            {
+                if(mostDerivedId.indexOf("::") === 0)
                 {
-                    if(mostDerivedId.indexOf("::") === 0)
-                    {
-                        throw new Ice.UnknownUserException(mostDerivedId.substr(2));
-                    }
-                    throw new Ice.UnknownUserException(mostDerivedId);
+                    throw new Ice.UnknownUserException(mostDerivedId.substr(2));
                 }
-
-                this.startSlice();
+                throw new Ice.UnknownUserException(mostDerivedId);
             }
-        },
-        startInstance: function(sliceType)
+
+            this.startSlice();
+        }
+    },
+    startInstance: function(sliceType)
+    {
+        Debug.assert(sliceType !== undefined);
+        Debug.assert(this._current.sliceType !== null && this._current.sliceType === sliceType);
+        this._current.skipFirstSlice = true;
+    },
+    endInstance: function(preserve)
+    {
+        var slicedData = null;
+        if(preserve)
         {
-            Debug.assert(sliceType !== undefined);
-            Debug.assert(this._current.sliceType !== null && this._current.sliceType === sliceType);
-            this._current.skipFirstSlice = true;
-        },
-        endInstance: function(preserve)
+            slicedData = this.readSlicedData();
+        }
+        if(this._current.slices !== null)
         {
-            var slicedData = null;
-            if(preserve)
-            {
-                slicedData = this.readSlicedData();
-            }
-            if(this._current.slices !== null)
-            {
-                this._current.slices.length = 0; // Clear the array.
-                this._current.indirectionTables.length = 0; // Clear the array.
-            }
-            this._current = this._current.previous;
-            return slicedData;
-        },
-        startSlice: function()
+            this._current.slices.length = 0; // Clear the array.
+            this._current.indirectionTables.length = 0; // Clear the array.
+        }
+        this._current = this._current.previous;
+        return slicedData;
+    },
+    startSlice: function()
+    {
+        //
+        // If first slice, don't read the header, it was already read in
+        // readInstance or throwException to find the factory.
+        //
+        if(this._current.skipFirstSlice)
         {
-            //
-            // If first slice, don't read the header, it was already read in
-            // readInstance or throwException to find the factory.
-            //
-            if(this._current.skipFirstSlice)
-            {
-                this._current.skipFirstSlice = false;
-                return this._current.typeId;
-            }
+            this._current.skipFirstSlice = false;
+            return this._current.typeId;
+        }
 
-            this._current.sliceFlags = this._stream.readByte();
+        this._current.sliceFlags = this._stream.readByte();
 
-            //
-            // Read the type ID, for object slices the type ID is encoded as a
-            // string or as an index, for exceptions it's always encoded as a
-            // string.
-            //
-            if(this._current.sliceType === SliceType.ObjectSlice)
+        //
+        // Read the type ID, for object slices the type ID is encoded as a
+        // string or as an index, for exceptions it's always encoded as a
+        // string.
+        //
+        if(this._current.sliceType === SliceType.ObjectSlice)
+        {
+            if((this._current.sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) === FLAG_HAS_TYPE_ID_COMPACT) // Must be checked 1st!
             {
-                if((this._current.sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) === FLAG_HAS_TYPE_ID_COMPACT) // Must be checked 1st!
-                {
-                    this._current.typeId = "";
-                    this._current.compactId = this._stream.readSize();
-                }
-                else if((this._current.sliceFlags & (FLAG_HAS_TYPE_ID_INDEX | FLAG_HAS_TYPE_ID_STRING)) !== 0)
-                {
-                    this._current.typeId = this.readTypeId((this._current.sliceFlags & FLAG_HAS_TYPE_ID_INDEX) !== 0);
-                    this._current.compactId = -1;
-                }
-                else
-                {
-                    // Only the most derived slice encodes the type ID for the compact format.
-                    this._current.typeId = "";
-                    this._current.compactId = -1;
-                }
+                this._current.typeId = "";
+                this._current.compactId = this._stream.readSize();
+            }
+            else if((this._current.sliceFlags & (FLAG_HAS_TYPE_ID_INDEX | FLAG_HAS_TYPE_ID_STRING)) !== 0)
+            {
+                this._current.typeId = this.readTypeId((this._current.sliceFlags & FLAG_HAS_TYPE_ID_INDEX) !== 0);
+                this._current.compactId = -1;
             }
             else
             {
-                this._current.typeId = this._stream.readString();
+                // Only the most derived slice encodes the type ID for the compact format.
+                this._current.typeId = "";
                 this._current.compactId = -1;
             }
+        }
+        else
+        {
+            this._current.typeId = this._stream.readString();
+            this._current.compactId = -1;
+        }
+
+        //
+        // Read the slice size if necessary.
+        //
+        if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+        {
+            this._current.sliceSize = this._stream.readInt();
+            if(this._current.sliceSize < 4)
+            {
+                throw new Ice.UnmarshalOutOfBoundsException();
+            }
+        }
+        else
+        {
+            this._current.sliceSize = 0;
+        }
+        return this._current.typeId;
+    },
+    endSlice: function()
+    {
+        var e,
+            i, 
+            indirectionTable = [],
+            length;
+        
+        if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
+        {
+            this._stream.skipOpts();
+        }
 
+        //
+        // Read the indirection table if one is present and transform the
+        // indirect patch list into patch entries with direct references.
+        //
+        if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
+        {
             //
-            // Read the slice size if necessary.
+            // The table is written as a sequence<size> to conserve space.
             //
-            if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+            length = this._stream.readAndCheckSeqSize(1);
+            for(i = 0; i < length; ++i)
             {
-                this._current.sliceSize = this._stream.readInt();
-                if(this._current.sliceSize < 4)
-                {
-                    throw new Ice.UnmarshalOutOfBoundsException();
-                }
+                indirectionTable[i] = this.readInstance(this._stream.readSize(), null);
             }
-            else
+            
+            //
+            // Sanity checks. If there are optional members, it's possible
+            // that not all object references were read if they are from
+            // unknown optional data members.
+            //
+            if(indirectionTable.length === 0)
             {
-                this._current.sliceSize = 0;
+                throw new Ice.MarshalException("empty indirection table");
             }
-            return this._current.typeId;
-        },
-        endSlice: function()
-        {
-            var e,
-                i, 
-                indirectionTable = [],
-                length;
-            
-            if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
+            if((this._current.indirectPatchList === null || this._current.indirectPatchList.length === 0) &&
+            (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) === 0)
             {
-                this._stream.skipOpts();
+                throw new Ice.MarshalException("no references to indirection table");
             }
 
             //
-            // Read the indirection table if one is present and transform the
-            // indirect patch list into patch entries with direct references.
+            // Convert indirect references into direct references.
             //
-            if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
+            if(this._current.indirectPatchList !== null)
             {
-                //
-                // The table is written as a sequence<size> to conserve space.
-                //
-                length = this._stream.readAndCheckSeqSize(1);
-                for(i = 0; i < length; ++i)
-                {
-                    indirectionTable[i] = this.readInstance(this._stream.readSize(), null);
-                }
-                
-                //
-                // Sanity checks. If there are optional members, it's possible
-                // that not all object references were read if they are from
-                // unknown optional data members.
-                //
-                if(indirectionTable.length === 0)
+                for(i = 0, length = this._current.indirectPatchList.length; i < length; ++i)
                 {
-                    throw new Ice.MarshalException("empty indirection table");
-                }
-                if((this._current.indirectPatchList === null || this._current.indirectPatchList.length === 0) &&
-                (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) === 0)
-                {
-                    throw new Ice.MarshalException("no references to indirection table");
-                }
-
-                //
-                // Convert indirect references into direct references.
-                //
-                if(this._current.indirectPatchList !== null)
-                {
-                    for(i = 0, length = this._current.indirectPatchList.length; i < length; ++i)
+                    e = this._current.indirectPatchList[i];
+                    Debug.assert(e.index >= 0);
+                    if(e.index >= indirectionTable.length)
                     {
-                        e = this._current.indirectPatchList[i];
-                        Debug.assert(e.index >= 0);
-                        if(e.index >= indirectionTable.length)
-                        {
-                            throw new Ice.MarshalException("indirection out of range");
-                        }
-                        this.addPatchEntry(indirectionTable[e.index], e.patcher);
+                        throw new Ice.MarshalException("indirection out of range");
                     }
-                    this._current.indirectPatchList.length = 0;
+                    this.addPatchEntry(indirectionTable[e.index], e.patcher);
                 }
+                this._current.indirectPatchList.length = 0;
             }
-        },
-        skipSlice: function()
+        }
+    },
+    skipSlice: function()
+    {
+        if(this._stream.instance.traceLevels().slicing > 0)
         {
-            if(this._stream.instance.traceLevels().slicing > 0)
-            {
-                var logger = this._stream.instance.initializationData().logger;
-                var slicingCat = this._stream.instance.traceLevels().slicingCat;
-                if(this._current.sliceType === SliceType.ExceptionSlice)
-                {
-                    TraceUtil.traceSlicing("exception", this._current.typeId, slicingCat, logger);
-                }
-                else
-                {
-                    TraceUtil.traceSlicing("object", this._current.typeId, slicingCat, logger);
-                }
-            }
-
-            var start = this._stream.pos;
-
-            if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+            var logger = this._stream.instance.initializationData().logger;
+            var slicingCat = this._stream.instance.traceLevels().slicingCat;
+            if(this._current.sliceType === SliceType.ExceptionSlice)
             {
-                Debug.assert(this._current.sliceSize >= 4);
-                this._stream.skip(this._current.sliceSize - 4);
+                TraceUtil.traceSlicing("exception", this._current.typeId, slicingCat, logger);
             }
             else
             {
-                if(this._current.sliceType === SliceType.ObjectSlice)
-                {
-                    throw new Ice.NoObjectFactoryException(
-                        "compact format prevents slicing (the sender should use the sliced format instead)", 
-                        this._current.typeId);
-                }
-                
-                if(this._current.typeId.indexOf("::") === 0)
-                {
-                    throw new Ice.UnknownUserException(this._current.typeId.substring(2));
-                }
-
-                throw new Ice.UnknownUserException(this._current.typeId);
+                TraceUtil.traceSlicing("object", this._current.typeId, slicingCat, logger);
             }
+        }
 
-            //
-            // Preserve this slice.
-            //
-            var info = new Ice.SliceInfo();
-            info.typeId = this._current.typeId;
-            info.compactId = this._current.compactId;
-            info.hasOptionalMembers = (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0;
-            info.isLastSlice = (this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0;
-            
-            var b = this._stream._buf;
-            var end = b.position;
-            var dataEnd = end;
-            if(info.hasOptionalMembers)
+        var start = this._stream.pos;
+
+        if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+        {
+            Debug.assert(this._current.sliceSize >= 4);
+            this._stream.skip(this._current.sliceSize - 4);
+        }
+        else
+        {
+            if(this._current.sliceType === SliceType.ObjectSlice)
             {
-                //
-                // Don't include the optional member end marker. It will be re-written by
-                // endSlice when the sliced data is re-written.
-                //
-                --dataEnd;
+                throw new Ice.NoObjectFactoryException(
+                    "compact format prevents slicing (the sender should use the sliced format instead)", 
+                    this._current.typeId);
             }
             
-            b.position = start;
-            info.bytes = b.getArray(dataEnd - start);
-            b.position = end;
-
-            if(this._current.slices === null) // Lazy initialization
+            if(this._current.typeId.indexOf("::") === 0)
             {
-                this._current.slices = []; // Ice.SliceInfo[]
-                this._current.indirectionTables = []; // int[]
+                throw new Ice.UnknownUserException(this._current.typeId.substring(2));
             }
 
+            throw new Ice.UnknownUserException(this._current.typeId);
+        }
+
+        //
+        // Preserve this slice.
+        //
+        var info = new Ice.SliceInfo();
+        info.typeId = this._current.typeId;
+        info.compactId = this._current.compactId;
+        info.hasOptionalMembers = (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0;
+        info.isLastSlice = (this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0;
+        
+        var b = this._stream._buf;
+        var end = b.position;
+        var dataEnd = end;
+        if(info.hasOptionalMembers)
+        {
             //
-            // Read the indirect object table. We read the instances or their
-            // IDs if the instance is a reference to an already un-marhsaled
-            // object.
-            //
-            // The SliceInfo object sequence is initialized only if
-            // readSlicedData is called.
+            // Don't include the optional member end marker. It will be re-written by
+            // endSlice when the sliced data is re-written.
             //
+            --dataEnd;
+        }
+        
+        b.position = start;
+        info.bytes = b.getArray(dataEnd - start);
+        b.position = end;
 
-            if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
-            {
-                var length = this._stream.readAndCheckSeqSize(1);
-                var indirectionTable = [];
-                for(var i = 0; i < length; ++i)
-                {
-                    indirectionTable[i] = this.readInstance(this._stream.readSize(), null);
-                }
-                this._current.indirectionTables.push(indirectionTable);
-            }
-            else
-            {
-                this._current.indirectionTables.push(null);
-            }
-            this._current.slices.push(info);
-        },
-        readOpt: function(readTag, expectedFormat)
+        if(this._current.slices === null) // Lazy initialization
         {
-            if(this._current === null)
-            {
-                return this._stream.readOptImpl(readTag, expectedFormat);
-            }
-            
-            if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
+            this._current.slices = []; // Ice.SliceInfo[]
+            this._current.indirectionTables = []; // int[]
+        }
+
+        //
+        // Read the indirect object table. We read the instances or their
+        // IDs if the instance is a reference to an already un-marhsaled
+        // object.
+        //
+        // The SliceInfo object sequence is initialized only if
+        // readSlicedData is called.
+        //
+
+        if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0)
+        {
+            var length = this._stream.readAndCheckSeqSize(1);
+            var indirectionTable = [];
+            for(var i = 0; i < length; ++i)
             {
-                return this._stream.readOptImpl(readTag, expectedFormat);
+                indirectionTable[i] = this.readInstance(this._stream.readSize(), null);
             }
-            return false;
-        },
-        readInstance: function(index, patcher)
+            this._current.indirectionTables.push(indirectionTable);
+        }
+        else
         {
-            Debug.assert(index > 0);
-            
-            var mostDerivedId,
-                v = null;
-            
-            if(index > 1)
+            this._current.indirectionTables.push(null);
+        }
+        this._current.slices.push(info);
+    },
+    readOpt: function(readTag, expectedFormat)
+    {
+        if(this._current === null)
+        {
+            return this._stream.readOptImpl(readTag, expectedFormat);
+        }
+        
+        if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
+        {
+            return this._stream.readOptImpl(readTag, expectedFormat);
+        }
+        return false;
+    },
+    readInstance: function(index, patcher)
+    {
+        Debug.assert(index > 0);
+        
+        var mostDerivedId,
+            v = null;
+        
+        if(index > 1)
+        {
+            if(patcher !== null)
             {
-                if(patcher !== null)
-                {
-                    this.addPatchEntry(index, patcher);
-                }
-                return index;
+                this.addPatchEntry(index, patcher);
             }
+            return index;
+        }
 
-            this.push(SliceType.ObjectSlice);
+        this.push(SliceType.ObjectSlice);
 
-            //
-            // Get the object ID before we start reading slices. If some
-            // slices are skiped, the indirect object table are still read and
-            // might read other objects.
-            //
-            index = ++this._objectIdIndex;
+        //
+        // Get the object ID before we start reading slices. If some
+        // slices are skiped, the indirect object table are still read and
+        // might read other objects.
+        //
+        index = ++this._objectIdIndex;
 
-            //
-            // Read the first slice header.
-            //
-            this.startSlice();
-            mostDerivedId = this._current.typeId;
-            while(true)
+        //
+        // Read the first slice header.
+        //
+        this.startSlice();
+        mostDerivedId = this._current.typeId;
+        while(true)
+        {
+            if(this._current.compactId >= 0)
             {
-                if(this._current.compactId >= 0)
-                {
-                    //
-                    // Translate a compact (numeric) type ID into a string type ID.
-                    //
-                    this._current.typeId = "";
-                    if(this._current.typeId.length === 0)
-                    {
-                        this._current.typeId = this._stream.getTypeId(this._current.compactId);
-                    }
-                }
-                
-                if(this._current.typeId.length > 0)
-                {
-                    v = this.newInstance(this._current.typeId);
-                    //
-                    // We found a factory, we get out of this loop.
-                    //
-                    if(v !== null && v !== undefined)
-                    {
-                        break;
-                    }
-                }
-
                 //
-                // If object slicing is disabled, stop un-marshalling.
+                // Translate a compact (numeric) type ID into a string type ID.
                 //
-                if(!this._sliceObjects)
+                this._current.typeId = "";
+                if(this._current.typeId.length === 0)
                 {
-                    throw new Ice.NoObjectFactoryException("object slicing is disabled", this._current.typeId);
+                    this._current.typeId = this._stream.getTypeId(this._current.compactId);
                 }
-
-                //
-                // Slice off what we don't understand.
-                //
-                this.skipSlice();
+            }
+            
+            if(this._current.typeId.length > 0)
+            {
+                v = this.newInstance(this._current.typeId);
                 //
-                // If this is the last slice, keep the object as an opaque
-                // UnknownSlicedData object.
+                // We found a factory, we get out of this loop.
                 //
-                if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0)
+                if(v !== null && v !== undefined)
                 {
-                    v = new Ice.UnknownSlicedObject(mostDerivedId);
                     break;
                 }
-
-                this.startSlice(); // Read next Slice header for next iteration.
             }
 
             //
-            // Un-marshal the object
+            // If object slicing is disabled, stop un-marshalling.
             //
-            this.unmarshal(index, v);
-            if(this._current === null && this._patchMap !== null && this._patchMap.size !== 0)
+            if(!this._sliceObjects)
             {
-                //
-                // If any entries remain in the patch map, the sender has sent an index for an object, but failed
-                // to supply the object.
-                //
-                throw new Ice.MarshalException("index for class received, but no instance");
+                throw new Ice.NoObjectFactoryException("object slicing is disabled", this._current.typeId);
             }
 
-            if(patcher !== null)
+            //
+            // Slice off what we don't understand.
+            //
+            this.skipSlice();
+            //
+            // If this is the last slice, keep the object as an opaque
+            // UnknownSlicedData object.
+            //
+            if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0)
             {
-                patcher.call(null, v);
+                v = new Ice.UnknownSlicedObject(mostDerivedId);
+                break;
             }
-            return index;
-        },
-        readSlicedData: function()
+
+            this.startSlice(); // Read next Slice header for next iteration.
+        }
+
+        //
+        // Un-marshal the object
+        //
+        this.unmarshal(index, v);
+        if(this._current === null && this._patchMap !== null && this._patchMap.size !== 0)
         {
-            var i, ii, table, info, j, jj;
-            
-            if(this._current.slices === null) // No preserved slices.
-            {
-                return null;
-            }
             //
-            // The _indirectionTables member holds the indirection table for each slice
-            // in _slices.
+            // If any entries remain in the patch map, the sender has sent an index for an object, but failed
+            // to supply the object.
             //
-            Debug.assert(this._current.slices.length === this._current.indirectionTables.length);
-            for(i = 0, ii = this._current.slices.length; i < ii; ++i)
-            {
-                //
-                // We use the "objects" list in SliceInfo to hold references
-                // to the target objects. Note that the objects might not have
-                // been read yet in the case of a circular reference to an
-                // enclosing object.
-                //
-                table = this._current.indirectionTables[i];
-                info = this._current.slices[i];
-                info.objects = [];
-                jj = table ? table.length : 0;
-                for(j = 0; j < jj; ++j)
-                {
-                    this.addPatchEntry(table[j], sequencePatcher(info.objects, j, IceObject));
-                }
-            }
-            return new SlicedData(ArrayUtil.clone(this._current.slices));
-        },
-        push: function(sliceType)
+            throw new Ice.MarshalException("index for class received, but no instance");
+        }
+
+        if(patcher !== null)
         {
-            if(this._current === null)
-            {
-                this._current = new EncapsDecoder11.InstanceData(null);
-            }
-            else
+            patcher.call(null, v);
+        }
+        return index;
+    },
+    readSlicedData: function()
+    {
+        var i, ii, table, info, j, jj;
+        
+        if(this._current.slices === null) // No preserved slices.
+        {
+            return null;
+        }
+        //
+        // The _indirectionTables member holds the indirection table for each slice
+        // in _slices.
+        //
+        Debug.assert(this._current.slices.length === this._current.indirectionTables.length);
+        for(i = 0, ii = this._current.slices.length; i < ii; ++i)
+        {
+            //
+            // We use the "objects" list in SliceInfo to hold references
+            // to the target objects. Note that the objects might not have
+            // been read yet in the case of a circular reference to an
+            // enclosing object.
+            //
+            table = this._current.indirectionTables[i];
+            info = this._current.slices[i];
+            info.objects = [];
+            jj = table ? table.length : 0;
+            for(j = 0; j < jj; ++j)
             {
-                this._current = !this._current.next ? new EncapsDecoder11.InstanceData(this._current) : this._current.next;
+                this.addPatchEntry(table[j], sequencePatcher(info.objects, j, IceObject));
             }
-            this._current.sliceType = sliceType;
-            this._current.skipFirstSlice = false;
         }
-    });
-    
-    EncapsDecoder11.InstanceData = function(previous)
+        return new SlicedData(ArrayUtil.clone(this._current.slices));
+    },
+    push: function(sliceType)
     {
-        if(previous !== null)
+        if(this._current === null)
         {
-            previous.next = this;
+            this._current = new EncapsDecoder11.InstanceData(null);
         }
-        this.previous = previous;
-        this.next = null;
+        else
+        {
+            this._current = !this._current.next ? new EncapsDecoder11.InstanceData(this._current) : this._current.next;
+        }
+        this._current.sliceType = sliceType;
+        this._current.skipFirstSlice = false;
+    }
+});
+
+EncapsDecoder11.InstanceData = function(previous)
+{
+    if(previous !== null)
+    {
+        previous.next = this;
+    }
+    this.previous = previous;
+    this.next = null;
 
-        // Instance attributes
-        this.sliceType = null;
-        this.skipFirstSlice = false;
-        this.slices = null;     // Preserved slices. Ice.SliceInfo[] 
-        this.indirectionTables = null; // int[] 
-
-        // Slice attributes
-        this.sliceFlags = 0;
-        this.sliceSize = 0;
-        this.typeId = null;
-        this.compactId = 0;
-        this.indirectPatchList = null; // Lazy initialized, IndirectPatchEntry[]
-    };
+    // Instance attributes
+    this.sliceType = null;
+    this.skipFirstSlice = false;
+    this.slices = null;     // Preserved slices. Ice.SliceInfo[] 
+    this.indirectionTables = null; // int[] 
 
-    var sequencePatcher = function(seq, index, T){
-        return function(v)
-            {
-                if(v !== null && !(v instanceof T))
-                {
-                    ExUtil.throwUOE(T.ice_staticId(), v);
-                }
-                seq[index] = v;
-            };
-    };
+    // Slice attributes
+    this.sliceFlags = 0;
+    this.sliceSize = 0;
+    this.typeId = null;
+    this.compactId = 0;
+    this.indirectPatchList = null; // Lazy initialized, IndirectPatchEntry[]
+};
 
-    var EncapsEncoder = Class({
-        __init__: function(stream, encaps)
-        {
-            this._stream = stream;
-            this._encaps = encaps;
-            this._marshaledMap = new HashMap(); // HashMap<Ice.Object, int>;
-            this._typeIdMap = null; // Lazy initialized. HashMap<String, int>
-            this._typeIdIndex = 0;
-        },
-        writeOpt: function()
-        {
-            return false;
-        },
-        writePendingObjects: function()
+var sequencePatcher = function(seq, index, T){
+    return function(v)
         {
-            return undefined;
-        },
-        registerTypeId: function(typeId)
-        {
-            if(this._typeIdMap === null) // Lazy initialization
+            if(v !== null && !(v instanceof T))
             {
-                this._typeIdMap = new HashMap(); // HashMap<String, int>
+                ExUtil.throwUOE(T.ice_staticId(), v);
             }
+            seq[index] = v;
+        };
+};
 
-            var p = this._typeIdMap.get(typeId);
-            if(p !== undefined)
-            {
-                return p;
-            }
-            this._typeIdMap.set(typeId, ++this._typeIdIndex);
-            return -1;
+var EncapsEncoder = Class({
+    __init__: function(stream, encaps)
+    {
+        this._stream = stream;
+        this._encaps = encaps;
+        this._marshaledMap = new HashMap(); // HashMap<Ice.Object, int>;
+        this._typeIdMap = null; // Lazy initialized. HashMap<String, int>
+        this._typeIdIndex = 0;
+    },
+    writeOpt: function()
+    {
+        return false;
+    },
+    writePendingObjects: function()
+    {
+        return undefined;
+    },
+    registerTypeId: function(typeId)
+    {
+        if(this._typeIdMap === null) // Lazy initialization
+        {
+            this._typeIdMap = new HashMap(); // HashMap<String, int>
         }
-    });
-    
-    var EncapsEncoder10 = Class(EncapsEncoder, {
-        __init__: function(stream, encaps)
-        {
-            EncapsEncoder.call(this, stream, encaps);
-            // Instance attributes
-            this._sliceType = SliceType.NoSlice;
-            this._writeSlice = 0;        // Position of the slice data members
-            // Encapsulation attributes for object marshalling.
-            this._objectIdIndex = 0;
-            this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, Integer>();
-        },
-        writeObject: function(v)
-        {
-            Debug.assert(v !== undefined);
-            //
-            // Object references are encoded as a negative integer in 1.0.
-            //
-            if(v !== null)
-            {
-                this._stream.writeInt(-this.registerObject(v));
-            }
-            else
-            {
-                this._stream.writeInt(0);
-            }
-        },
-        writeUserException: function(v)
+
+        var p = this._typeIdMap.get(typeId);
+        if(p !== undefined)
         {
-            Debug.assert(v !== null && v !== undefined);
-            //
-            // User exception with the 1.0 encoding start with a boolean
-            // flag that indicates whether or not the exception uses
-            // classes. 
-            //
-            // This allows reading the pending objects even if some part of
-            // the exception was sliced.
-            //
-            var usesClasses = v.__usesClasses();
-            this._stream.writeBool(usesClasses);
-            v.__write(this._stream);
-            if(usesClasses)
-            {
-                this.writePendingObjects();
-            }
-        },
-        startInstance: function(sliceType)
+            return p;
+        }
+        this._typeIdMap.set(typeId, ++this._typeIdIndex);
+        return -1;
+    }
+});
+
+var EncapsEncoder10 = Class(EncapsEncoder, {
+    __init__: function(stream, encaps)
+    {
+        EncapsEncoder.call(this, stream, encaps);
+        // Instance attributes
+        this._sliceType = SliceType.NoSlice;
+        this._writeSlice = 0;        // Position of the slice data members
+        // Encapsulation attributes for object marshalling.
+        this._objectIdIndex = 0;
+        this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, Integer>();
+    },
+    writeObject: function(v)
+    {
+        Debug.assert(v !== undefined);
+        //
+        // Object references are encoded as a negative integer in 1.0.
+        //
+        if(v !== null)
         {
-            this._sliceType = sliceType;
-        },
-        endInstance: function()
+            this._stream.writeInt(-this.registerObject(v));
+        }
+        else
         {
-            if(this._sliceType === SliceType.ObjectSlice)
-            {
-                //
-                // Write the Object slice.
-                //
-                this.startSlice(IceObject.ice_staticId(), -1, true);
-                this._stream.writeSize(0); // For compatibility with the old AFM.
-                this.endSlice();
-            }
-            this._sliceType = SliceType.NoSlice;
-        },
-        startSlice: function(typeId)
+            this._stream.writeInt(0);
+        }
+    },
+    writeUserException: function(v)
+    {
+        Debug.assert(v !== null && v !== undefined);
+        //
+        // User exception with the 1.0 encoding start with a boolean
+        // flag that indicates whether or not the exception uses
+        // classes. 
+        //
+        // This allows reading the pending objects even if some part of
+        // the exception was sliced.
+        //
+        var usesClasses = v.__usesClasses();
+        this._stream.writeBool(usesClasses);
+        v.__write(this._stream);
+        if(usesClasses)
+        {
+            this.writePendingObjects();
+        }
+    },
+    startInstance: function(sliceType)
+    {
+        this._sliceType = sliceType;
+    },
+    endInstance: function()
+    {
+        if(this._sliceType === SliceType.ObjectSlice)
         {
             //
-            // For object slices, encode a boolean to indicate how the type ID
-            // is encoded and the type ID either as a string or index. For
-            // exception slices, always encode the type ID as a string.
+            // Write the Object slice.
             //
-            if(this._sliceType === SliceType.ObjectSlice)
+            this.startSlice(IceObject.ice_staticId(), -1, true);
+            this._stream.writeSize(0); // For compatibility with the old AFM.
+            this.endSlice();
+        }
+        this._sliceType = SliceType.NoSlice;
+    },
+    startSlice: function(typeId)
+    {
+        //
+        // For object slices, encode a boolean to indicate how the type ID
+        // is encoded and the type ID either as a string or index. For
+        // exception slices, always encode the type ID as a string.
+        //
+        if(this._sliceType === SliceType.ObjectSlice)
+        {
+            var index = this.registerTypeId(typeId);
+            if(index < 0)
             {
-                var index = this.registerTypeId(typeId);
-                if(index < 0)
-                {
-                    this._stream.writeBool(false);
-                    this._stream.writeString(typeId);
-                }
-                else
-                {
-                    this._stream.writeBool(true);
-                    this._stream.writeSize(index);
-                }
+                this._stream.writeBool(false);
+                this._stream.writeString(typeId);
             }
             else
             {
-                this._stream.writeString(typeId);
+                this._stream.writeBool(true);
+                this._stream.writeSize(index);
             }
+        }
+        else
+        {
+            this._stream.writeString(typeId);
+        }
 
-            this._stream.writeInt(0); // Placeholder for the slice length.
+        this._stream.writeInt(0); // Placeholder for the slice length.
 
-            this._writeSlice = this._stream.pos;
-        },
-        endSlice: function()
-        {
-            //
-            // Write the slice length.
-            //
-            var sz = this._stream.pos - this._writeSlice + 4;
-            this._stream.rewriteInt(sz, this._writeSlice - 4);
-        },
-        writePendingObjects: function()
-        {
-            var self = this,
-                writeCB = function(key, value)
+        this._writeSlice = this._stream.pos;
+    },
+    endSlice: function()
+    {
+        //
+        // Write the slice length.
+        //
+        var sz = this._stream.pos - this._writeSlice + 4;
+        this._stream.rewriteInt(sz, this._writeSlice - 4);
+    },
+    writePendingObjects: function()
+    {
+        var self = this,
+            writeCB = function(key, value)
+                        {
+                            //
+                            // Ask the instance to marshal itself. Any new class
+                            // instances that are triggered by the classes marshaled
+                            // are added to toBeMarshaledMap.
+                            //
+                            self._stream.writeInt(value);
+
+                            try
                             {
-                                //
-                                // Ask the instance to marshal itself. Any new class
-                                // instances that are triggered by the classes marshaled
-                                // are added to toBeMarshaledMap.
-                                //
-                                self._stream.writeInt(value);
-
-                                try
-                                {
-                                    key.ice_preMarshal();
-                                }
-                                catch(ex)
-                                {
-                                    self._stream.instance.initializationData().logger.warning(
-                                        "exception raised by ice_preMarshal:\n" + ExUtil.toString(ex));
-                                }
-
-                                key.__write(self._stream);
-                            },
-                savedMap;
-            
-            while(this._toBeMarshaledMap.size > 0)
-            {
-                //
-                // Consider the to be marshalled objects as marshalled now,
-                // this is necessary to avoid adding again the "to be
-                // marshalled objects" into _toBeMarshaledMap while writing
-                // objects.
-                //
-                this._marshaledMap.merge(this._toBeMarshaledMap);
+                                key.ice_preMarshal();
+                            }
+                            catch(ex)
+                            {
+                                self._stream.instance.initializationData().logger.warning(
+                                    "exception raised by ice_preMarshal:\n" + ExUtil.toString(ex));
+                            }
 
-                savedMap = this._toBeMarshaledMap;
-                this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, int>();
-                this._stream.writeSize(savedMap.size);
-                savedMap.forEach(writeCB);
-            }
-            this._stream.writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
-        },
-        registerObject: function(v)
+                            key.__write(self._stream);
+                        },
+            savedMap;
+        
+        while(this._toBeMarshaledMap.size > 0)
         {
-            Debug.assert(v !== null);
-
             //
-            // Look for this instance in the to-be-marshaled map.
+            // Consider the to be marshalled objects as marshalled now,
+            // this is necessary to avoid adding again the "to be
+            // marshalled objects" into _toBeMarshaledMap while writing
+            // objects.
             //
-            var p = this._toBeMarshaledMap.get(v);
-            if(p !== undefined)
-            {
-                return p;
-            }
+            this._marshaledMap.merge(this._toBeMarshaledMap);
 
-            //
-            // Didn't find it, try the marshaled map next.
-            //
-            p = this._marshaledMap.get(v);
-            if(p !== undefined)
-            {
-                return p;
-            }
+            savedMap = this._toBeMarshaledMap;
+            this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, int>();
+            this._stream.writeSize(savedMap.size);
+            savedMap.forEach(writeCB);
+        }
+        this._stream.writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
+    },
+    registerObject: function(v)
+    {
+        Debug.assert(v !== null);
 
-            //
-            // We haven't seen this instance previously, create a new
-            // index, and insert it into the to-be-marshaled map.
-            //
-            this._toBeMarshaledMap.set(v, ++this._objectIdIndex);
-            return this._objectIdIndex;
+        //
+        // Look for this instance in the to-be-marshaled map.
+        //
+        var p = this._toBeMarshaledMap.get(v);
+        if(p !== undefined)
+        {
+            return p;
         }
-    });
-    
-    var EncapsEncoder11 = Class(EncapsEncoder, {
-        __init__: function(stream, encaps)
+
+        //
+        // Didn't find it, try the marshaled map next.
+        //
+        p = this._marshaledMap.get(v);
+        if(p !== undefined)
+        {
+            return p;
+        }
+
+        //
+        // We haven't seen this instance previously, create a new
+        // index, and insert it into the to-be-marshaled map.
+        //
+        this._toBeMarshaledMap.set(v, ++this._objectIdIndex);
+        return this._objectIdIndex;
+    }
+});
+
+var EncapsEncoder11 = Class(EncapsEncoder, {
+    __init__: function(stream, encaps)
+    {
+        EncapsEncoder.call(this, stream, encaps); 
+        this._current = null;
+        this._objectIdIndex = 1;
+    },
+    writeObject: function(v)
+    {
+        Debug.assert(v !== undefined);
+        var index, idx;
+        if(v === null)
         {
-            EncapsEncoder.call(this, stream, encaps); 
-            this._current = null;
-            this._objectIdIndex = 1;
-        },
-        writeObject: function(v)
+            this._stream.writeSize(0);
+        }
+        else if(this._current !== null && this._encaps.format === FormatType.SlicedFormat)
         {
-            Debug.assert(v !== undefined);
-            var index, idx;
-            if(v === null)
+            if(this._current.indirectionTable === null) // Lazy initialization
             {
-                this._stream.writeSize(0);
+                this._current.indirectionTable = []; // Ice.Object[]
+                this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int>
             }
-            else if(this._current !== null && this._encaps.format === FormatType.SlicedFormat)
-            {
-                if(this._current.indirectionTable === null) // Lazy initialization
-                {
-                    this._current.indirectionTable = []; // Ice.Object[]
-                    this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int>
-                }
 
-                //
-                // If writting an object within a slice and using the sliced
-                // format, write an index from the object indirection
-                // table. The indirect object table is encoded at the end of
-                // each slice and is always read (even if the Slice is
-                // unknown).
-                // 
-                index = this._current.indirectionMap.get(v);
-                if(index === undefined)
-                {
-                    this._current.indirectionTable.push(v);
-                    idx = this._current.indirectionTable.length; // Position + 1 (0 is reserved for nil)
-                    this._current.indirectionMap.set(v, idx);
-                    this._stream.writeSize(idx); 
-                }
-                else
-                {
-                    this._stream.writeSize(index);
-                }
+            //
+            // If writting an object within a slice and using the sliced
+            // format, write an index from the object indirection
+            // table. The indirect object table is encoded at the end of
+            // each slice and is always read (even if the Slice is
+            // unknown).
+            // 
+            index = this._current.indirectionMap.get(v);
+            if(index === undefined)
+            {
+                this._current.indirectionTable.push(v);
+                idx = this._current.indirectionTable.length; // Position + 1 (0 is reserved for nil)
+                this._current.indirectionMap.set(v, idx);
+                this._stream.writeSize(idx); 
             }
             else
             {
-                this.writeInstance(v); // Write the instance or a reference if already marshaled.
+                this._stream.writeSize(index);
             }
-        },
-        writePendingObjects: function()
+        }
+        else
         {
-            return undefined;
-        },
-        writeUserException: function(v)
+            this.writeInstance(v); // Write the instance or a reference if already marshaled.
+        }
+    },
+    writePendingObjects: function()
+    {
+        return undefined;
+    },
+    writeUserException: function(v)
+    {
+        Debug.assert(v !== null && v !== undefined);
+        v.__write(this._stream);
+    },
+    startInstance: function(sliceType, data)
+    {
+        if(this._current === null)
         {
-            Debug.assert(v !== null && v !== undefined);
-            v.__write(this._stream);
-        },
-        startInstance: function(sliceType, data)
+            this._current = new EncapsEncoder11.InstanceData(null);
+        }
+        else
         {
-            if(this._current === null)
-            {
-                this._current = new EncapsEncoder11.InstanceData(null);
-            }
-            else
-            {
-                this._current = (this._current.next === null) ? new EncapsEncoder11.InstanceData(this._current) : this._current.next;
-            }
-            this._current.sliceType = sliceType;
-            this._current.firstSlice = true;
+            this._current = (this._current.next === null) ? new EncapsEncoder11.InstanceData(this._current) : this._current.next;
+        }
+        this._current.sliceType = sliceType;
+        this._current.firstSlice = true;
 
-            if(data !== null && data !== undefined)
-            {
-                this.writeSlicedData(data);
-            }
-        },
-        endInstance: function()
+        if(data !== null && data !== undefined)
         {
-            this._current = this._current.previous;
-        },
-        startSlice: function(typeId, compactId, last)
-        {
-            Debug.assert((this._current.indirectionTable === null || this._current.indirectionTable.length === 0) && 
-                         (this._current.indirectionMap === null || this._current.indirectionMap.size === 0));
+            this.writeSlicedData(data);
+        }
+    },
+    endInstance: function()
+    {
+        this._current = this._current.previous;
+    },
+    startSlice: function(typeId, compactId, last)
+    {
+        Debug.assert((this._current.indirectionTable === null || this._current.indirectionTable.length === 0) && 
+                        (this._current.indirectionMap === null || this._current.indirectionMap.size === 0));
 
-            this._current.sliceFlagsPos = this._stream.pos;
+        this._current.sliceFlagsPos = this._stream.pos;
 
-            this._current.sliceFlags = 0;
-            if(this._encaps.format === FormatType.SlicedFormat)
-            {
-                this._current.sliceFlags |= FLAG_HAS_SLICE_SIZE; // Encode the slice size if using the sliced format.
-            }
-            if(last)
-            {
-                this._current.sliceFlags |= FLAG_IS_LAST_SLICE; // This is the last slice.
-            }
+        this._current.sliceFlags = 0;
+        if(this._encaps.format === FormatType.SlicedFormat)
+        {
+            this._current.sliceFlags |= FLAG_HAS_SLICE_SIZE; // Encode the slice size if using the sliced format.
+        }
+        if(last)
+        {
+            this._current.sliceFlags |= FLAG_IS_LAST_SLICE; // This is the last slice.
+        }
 
-            this._stream.writeByte(0); // Placeholder for the slice flags
+        this._stream.writeByte(0); // Placeholder for the slice flags
 
+        //
+        // For object slices, encode the flag and the type ID either as a
+        // string or index. For exception slices, always encode the type
+        // ID a string.
+        //
+        if(this._current.sliceType === SliceType.ObjectSlice)
+        {
             //
-            // For object slices, encode the flag and the type ID either as a
-            // string or index. For exception slices, always encode the type
-            // ID a string.
-            //
-            if(this._current.sliceType === SliceType.ObjectSlice)
+            // Encode the type ID (only in the first slice for the compact
+            // encoding).
+            // 
+            if(this._encaps.format === FormatType.SlicedFormat || this._current.firstSlice)
             {
-                //
-                // Encode the type ID (only in the first slice for the compact
-                // encoding).
-                // 
-                if(this._encaps.format === FormatType.SlicedFormat || this._current.firstSlice)
+                if(compactId >= 0)
                 {
-                    if(compactId >= 0)
+                    this._current.sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT;
+                    this._stream.writeSize(compactId);
+                }
+                else
+                {
+                    var index = this.registerTypeId(typeId);
+                    if(index < 0)
                     {
-                        this._current.sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT;
-                        this._stream.writeSize(compactId);
+                        this._current.sliceFlags |= FLAG_HAS_TYPE_ID_STRING;
+                        this._stream.writeString(typeId);
                     }
                     else
                     {
-                        var index = this.registerTypeId(typeId);
-                        if(index < 0)
-                        {
-                            this._current.sliceFlags |= FLAG_HAS_TYPE_ID_STRING;
-                            this._stream.writeString(typeId);
-                        }
-                        else
-                        {
-                            this._current.sliceFlags |= FLAG_HAS_TYPE_ID_INDEX;
-                            this._stream.writeSize(index);
-                        }
+                        this._current.sliceFlags |= FLAG_HAS_TYPE_ID_INDEX;
+                        this._stream.writeSize(index);
                     }
                 }
             }
-            else
-            {
-                this._stream.writeString(typeId);
-            }
+        }
+        else
+        {
+            this._stream.writeString(typeId);
+        }
 
-            if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
-            {
-                this._stream.writeInt(0); // Placeholder for the slice length.
-            }
+        if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+        {
+            this._stream.writeInt(0); // Placeholder for the slice length.
+        }
 
-            this._current.writeSlice = this._stream.pos;
-            this._current.firstSlice = false;
-        },
-        endSlice: function()
+        this._current.writeSlice = this._stream.pos;
+        this._current.firstSlice = false;
+    },
+    endSlice: function()
+    {
+        var sz, i, length;
+        
+        //
+        // Write the optional member end marker if some optional members
+        // were encoded. Note that the optional members are encoded before
+        // the indirection table and are included in the slice size.
+        //
+        if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
         {
-            var sz, i, length;
-            
-            //
-            // Write the optional member end marker if some optional members
-            // were encoded. Note that the optional members are encoded before
-            // the indirection table and are included in the slice size.
-            //
-            if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0)
-            {
-                this._stream.writeByte(OPTIONAL_END_MARKER);
-            }
+            this._stream.writeByte(OPTIONAL_END_MARKER);
+        }
 
-            //
-            // Write the slice length if necessary.
-            //
-            if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
-            {
-                sz = this._stream.pos - this._current.writeSlice + 4;
-                this._stream.rewriteInt(sz, this._current.writeSlice - 4);
-            }
+        //
+        // Write the slice length if necessary.
+        //
+        if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0)
+        {
+            sz = this._stream.pos - this._current.writeSlice + 4;
+            this._stream.rewriteInt(sz, this._current.writeSlice - 4);
+        }
+
+        //
+        // Only write the indirection table if it contains entries.
+        //
+        if(this._current.indirectionTable !== null && this._current.indirectionTable.length !== 0)
+        {
+            Debug.assert(this._encaps.format === FormatType.SlicedFormat);
+            this._current.sliceFlags |= FLAG_HAS_INDIRECTION_TABLE;
 
             //
-            // Only write the indirection table if it contains entries.
+            // Write the indirection object table.
             //
-            if(this._current.indirectionTable !== null && this._current.indirectionTable.length !== 0)
+            this._stream.writeSize(this._current.indirectionTable.length);
+            for(i = 0, length = this._current.indirectionTable.length; i < length; ++i)
             {
-                Debug.assert(this._encaps.format === FormatType.SlicedFormat);
-                this._current.sliceFlags |= FLAG_HAS_INDIRECTION_TABLE;
-
-                //
-                // Write the indirection object table.
-                //
-                this._stream.writeSize(this._current.indirectionTable.length);
-                for(i = 0, length = this._current.indirectionTable.length; i < length; ++i)
-                {
-                    this.writeInstance(this._current.indirectionTable[i]);
-                }
-                this._current.indirectionTable.length = 0; // Faster way to clean array in JavaScript
-                this._current.indirectionMap.clear();
+                this.writeInstance(this._current.indirectionTable[i]);
             }
+            this._current.indirectionTable.length = 0; // Faster way to clean array in JavaScript
+            this._current.indirectionMap.clear();
+        }
 
-            //
-            // Finally, update the slice flags.
-            //
-            this._stream.rewriteByte(this._current.sliceFlags, this._current.sliceFlagsPos);
-        },
-        writeOpt: function(tag, format)
+        //
+        // Finally, update the slice flags.
+        //
+        this._stream.rewriteByte(this._current.sliceFlags, this._current.sliceFlagsPos);
+    },
+    writeOpt: function(tag, format)
+    {
+        if(this._current === null)
         {
-            if(this._current === null)
-            {
-                return this._stream.writeOptImpl(tag, format);
-            }
-            
-            if(this._stream.writeOptImpl(tag, format))
-            {
-                this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
-                return true;
-            }
-            
-            return false;
-        },
-        writeSlicedData: function(slicedData)
+            return this._stream.writeOptImpl(tag, format);
+        }
+        
+        if(this._stream.writeOptImpl(tag, format))
         {
-            Debug.assert(slicedData !== null && slicedData !== undefined);
+            this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+            return true;
+        }
+        
+        return false;
+    },
+    writeSlicedData: function(slicedData)
+    {
+        Debug.assert(slicedData !== null && slicedData !== undefined);
+        
+        //
+        // We only remarshal preserved slices if we are using the sliced
+        // format. Otherwise, we ignore the preserved slices, which
+        // essentially "slices" the object into the most-derived type
+        // known by the sender.
+        //
+        if(this._encaps.format !== FormatType.SlicedFormat)
+        {
+            return;
+        }
+
+        var i, ii, info,
+            j, jj;
             
+        for(i = 0, ii = slicedData.slices.length; i < ii; ++i)
+        {
+            info = slicedData.slices[i];
+            this.startSlice(info.typeId, info.compactId, info.isLastSlice);
+
             //
-            // We only remarshal preserved slices if we are using the sliced
-            // format. Otherwise, we ignore the preserved slices, which
-            // essentially "slices" the object into the most-derived type
-            // known by the sender.
+            // Write the bytes associated with this slice.
             //
-            if(this._encaps.format !== FormatType.SlicedFormat)
+            this._stream.writeBlob(info.bytes);
+
+            if(info.hasOptionalMembers)
             {
-                return;
+                this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
             }
 
-            var i, ii, info,
-                j, jj;
-                
-            for(i = 0, ii = slicedData.slices.length; i < ii; ++i)
+            //
+            // Make sure to also re-write the object indirection table.
+            //
+            if(info.objects !== null && info.objects.length > 0)
             {
-                info = slicedData.slices[i];
-                this.startSlice(info.typeId, info.compactId, info.isLastSlice);
-
-                //
-                // Write the bytes associated with this slice.
-                //
-                this._stream.writeBlob(info.bytes);
-
-                if(info.hasOptionalMembers)
+                if(this._current.indirectionTable === null) // Lazy initialization
                 {
-                    this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+                    this._current.indirectionTable = []; // Ice.Object[]
+                    this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int>
                 }
-
-                //
-                // Make sure to also re-write the object indirection table.
-                //
-                if(info.objects !== null && info.objects.length > 0)
+                
+                for(j = 0, jj = info.objects.length; j < jj; ++j)
                 {
-                    if(this._current.indirectionTable === null) // Lazy initialization
-                    {
-                        this._current.indirectionTable = []; // Ice.Object[]
-                        this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int>
-                    }
-                    
-                    for(j = 0, jj = info.objects.length; j < jj; ++j)
-                    {
-                        this._current.indirectionTable.push(info.objects[j]);
-                    }
+                    this._current.indirectionTable.push(info.objects[j]);
                 }
-                
-                this.endSlice();
             }
-        },
-        writeInstance: function(v)
+            
+            this.endSlice();
+        }
+    },
+    writeInstance: function(v)
+    {
+        Debug.assert(v !== null && v !== undefined);
+
+        //
+        // If the instance was already marshaled, just write it's ID.
+        //
+        var p = this._marshaledMap.get(v);
+        if(p !== undefined)
         {
-            Debug.assert(v !== null && v !== undefined);
+            this._stream.writeSize(p);
+            return;
+        }
 
-            //
-            // If the instance was already marshaled, just write it's ID.
-            //
-            var p = this._marshaledMap.get(v);
-            if(p !== undefined)
-            {
-                this._stream.writeSize(p);
-                return;
-            }
+        //
+        // We haven't seen this instance previously, create a new ID,
+        // insert it into the marshaled map, and write the instance.
+        //
+        this._marshaledMap.set(v, ++this._objectIdIndex);
 
-            //
-            // We haven't seen this instance previously, create a new ID,
-            // insert it into the marshaled map, and write the instance.
-            //
-            this._marshaledMap.set(v, ++this._objectIdIndex);
+        try
+        {
+            v.ice_preMarshal();
+        }
+        catch(ex)
+        {
+            this._stream.instance.initializationData().logger.warning("exception raised by ice_preMarshal:\n" + 
+                                                                    ExUtil.toString(ex));
+        }
 
-            try
-            {
-                v.ice_preMarshal();
-            }
-            catch(ex)
-            {
-                this._stream.instance.initializationData().logger.warning("exception raised by ice_preMarshal:\n" + 
-                                                                        ExUtil.toString(ex));
-            }
+        this._stream.writeSize(1); // Object instance marker.
+        v.__write(this._stream);
+    }
+});
 
-            this._stream.writeSize(1); // Object instance marker.
-            v.__write(this._stream);
-        }
-    });
+EncapsEncoder11.InstanceData = function(previous)
+{
+    Debug.assert(previous !== undefined);
+    if(previous !== null)
+    {
+        previous.next = this;
+    }
+    this.previous = previous;
+    this.next = null;
     
-    EncapsEncoder11.InstanceData = function(previous)
+    // Instance attributes
+    this.sliceType = null;
+    this.firstSlice = false;
+
+    // Slice attributes
+    this.sliceFlags = 0;
+    this.writeSlice = 0;    // Position of the slice data members
+    this.sliceFlagsPos = 0; // Position of the slice flags
+    this.indirectionTable = null; // Ice.Object[]
+    this.indirectionMap = null; // HashMap<Ice.Object, int> 
+};
+
+var ReadEncaps = Class({
+    __init__: function()
     {
-        Debug.assert(previous !== undefined);
-        if(previous !== null)
-        {
-            previous.next = this;
-        }
-        this.previous = previous;
+        this.start = 0;
+        this.sz = 0;
+        this.encoding = null;
+        this.encoding_1_0 = false;
+        this.decoder = null;
         this.next = null;
-        
-        // Instance attributes
-        this.sliceType = null;
-        this.firstSlice = false;
-
-        // Slice attributes
-        this.sliceFlags = 0;
-        this.writeSlice = 0;    // Position of the slice data members
-        this.sliceFlagsPos = 0; // Position of the slice flags
-        this.indirectionTable = null; // Ice.Object[]
-        this.indirectionMap = null; // HashMap<Ice.Object, int> 
-    };
+    },
+    reset: function()
+    {
+        this.decoder = null;
+    },
+    setEncoding: function(encoding)
+    {
+        this.encoding = encoding;
+        this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0);
+    }
+});
 
-    var ReadEncaps = Class({
-        __init__: function()
-        {
-            this.start = 0;
-            this.sz = 0;
-            this.encoding = null;
-            this.encoding_1_0 = false;
-            this.decoder = null;
-            this.next = null;
-        },
-        reset: function()
-        {
-            this.decoder = null;
-        },
-        setEncoding: function(encoding)
+var WriteEncaps = Class({
+    __init__: function()
+    {
+        this.start = 0;
+        this.format = FormatType.DefaultFormat;
+        this.encoding = null;
+        this.encoding_1_0 = false;
+        this.encoder = null;
+        this.next = null;
+    },
+    reset: function()
+    {
+        this.encoder = null;
+    },
+    setEncoding: function(encoding)
+    {
+        this.encoding = encoding;
+        this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0);
+    }
+});
+
+var BasicStream = Class({
+    __init__: function(instance, encoding, unlimited, data)
+    {
+        this._instance = instance;
+        this._closure = null;
+        this._encoding = encoding;
+
+        this._readEncapsStack = null;
+        this._writeEncapsStack = null;
+        this._readEncapsCache = null;
+        this._writeEncapsCache = null;
+
+        this._sliceObjects = true;
+
+        this._messageSizeMax = this._instance.messageSizeMax(); // Cached for efficiency.
+        this._unlimited = unlimited !== undefined ? unlimited : false;
+
+        this._startSeq = -1;
+        this._sizePos = -1;
+        
+        if(data !== undefined)
         {
-            this.encoding = encoding;
-            this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0);
+            this._buf = new Ice.Buffer(data);
         }
-    });
-    
-    var WriteEncaps = Class({
-        __init__: function()
+        else
         {
-            this.start = 0;
-            this.format = FormatType.DefaultFormat;
-            this.encoding = null;
-            this.encoding_1_0 = false;
-            this.encoder = null;
-            this.next = null;
-        },
-        reset: function()
-        {
-            this.encoder = null;
-        },
-        setEncoding: function(encoding)
-        {
-            this.encoding = encoding;
-            this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0);
+            this._buf = new Ice.Buffer();
         }
-    });
-    
-    var BasicStream = Class({
-        __init__: function(instance, encoding, unlimited, data)
+    },
+    //
+    // This function allows this object to be reused, rather than
+    // reallocated.
+    //
+    reset: function()
+    {
+        this._buf.reset();
+        this.clear();
+    },
+    clear: function()
+    {
+        if(this._readEncapsStack !== null)
         {
-            this._instance = instance;
-            this._closure = null;
-            this._encoding = encoding;
-
+            Debug.assert(this._readEncapsStack.next);
+            this._readEncapsStack.next = this._readEncapsCache;
+            this._readEncapsCache = this._readEncapsStack;
+            this._readEncapsCache.reset();
             this._readEncapsStack = null;
+        }
+
+        if(this._writeEncapsStack !== null)
+        {
+            Debug.assert(this._writeEncapsStack.next);
+            this._writeEncapsStack.next = this._writeEncapsCache;
+            this._writeEncapsCache = this._writeEncapsStack;
+            this._writeEncapsCache.reset();
             this._writeEncapsStack = null;
-            this._readEncapsCache = null;
-            this._writeEncapsCache = null;
+        }
+        this._startSeq = -1;
+        this._sliceObjects = true;
+    },
+    swap: function(other)
+    {
+        Debug.assert(this._instance === other._instance);
+        
+        var tmpBuf, tmpClosure, tmpUnlimited, tmpStartSeq, tmpMinSeqSize, tmpSizePos;
 
-            this._sliceObjects = true;
+        tmpBuf = other._buf;
+        other._buf = this._buf;
+        this._buf = tmpBuf;
 
-            this._messageSizeMax = this._instance.messageSizeMax(); // Cached for efficiency.
-            this._unlimited = unlimited !== undefined ? unlimited : false;
+        tmpClosure = other._closure;
+        other._closure = this._closure;
+        this._closure = tmpClosure;
 
-            this._startSeq = -1;
-            this._sizePos = -1;
-            
-            if(data !== undefined)
-            {
-                this._buf = new Ice.Buffer(data);
-            }
-            else
-            {
-                this._buf = new Ice.Buffer();
-            }
-        },
         //
-        // This function allows this object to be reused, rather than
-        // reallocated.
+        // Swap is never called for BasicStreams that have encapsulations being read/write. However,
+        // encapsulations might still be set in case marshalling or un-marshalling failed. We just
+        // reset the encapsulations if there are still some set.
+        //
+        this.resetEncaps();
+        other.resetEncaps();
+
+        tmpUnlimited = other._unlimited;
+        other._unlimited = this._unlimited;
+        this._unlimited = tmpUnlimited;
+
+        tmpStartSeq = other._startSeq;
+        other._startSeq = this._startSeq;
+        this._startSeq = tmpStartSeq;
+
+        tmpMinSeqSize = other._minSeqSize;
+        other._minSeqSize = this._minSeqSize;
+        this._minSeqSize = tmpMinSeqSize;
+
+        tmpSizePos = other._sizePos;
+        other._sizePos = this._sizePos;
+        this._sizePos = tmpSizePos;
+    },
+    resetEncaps: function()
+    {
+        this._readEncapsStack = null;
+        this._writeEncapsStack = null;
+    },
+    resize: function(sz)
+    {
+        //
+        // Check memory limit if stream is not unlimited.
         //
-        reset: function()
+        if(!this._unlimited && sz > this._messageSizeMax)
         {
-            this._buf.reset();
-            this.clear();
-        },
-        clear: function()
+            ExUtil.throwMemoryLimitException(sz, this._messageSizeMax);
+        }
+
+        this._buf.resize(sz);
+        this._buf.position = sz;
+    },
+    prepareWrite: function()
+    {
+        this._buf.position = 0;
+        return this._buf;
+    },
+    startWriteObject: function(data)
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.startInstance(SliceType.ObjectSlice, data);
+    },
+    endWriteObject: function()
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.endInstance();
+    },
+    startReadObject: function()
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        this._readEncapsStack.decoder.startInstance(SliceType.ObjectSlice);
+    },
+    endReadObject: function(preserve)
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        return this._readEncapsStack.decoder.endInstance(preserve);
+    },
+    startWriteException: function(data)
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.startInstance(SliceType.ExceptionSlice, data);
+    },
+    endWriteException: function()
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.endInstance();
+    },
+    startReadException: function()
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        this._readEncapsStack.decoder.startInstance(SliceType.ExceptionSlice);
+    },
+    endReadException: function(preserve)
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        return this._readEncapsStack.decoder.endInstance(preserve);
+    },
+    startWriteEncaps: function(encoding, format)
+    {
+        //
+        // If no encoding version is specified, use the current write
+        // encapsulation encoding version if there's a current write
+        // encapsulation, otherwise, use the stream encoding version.
+        //
+
+        if(encoding === undefined)
         {
-            if(this._readEncapsStack !== null)
+            if(this._writeEncapsStack !== null)
             {
-                Debug.assert(this._readEncapsStack.next);
-                this._readEncapsStack.next = this._readEncapsCache;
-                this._readEncapsCache = this._readEncapsStack;
-                this._readEncapsCache.reset();
-                this._readEncapsStack = null;
+                encoding = this._writeEncapsStack.encoding;
+                format = this._writeEncapsStack.format;
             }
-
-            if(this._writeEncapsStack !== null)
+            else
             {
-                Debug.assert(this._writeEncapsStack.next);
-                this._writeEncapsStack.next = this._writeEncapsCache;
-                this._writeEncapsCache = this._writeEncapsStack;
-                this._writeEncapsCache.reset();
-                this._writeEncapsStack = null;
+                encoding = this._encoding;
+                format = FormatType.DefaultFormat;
             }
-            this._startSeq = -1;
-            this._sliceObjects = true;
-        },
-        swap: function(other)
-        {
-            Debug.assert(this._instance === other._instance);
-            
-            var tmpBuf, tmpClosure, tmpUnlimited, tmpStartSeq, tmpMinSeqSize, tmpSizePos;
-
-            tmpBuf = other._buf;
-            other._buf = this._buf;
-            this._buf = tmpBuf;
-
-            tmpClosure = other._closure;
-            other._closure = this._closure;
-            this._closure = tmpClosure;
-
-            //
-            // Swap is never called for BasicStreams that have encapsulations being read/write. However,
-            // encapsulations might still be set in case marshalling or un-marshalling failed. We just
-            // reset the encapsulations if there are still some set.
-            //
-            this.resetEncaps();
-            other.resetEncaps();
-
-            tmpUnlimited = other._unlimited;
-            other._unlimited = this._unlimited;
-            this._unlimited = tmpUnlimited;
-
-            tmpStartSeq = other._startSeq;
-            other._startSeq = this._startSeq;
-            this._startSeq = tmpStartSeq;
+        }
 
-            tmpMinSeqSize = other._minSeqSize;
-            other._minSeqSize = this._minSeqSize;
-            this._minSeqSize = tmpMinSeqSize;
+        Protocol.checkSupportedEncoding(encoding);
 
-            tmpSizePos = other._sizePos;
-            other._sizePos = this._sizePos;
-            this._sizePos = tmpSizePos;
-        },
-        resetEncaps: function()
+        var curr = this._writeEncapsCache;
+        if(curr !== null)
         {
-            this._readEncapsStack = null;
-            this._writeEncapsStack = null;
-        },
-        resize: function(sz)
+            curr.reset();
+            this._writeEncapsCache = this._writeEncapsCache.next;
+        }
+        else
         {
-            //
-            // Check memory limit if stream is not unlimited.
-            //
-            if(!this._unlimited && sz > this._messageSizeMax)
-            {
-                ExUtil.throwMemoryLimitException(sz, this._messageSizeMax);
-            }
+            curr = new WriteEncaps();
+        }
+        curr.next = this._writeEncapsStack;
+        this._writeEncapsStack = curr;
 
-            this._buf.resize(sz);
-            this._buf.position = sz;
-        },
-        prepareWrite: function()
-        {
-            this._buf.position = 0;
-            return this._buf;
-        },
-        startWriteObject: function(data)
-        {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.startInstance(SliceType.ObjectSlice, data);
-        },
-        endWriteObject: function()
-        {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.endInstance();
-        },
-        startReadObject: function()
-        {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            this._readEncapsStack.decoder.startInstance(SliceType.ObjectSlice);
-        },
-        endReadObject: function(preserve)
-        {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            return this._readEncapsStack.decoder.endInstance(preserve);
-        },
-        startWriteException: function(data)
-        {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.startInstance(SliceType.ExceptionSlice, data);
-        },
-        endWriteException: function()
+        this._writeEncapsStack.format = format;
+        this._writeEncapsStack.setEncoding(encoding);
+        this._writeEncapsStack.start = this._buf.limit;
+
+        this.writeInt(0); // Placeholder for the encapsulation length.
+        this._writeEncapsStack.encoding.__write(this);
+    },
+    endWriteEncaps: function()
+    {
+        Debug.assert(this._writeEncapsStack);
+
+        // Size includes size and version.
+        var start = this._writeEncapsStack.start;
+        
+        var sz = this._buf.limit - start;
+        this._buf.putIntAt(start, sz);
+
+        var curr = this._writeEncapsStack;
+        this._writeEncapsStack = curr.next;
+        curr.next = this._writeEncapsCache;
+        this._writeEncapsCache = curr;
+        this._writeEncapsCache.reset();
+    },
+    endWriteEncapsChecked: function() // Used by public stream API.
+    {
+        if(this._writeEncapsStack === null)
         {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.endInstance();
-        },
-        startReadException: function()
+            throw new Ice.EncapsulationException("not in an encapsulation");
+        }
+        this.endWriteEncaps();
+    },
+    writeEmptyEncaps: function(encoding)
+    {
+        Protocol.checkSupportedEncoding(encoding);
+        this.writeInt(6); // Size
+        encoding.__write(this);
+    },
+    writeEncaps: function(v)
+    {
+        if(v.length < 6)
         {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            this._readEncapsStack.decoder.startInstance(SliceType.ExceptionSlice);
-        },
-        endReadException: function(preserve)
+            throw new Ice.EncapsulationException();
+        }
+        this.expand(v.length);
+        this._buf.putArray(v);
+    },
+    getWriteEncoding: function()
+    {
+        return this._writeEncapsStack !== null ? this._writeEncapsStack.encoding : this._encoding;
+    },
+    startReadEncaps: function()
+    {
+        var curr = this._readEncapsCache;
+        if(curr !== null)
         {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            return this._readEncapsStack.decoder.endInstance(preserve);
-        },
-        startWriteEncaps: function(encoding, format)
+            curr.reset();
+            this._readEncapsCache = this._readEncapsCache.next;
+        }
+        else
         {
-            //
-            // If no encoding version is specified, use the current write
-            // encapsulation encoding version if there's a current write
-            // encapsulation, otherwise, use the stream encoding version.
-            //
-
-            if(encoding === undefined)
-            {
-                if(this._writeEncapsStack !== null)
-                {
-                    encoding = this._writeEncapsStack.encoding;
-                    format = this._writeEncapsStack.format;
-                }
-                else
-                {
-                    encoding = this._encoding;
-                    format = FormatType.DefaultFormat;
-                }
-            }
-
-            Protocol.checkSupportedEncoding(encoding);
-
-            var curr = this._writeEncapsCache;
-            if(curr !== null)
-            {
-                curr.reset();
-                this._writeEncapsCache = this._writeEncapsCache.next;
-            }
-            else
-            {
-                curr = new WriteEncaps();
-            }
-            curr.next = this._writeEncapsStack;
-            this._writeEncapsStack = curr;
+            curr = new ReadEncaps();
+        }
+        curr.next = this._readEncapsStack;
+        this._readEncapsStack = curr;
 
-            this._writeEncapsStack.format = format;
-            this._writeEncapsStack.setEncoding(encoding);
-            this._writeEncapsStack.start = this._buf.limit;
+        this._readEncapsStack.start = this._buf.position;
 
-            this.writeInt(0); // Placeholder for the encapsulation length.
-            this._writeEncapsStack.encoding.__write(this);
-        },
-        endWriteEncaps: function()
+        //
+        // I don't use readSize() and writeSize() for encapsulations,
+        // because when creating an encapsulation, I must know in advance
+        // how many bytes the size information will require in the data
+        // stream. If I use an Int, it is always 4 bytes. For
+        // readSize()/writeSize(), it could be 1 or 5 bytes.
+        //
+        var sz = this.readInt();
+        if(sz < 6)
+        {
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        if(sz - 4 > this._buf.remaining)
         {
-            Debug.assert(this._writeEncapsStack);
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        this._readEncapsStack.sz = sz;
 
-            // Size includes size and version.
-            var start = this._writeEncapsStack.start;
-            
-            var sz = this._buf.limit - start;
-            this._buf.putIntAt(start, sz);
+        var encoding = new Ice.EncodingVersion();
+        encoding.__read(this);
+        Protocol.checkSupportedEncoding(encoding); // Make sure the encoding is supported.
+        this._readEncapsStack.setEncoding(encoding);
 
-            var curr = this._writeEncapsStack;
-            this._writeEncapsStack = curr.next;
-            curr.next = this._writeEncapsCache;
-            this._writeEncapsCache = curr;
-            this._writeEncapsCache.reset();
-        },
-        endWriteEncapsChecked: function() // Used by public stream API.
-        {
-            if(this._writeEncapsStack === null)
-            {
-                throw new Ice.EncapsulationException("not in an encapsulation");
-            }
-            this.endWriteEncaps();
-        },
-        writeEmptyEncaps: function(encoding)
-        {
-            Protocol.checkSupportedEncoding(encoding);
-            this.writeInt(6); // Size
-            encoding.__write(this);
-        },
-        writeEncaps: function(v)
+        return encoding;
+    },
+    endReadEncaps: function()
+    {
+        Debug.assert(this._readEncapsStack !== null);
+
+        if(!this._readEncapsStack.encoding_1_0)
         {
-            if(v.length < 6)
+            this.skipOpts();
+            if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz)
             {
                 throw new Ice.EncapsulationException();
             }
-            this.expand(v.length);
-            this._buf.putArray(v);
-        },
-        getWriteEncoding: function()
-        {
-            return this._writeEncapsStack !== null ? this._writeEncapsStack.encoding : this._encoding;
-        },
-        startReadEncaps: function()
+        }
+        else if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz)
         {
-            var curr = this._readEncapsCache;
-            if(curr !== null)
-            {
-                curr.reset();
-                this._readEncapsCache = this._readEncapsCache.next;
-            }
-            else
+            if(this._buf.position + 1 !== this._readEncapsStack.start + this._readEncapsStack.sz)
             {
-                curr = new ReadEncaps();
+                throw new Ice.EncapsulationException();
             }
-            curr.next = this._readEncapsStack;
-            this._readEncapsStack = curr;
-
-            this._readEncapsStack.start = this._buf.position;
-
+            
             //
-            // I don't use readSize() and writeSize() for encapsulations,
-            // because when creating an encapsulation, I must know in advance
-            // how many bytes the size information will require in the data
-            // stream. If I use an Int, it is always 4 bytes. For
-            // readSize()/writeSize(), it could be 1 or 5 bytes.
+            // Ice version < 3.3 had a bug where user exceptions with
+            // class members could be encoded with a trailing byte
+            // when dispatched with AMD. So we tolerate an extra byte
+            // in the encapsulation.
             //
-            var sz = this.readInt();
-            if(sz < 6)
+            
+            try
             {
-                throw new Ice.UnmarshalOutOfBoundsException();
+                this._buf.get();
             }
-            if(sz - 4 > this._buf.remaining)
+            catch(ex)
             {
                 throw new Ice.UnmarshalOutOfBoundsException();
             }
-            this._readEncapsStack.sz = sz;
-
-            var encoding = new Ice.EncodingVersion();
-            encoding.__read(this);
-            Protocol.checkSupportedEncoding(encoding); // Make sure the encoding is supported.
-            this._readEncapsStack.setEncoding(encoding);
+        }
 
-            return encoding;
-        },
-        endReadEncaps: function()
+        var curr = this._readEncapsStack;
+        this._readEncapsStack = curr.next;
+        curr.next = this._readEncapsCache;
+        this._readEncapsCache = curr;
+        this._readEncapsCache.reset();
+    },
+    skipEmptyEncaps: function(encoding)
+    {
+        Debug.assert(encoding !== undefined);
+        var sz = this.readInt();
+        if(sz !== 6)
         {
-            Debug.assert(this._readEncapsStack !== null);
-
-            if(!this._readEncapsStack.encoding_1_0)
-            {
-                this.skipOpts();
-                if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz)
-                {
-                    throw new Ice.EncapsulationException();
-                }
-            }
-            else if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz)
-            {
-                if(this._buf.position + 1 !== this._readEncapsStack.start + this._readEncapsStack.sz)
-                {
-                    throw new Ice.EncapsulationException();
-                }
-                
-                //
-                // Ice version < 3.3 had a bug where user exceptions with
-                // class members could be encoded with a trailing byte
-                // when dispatched with AMD. So we tolerate an extra byte
-                // in the encapsulation.
-                //
-                
-                try
-                {
-                    this._buf.get();
-                }
-                catch(ex)
-                {
-                    throw new Ice.UnmarshalOutOfBoundsException();
-                }
-            }
+            throw new Ice.EncapsulationException();
+        }
 
-            var curr = this._readEncapsStack;
-            this._readEncapsStack = curr.next;
-            curr.next = this._readEncapsCache;
-            this._readEncapsCache = curr;
-            this._readEncapsCache.reset();
-        },
-        skipEmptyEncaps: function(encoding)
+        var pos = this._buf.position;
+        if(pos + 2 > this._buf.limit)
         {
-            Debug.assert(encoding !== undefined);
-            var sz = this.readInt();
-            if(sz !== 6)
-            {
-                throw new Ice.EncapsulationException();
-            }
-
-            var pos = this._buf.position;
-            if(pos + 2 > this._buf.limit)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
 
-            if(encoding !== null)
-            {
-                encoding.__read(this);
-            }
-            else
-            {
-                this._buf.position = pos + 2;
-            }
-        },
-        endReadEncapsChecked: function() // Used by public stream API.
+        if(encoding !== null)
         {
-            if(this._readEncapsStack === null)
-            {
-                throw new Ice.EncapsulationException("not in an encapsulation");
-            }
-            this.endReadEncaps();
-        },
-        readEncaps: function(encoding)
+            encoding.__read(this);
+        }
+        else
         {
-            Debug.assert(encoding !== undefined);
-            var sz = this.readInt();
-            if(sz < 6)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
+            this._buf.position = pos + 2;
+        }
+    },
+    endReadEncapsChecked: function() // Used by public stream API.
+    {
+        if(this._readEncapsStack === null)
+        {
+            throw new Ice.EncapsulationException("not in an encapsulation");
+        }
+        this.endReadEncaps();
+    },
+    readEncaps: function(encoding)
+    {
+        Debug.assert(encoding !== undefined);
+        var sz = this.readInt();
+        if(sz < 6)
+        {
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
 
-            if(sz - 4 > this._buf.remaining)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
+        if(sz - 4 > this._buf.remaining)
+        {
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
 
-            if(encoding !== null)
-            {
-                encoding.__read(this);
-                this._buf.position = this._buf.position - 6;
-            }
-            else
-            {
-                this._buf.position = this._buf.position - 4;
-            }
+        if(encoding !== null)
+        {
+            encoding.__read(this);
+            this._buf.position = this._buf.position - 6;
+        }
+        else
+        {
+            this._buf.position = this._buf.position - 4;
+        }
 
-            try
-            {
-                return this._buf.getArray(sz);
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        getReadEncoding: function()
+        try
         {
-            return this._readEncapsStack !== null ? this._readEncapsStack.encoding : this._encoding;
-        },
-        getReadEncapsSize: function()
+            return this._buf.getArray(sz);
+        }
+        catch(ex)
         {
-            Debug.assert(this._readEncapsStack !== null);
-            return this._readEncapsStack.sz - 6;
-        },
-        skipEncaps: function()
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    getReadEncoding: function()
+    {
+        return this._readEncapsStack !== null ? this._readEncapsStack.encoding : this._encoding;
+    },
+    getReadEncapsSize: function()
+    {
+        Debug.assert(this._readEncapsStack !== null);
+        return this._readEncapsStack.sz - 6;
+    },
+    skipEncaps: function()
+    {
+        var sz = this.readInt();
+        if(sz < 6)
         {
-            var sz = this.readInt();
-            if(sz < 6)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-            var encoding = new Ice.EncodingVersion();
-            encoding.__read(this);
-            try
-            {
-                this._buf.position = this._buf.position + sz - 6;
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-            return encoding;
-        },
-        startWriteSlice: function(typeId, compactId, last)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        var encoding = new Ice.EncodingVersion();
+        encoding.__read(this);
+        try
         {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.startSlice(typeId, compactId, last);
-        },
-        endWriteSlice: function()
+            this._buf.position = this._buf.position + sz - 6;
+        }
+        catch(ex)
         {
-            Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
-            this._writeEncapsStack.encoder.endSlice();
-        },
-        startReadSlice: function() // Returns type ID of next slice
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        return encoding;
+    },
+    startWriteSlice: function(typeId, compactId, last)
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.startSlice(typeId, compactId, last);
+    },
+    endWriteSlice: function()
+    {
+        Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null);
+        this._writeEncapsStack.encoder.endSlice();
+    },
+    startReadSlice: function() // Returns type ID of next slice
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        return this._readEncapsStack.decoder.startSlice();
+    },
+    endReadSlice: function()
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        this._readEncapsStack.decoder.endSlice();
+    },
+    skipSlice: function()
+    {
+        Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
+        this._readEncapsStack.decoder.skipSlice();
+    },
+    readPendingObjects: function()
+    {
+        if(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null)
         {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            return this._readEncapsStack.decoder.startSlice();
-        },
-        endReadSlice: function()
+            this._readEncapsStack.decoder.readPendingObjects();
+        }
+        else if((this._readEncapsStack !== null && this._readEncapsStack.encoding_1_0) ||
+                (this._readEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0)))
         {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            this._readEncapsStack.decoder.endSlice();
-        },
-        skipSlice: function()
+            //
+            // If using the 1.0 encoding and no objects were read, we
+            // still read an empty sequence of pending objects if
+            // requested (i.e.: if this is called).
+            //
+            // This is required by the 1.0 encoding, even if no objects
+            // are written we do marshal an empty sequence if marshaled
+            // data types use classes.
+            //
+            this.skipSize();
+        }
+    },
+    writePendingObjects: function()
+    {
+        if(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null)
         {
-            Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null);
-            this._readEncapsStack.decoder.skipSlice();
-        },
-        readPendingObjects: function()
+            this._writeEncapsStack.encoder.writePendingObjects();
+        }
+        else if((this._writeEncapsStack !== null && this._writeEncapsStack.encoding_1_0) ||
+                (this._writeEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0)))
         {
-            if(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null)
-            {
-                this._readEncapsStack.decoder.readPendingObjects();
-            }
-            else if((this._readEncapsStack !== null && this._readEncapsStack.encoding_1_0) ||
-                    (this._readEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0)))
-            {
-                //
-                // If using the 1.0 encoding and no objects were read, we
-                // still read an empty sequence of pending objects if
-                // requested (i.e.: if this is called).
-                //
-                // This is required by the 1.0 encoding, even if no objects
-                // are written we do marshal an empty sequence if marshaled
-                // data types use classes.
-                //
-                this.skipSize();
-            }
-        },
-        writePendingObjects: function()
+            //
+            // If using the 1.0 encoding and no objects were written, we
+            // still write an empty sequence for pending objects if
+            // requested (i.e.: if this is called).
+            // 
+            // This is required by the 1.0 encoding, even if no objects
+            // are written we do marshal an empty sequence if marshaled
+            // data types use classes.
+            //
+            this.writeSize(0);
+        }
+    },
+    writeSize: function(v)
+    {
+        if(v > 254)
         {
-            if(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null)
-            {
-                this._writeEncapsStack.encoder.writePendingObjects();
-            }
-            else if((this._writeEncapsStack !== null && this._writeEncapsStack.encoding_1_0) ||
-                    (this._writeEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0)))
-            {
-                //
-                // If using the 1.0 encoding and no objects were written, we
-                // still write an empty sequence for pending objects if
-                // requested (i.e.: if this is called).
-                // 
-                // This is required by the 1.0 encoding, even if no objects
-                // are written we do marshal an empty sequence if marshaled
-                // data types use classes.
-                //
-                this.writeSize(0);
-            }
-        },
-        writeSize: function(v)
+            this.expand(5);
+            this._buf.put(255);
+            this._buf.putInt(v);
+        }
+        else
         {
-            if(v > 254)
-            {
-                this.expand(5);
-                this._buf.put(255);
-                this._buf.putInt(v);
-            }
-            else
-            {
-                this.expand(1);
-                this._buf.put(v);
-            }
-        },
-        readSize: function()
+            this.expand(1);
+            this._buf.put(v);
+        }
+    },
+    readSize: function()
+    {
+        try
         {
-            try
+            var b = this._buf.get();
+            if(b === 255)
             {
-                var b = this._buf.get();
-                if(b === 255)
+                var v = this._buf.getInt();
+                if(v < 0)
                 {
-                    var v = this._buf.getInt();
-                    if(v < 0)
-                    {
-                        throw new Ice.UnmarshalOutOfBoundsException();
-                    }
-                    return v;
+                    throw new Ice.UnmarshalOutOfBoundsException();
                 }
-                return b;
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
+                return v;
             }
-        },
-        readAndCheckSeqSize: function(minSize)
+            return b;
+        }
+        catch(ex)
         {
-            var sz = this.readSize();
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    readAndCheckSeqSize: function(minSize)
+    {
+        var sz = this.readSize();
 
-            if(sz === 0)
-            {
-                return sz;
-            }
+        if(sz === 0)
+        {
+            return sz;
+        }
 
-            //
-            // The _startSeq variable points to the start of the sequence for which
-            // we expect to read at least _minSeqSize bytes from the stream.
-            //
-            // If not initialized or if we already read more data than _minSeqSize,
-            // we reset _startSeq and _minSeqSize for this sequence (possibly a
-            // top-level sequence or enclosed sequence it doesn't really matter).
-            //
-            // Otherwise, we are reading an enclosed sequence and we have to bump
-            // _minSeqSize by the minimum size that this sequence will  require on
-            // the stream.
-            //
-            // The goal of this check is to ensure that when we start un-marshalling
-            // a new sequence, we check the minimal size of this new sequence against
-            // the estimated remaining buffer size. This estimatation is based on
-            // the minimum size of the enclosing sequences, it's _minSeqSize.
-            //
-            if(this._startSeq === -1 || this._buf.position > (this._startSeq + this._minSeqSize))
-            {
-                this._startSeq = this._buf.position;
-                this._minSeqSize = sz * minSize;
-            }
-            else
-            {
-                this._minSeqSize += sz * minSize;
-            }
+        //
+        // The _startSeq variable points to the start of the sequence for which
+        // we expect to read at least _minSeqSize bytes from the stream.
+        //
+        // If not initialized or if we already read more data than _minSeqSize,
+        // we reset _startSeq and _minSeqSize for this sequence (possibly a
+        // top-level sequence or enclosed sequence it doesn't really matter).
+        //
+        // Otherwise, we are reading an enclosed sequence and we have to bump
+        // _minSeqSize by the minimum size that this sequence will  require on
+        // the stream.
+        //
+        // The goal of this check is to ensure that when we start un-marshalling
+        // a new sequence, we check the minimal size of this new sequence against
+        // the estimated remaining buffer size. This estimatation is based on
+        // the minimum size of the enclosing sequences, it's _minSeqSize.
+        //
+        if(this._startSeq === -1 || this._buf.position > (this._startSeq + this._minSeqSize))
+        {
+            this._startSeq = this._buf.position;
+            this._minSeqSize = sz * minSize;
+        }
+        else
+        {
+            this._minSeqSize += sz * minSize;
+        }
 
-            //
-            // If there isn't enough data to read on the stream for the sequence (and
-            // possibly enclosed sequences), something is wrong with the marshalled
-            // data: it's claiming having more data that what is possible to read.
-            //
-            if(this._startSeq + this._minSeqSize > this._buf.limit)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
+        //
+        // If there isn't enough data to read on the stream for the sequence (and
+        // possibly enclosed sequences), something is wrong with the marshalled
+        // data: it's claiming having more data that what is possible to read.
+        //
+        if(this._startSeq + this._minSeqSize > this._buf.limit)
+        {
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
 
-            return sz;
-        },
-        startSize: function()
+        return sz;
+    },
+    startSize: function()
+    {
+        var pos = this._buf.position;
+        this.writeInt(0); // Placeholder for 32-bit size
+        return pos;
+    },
+    endSize: function(pos)
+    {
+        Debug.assert(pos >= 0);
+        this.rewriteInt(this._buf.position - pos - 4, pos);
+    },
+    writeBlob: function(v)
+    {
+        if(v === null)
         {
-            var pos = this._buf.position;
-            this.writeInt(0); // Placeholder for 32-bit size
-            return pos;
-        },
-        endSize: function(pos)
+            return;
+        }
+        this.expand(v.length);
+        this._buf.putArray(v);
+    },
+    readBlob: function(sz)
+    {
+        if(this._buf.remaining < sz)
         {
-            Debug.assert(pos >= 0);
-            this.rewriteInt(this._buf.position - pos - 4, pos);
-        },
-        writeBlob: function(v)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        try
         {
-            if(v === null)
-            {
-                return;
-            }
-            this.expand(v.length);
-            this._buf.putArray(v);
-        },
-        readBlob: function(sz)
+            return this._buf.getArray(sz);
+        }
+        catch(ex)
         {
-            if(this._buf.remaining < sz)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-            try
-            {
-                return this._buf.getArray(sz);
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        // Read/write format and tag for optionals
-        writeOpt: function(tag, format)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    // Read/write format and tag for optionals
+    writeOpt: function(tag, format)
+    {
+        Debug.assert(this._writeEncapsStack !== null);
+        if(this._writeEncapsStack.encoder !== null)
         {
-            Debug.assert(this._writeEncapsStack !== null);
-            if(this._writeEncapsStack.encoder !== null)
-            {
-                return this._writeEncapsStack.encoder.writeOpt(tag, format);
-            }
-            return this.writeOptImpl(tag, format);
-        },
-        readOpt: function(tag, expectedFormat)
+            return this._writeEncapsStack.encoder.writeOpt(tag, format);
+        }
+        return this.writeOptImpl(tag, format);
+    },
+    readOpt: function(tag, expectedFormat)
+    {
+        Debug.assert(this._readEncapsStack !== null);
+        if(this._readEncapsStack.decoder !== null)
         {
-            Debug.assert(this._readEncapsStack !== null);
-            if(this._readEncapsStack.decoder !== null)
-            {
-                return this._readEncapsStack.decoder.readOpt(tag, expectedFormat);
-            }
-            return this.readOptImpl(tag, expectedFormat);
-        },
-        writeOptValue: function(tag, format, write, v)
+            return this._readEncapsStack.decoder.readOpt(tag, expectedFormat);
+        }
+        return this.readOptImpl(tag, expectedFormat);
+    },
+    writeOptValue: function(tag, format, write, v)
+    {
+        if(v !== undefined)
         {
-            if(v !== undefined)
+            if(this.writeOpt(tag, format))
             {
-                if(this.writeOpt(tag, format))
-                {
-                    write.call(this, v);
-                }
+                write.call(this, v);
             }
-        },
-        readOptValue: function(tag, format, read)
+        }
+    },
+    readOptValue: function(tag, format, read)
+    {
+        if(this.readOpt(tag, format))
         {
-            if(this.readOpt(tag, format))
-            {
-                return read.call(this);
-            }
-            else
-            {
-                return undefined;
-            }
-        },
-        writeByte: function(v)
+            return read.call(this);
+        }
+        else
         {
-            this.expand(1);
-            this._buf.put(v);
-        },
-        rewriteByte: function(v, dest)
+            return undefined;
+        }
+    },
+    writeByte: function(v)
+    {
+        this.expand(1);
+        this._buf.put(v);
+    },
+    rewriteByte: function(v, dest)
+    {
+        this._buf.putAt(dest, v);
+    },
+    readByte: function()
+    {
+        try
         {
-            this._buf.putAt(dest, v);
-        },
-        readByte: function()
+            return this._buf.get();
+        }
+        catch(ex)
         {
-            try
-            {
-                return this._buf.get();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeByteSeq: function(v)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeByteSeq: function(v)
+    {
+        if(v === null || v.length === 0)
         {
-            if(v === null || v.length === 0)
-            {
-                this.writeSize(0);
-            }
-            else
-            {
-                this.writeSize(v.length);
-                this.expand(v.length);
-                this._buf.putArray(v);
-            }
-        },
-        readByteSeq: function()
+            this.writeSize(0);
+        }
+        else
         {
-            return this._buf.getArray(this.readAndCheckSeqSize(1));
-        },
-        writeBool: function(v)
+            this.writeSize(v.length);
+            this.expand(v.length);
+            this._buf.putArray(v);
+        }
+    },
+    readByteSeq: function()
+    {
+        return this._buf.getArray(this.readAndCheckSeqSize(1));
+    },
+    writeBool: function(v)
+    {
+        this.expand(1);
+        this._buf.put(v ? 1 : 0);
+    },
+    rewriteBool: function(v, dest)
+    {
+        this._buf.putAt(dest, v ? 1 : 0);
+    },
+    readBool: function()
+    {
+        try
         {
-            this.expand(1);
-            this._buf.put(v ? 1 : 0);
-        },
-        rewriteBool: function(v, dest)
+            return this._buf.get() === 1;
+        }
+        catch(ex)
         {
-            this._buf.putAt(dest, v ? 1 : 0);
-        },
-        readBool: function()
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeShort: function(v)
+    {
+        this.expand(2);
+        this._buf.putShort(v);
+    },
+    readShort: function()
+    {
+        try
         {
-            try
-            {
-                return this._buf.get() === 1;
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeShort: function(v)
+            return this._buf.getShort();
+        }
+        catch(ex)
         {
-            this.expand(2);
-            this._buf.putShort(v);
-        },
-        readShort: function()
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeInt: function(v)
+    {
+        this.expand(4);
+        this._buf.putInt(v);
+    },
+    rewriteInt: function(v, dest)
+    {
+        this._buf.putIntAt(dest, v);
+    },
+    readInt: function()
+    {
+        try
         {
-            try
-            {
-                return this._buf.getShort();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeInt: function(v)
+            return this._buf.getInt();
+        }
+        catch(ex)
         {
-            this.expand(4);
-            this._buf.putInt(v);
-        },
-        rewriteInt: function(v, dest)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeLong: function(v)
+    {
+        this.expand(8);
+        this._buf.putLong(v);
+    },
+    readLong: function()
+    {
+        try
         {
-            this._buf.putIntAt(dest, v);
-        },
-        readInt: function()
+            return this._buf.getLong();
+        }
+        catch(ex)
         {
-            try
-            {
-                return this._buf.getInt();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeLong: function(v)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeFloat: function(v)
+    {
+        this.expand(4);
+        this._buf.putFloat(v);
+    },
+    readFloat: function()
+    {
+        try
         {
-            this.expand(8);
-            this._buf.putLong(v);
-        },
-        readLong: function()
+            return this._buf.getFloat();
+        }
+        catch(ex)
         {
-            try
-            {
-                return this._buf.getLong();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeFloat: function(v)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeDouble: function(v)
+    {
+        this.expand(8);
+        this._buf.putDouble(v);
+    },
+    readDouble: function()
+    {
+        try
         {
-            this.expand(4);
-            this._buf.putFloat(v);
-        },
-        readFloat: function()
+            return this._buf.getDouble();
+        }
+        catch(ex)
         {
-            try
-            {
-                return this._buf.getFloat();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeDouble: function(v)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeString: function(v)
+    {
+        if(v === null || v.length === 0)
         {
-            this.expand(8);
-            this._buf.putDouble(v);
-        },
-        readDouble: function()
+            this.writeSize(0);
+        }
+        else
         {
-            try
-            {
-                return this._buf.getDouble();
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeString: function(v)
+            this._buf.writeString(this, v);
+        }
+    },
+    readString: function()
+    {
+        var len = this.readSize();
+        if(len === 0)
         {
-            if(v === null || v.length === 0)
-            {
-                this.writeSize(0);
-            }
-            else
-            {
-                this._buf.writeString(this, v);
-            }
-        },
-        readString: function()
+            return "";
+        }
+        //
+        // Check the buffer has enough bytes to read.
+        //
+        if(this._buf.remaining < len)
         {
-            var len = this.readSize();
-            if(len === 0)
-            {
-                return "";
-            }
-            //
-            // Check the buffer has enough bytes to read.
-            //
-            if(this._buf.remaining < len)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
 
-            try
-            {
-                return this._buf.getString(len);
-            }
-            catch(ex)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-        },
-        writeProxy: function(v)
+        try
         {
-            this._instance.proxyFactory().proxyToStream(v, this);
-        },
-        writeOptProxy: function(tag, v)
-        {
-            if(v !== undefined)
-            {
-                if(this.writeOpt(tag, OptionalFormat.FSize))
-                {
-                    var pos = this.startSize();
-                    this.writeProxy(v);
-                    this.endSize(pos);
-                }
-            }
-        },
-        readProxy: function(type)
+            return this._buf.getString(len);
+        }
+        catch(ex)
         {
-            return this._instance.proxyFactory().streamToProxy(this, type);
-        },
-        readOptProxy: function(tag, type)
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+    },
+    writeProxy: function(v)
+    {
+        this._instance.proxyFactory().proxyToStream(v, this);
+    },
+    writeOptProxy: function(tag, v)
+    {
+        if(v !== undefined)
         {
-            if(this.readOpt(tag, OptionalFormat.FSize))
+            if(this.writeOpt(tag, OptionalFormat.FSize))
             {
-                this.skip(4);
-                return this.readProxy(type);
+                var pos = this.startSize();
+                this.writeProxy(v);
+                this.endSize(pos);
             }
-            else
-            {
-                return undefined;
-            }
-        },
-        writeEnum: function(v)
+        }
+    },
+    readProxy: function(type)
+    {
+        return this._instance.proxyFactory().streamToProxy(this, type);
+    },
+    readOptProxy: function(tag, type)
+    {
+        if(this.readOpt(tag, OptionalFormat.FSize))
         {
-            if(this.isWriteEncoding_1_0())
-            {
-                if(v.maxValue < 127)
-                {
-                    this.writeByte(v.value);
-                }
-                else if(v.maxValue < 32767)
-                {
-                    this.writeShort(v.value);
-                }
-                else
-                {
-                    this.writeInt(v.value);
-                }
-            }
-            else
-            {
-                this.writeSize(v.value);
-            }
-        },
-        readEnum: function(T)
+            this.skip(4);
+            return this.readProxy(type);
+        }
+        else
         {
-            var v;
-            if(this.getReadEncoding().equals(Ice.Encoding_1_0))
-            {
-                if(T.maxValue < 127)
-                {
-                    v = this.readByte();
-                }
-                else if(T.maxValue < 32767)
-                {
-                    v = this.readShort();
-                }
-                else
-                {
-                    v = this.readInt();
-                }
-            }
-            else
-            {
-                v = this.readSize();
-            }
-            
-            var e = T.valueOf(v);
-            if(e === undefined)
+            return undefined;
+        }
+    },
+    writeEnum: function(v)
+    {
+        if(this.isWriteEncoding_1_0())
+        {
+            if(v.maxValue < 127)
             {
-                throw new Ice.MarshalException("enumerator value " + v + " is out of range");
+                this.writeByte(v.value);
             }
-            return e;
-        },
-        readOptEnum: function(tag, T)
-        {
-            if(this.readOpt(tag, OptionalFormat.Size))
+            else if(v.maxValue < 32767)
             {
-                return this.readEnum(T);
+                this.writeShort(v.value);
             }
             else
             {
-                return undefined;
+                this.writeInt(v.value);
             }
-        },
-        writeObject: function(v)
+        }
+        else
         {
-            this.initWriteEncaps();
-            this._writeEncapsStack.encoder.writeObject(v);
-        },
-        writeOptObject: function(tag, v)
+            this.writeSize(v.value);
+        }
+    },
+    readEnum: function(T)
+    {
+        var v;
+        if(this.getReadEncoding().equals(Ice.Encoding_1_0))
         {
-            if(v !== undefined)
+            if(T.maxValue < 127)
             {
-                if(this.writeOpt(tag, OptionalFormat.Class))
-                {
-                    this.writeObject(v);
-                }
+                v = this.readByte();
             }
-        },
-        readObject: function(patcher, T)
-        {
-            this.initReadEncaps();
-            //
-            // BUGFIX:
-            // With Chrome linux the invokation of readObject on the decoder some times
-            // calls BasicStream.readObject with the decoder object as this param.
-            // Use call instead of directly invoke the method to workaround this bug.
-            //
-            this._readEncapsStack.decoder.readObject.call(
-                this._readEncapsStack.decoder,
-                function(obj){
-                    if(obj !== null && !(obj.ice_instanceof(T)))
-                    {
-                        ExUtil.throwUOE(T.ice_staticId(), obj);
-                    }
-                    patcher(obj);
-                });
-        },
-        readOptObject: function(tag, patcher, T)
-        {
-            if(this.readOpt(tag, OptionalFormat.Class))
+            else if(T.maxValue < 32767)
             {
-                this.readObject(patcher, T);
+                v = this.readShort();
             }
             else
             {
-                patcher(undefined);
+                v = this.readInt();
             }
-        },
-        writeUserException: function(e)
+        }
+        else
         {
-            this.initWriteEncaps();
-            this._writeEncapsStack.encoder.writeUserException(e);
-        },
-        throwException: function()
+            v = this.readSize();
+        }
+        
+        var e = T.valueOf(v);
+        if(e === undefined)
         {
-            this.initReadEncaps();
-            this._readEncapsStack.decoder.throwException();
-        },
-        sliceObjects: function(b)
+            throw new Ice.MarshalException("enumerator value " + v + " is out of range");
+        }
+        return e;
+    },
+    readOptEnum: function(tag, T)
+    {
+        if(this.readOpt(tag, OptionalFormat.Size))
         {
-            this._sliceObjects = b;
-        },
-        readOptImpl: function(readTag, expectedFormat)
+            return this.readEnum(T);
+        }
+        else
         {
-            var b, v, format, tag, offset;
-
-            if(this.isReadEncoding_1_0())
+            return undefined;
+        }
+    },
+    writeObject: function(v)
+    {
+        this.initWriteEncaps();
+        this._writeEncapsStack.encoder.writeObject(v);
+    },
+    writeOptObject: function(tag, v)
+    {
+        if(v !== undefined)
+        {
+            if(this.writeOpt(tag, OptionalFormat.Class))
             {
-                return false; // Optional members aren't supported with the 1.0 encoding.
+                this.writeObject(v);
             }
-
-            while(true)
-            {
-                if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz)
+        }
+    },
+    readObject: function(patcher, T)
+    {
+        this.initReadEncaps();
+        //
+        // BUGFIX:
+        // With Chrome linux the invokation of readObject on the decoder some times
+        // calls BasicStream.readObject with the decoder object as this param.
+        // Use call instead of directly invoke the method to workaround this bug.
+        //
+        this._readEncapsStack.decoder.readObject.call(
+            this._readEncapsStack.decoder,
+            function(obj){
+                if(obj !== null && !(obj.ice_instanceof(T)))
                 {
-                    return false; // End of encapsulation also indicates end of optionals.
+                    ExUtil.throwUOE(T.ice_staticId(), obj);
                 }
+                patcher(obj);
+            });
+    },
+    readOptObject: function(tag, patcher, T)
+    {
+        if(this.readOpt(tag, OptionalFormat.Class))
+        {
+            this.readObject(patcher, T);
+        }
+        else
+        {
+            patcher(undefined);
+        }
+    },
+    writeUserException: function(e)
+    {
+        this.initWriteEncaps();
+        this._writeEncapsStack.encoder.writeUserException(e);
+    },
+    throwException: function()
+    {
+        this.initReadEncaps();
+        this._readEncapsStack.decoder.throwException();
+    },
+    sliceObjects: function(b)
+    {
+        this._sliceObjects = b;
+    },
+    readOptImpl: function(readTag, expectedFormat)
+    {
+        var b, v, format, tag, offset;
 
-                v = this.readByte();
+        if(this.isReadEncoding_1_0())
+        {
+            return false; // Optional members aren't supported with the 1.0 encoding.
+        }
 
-                if(v === OPTIONAL_END_MARKER)
-                {
-                    this._buf.position -= 1; // Rewind.
-                    return false;
-                }
+        while(true)
+        {
+            if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz)
+            {
+                return false; // End of encapsulation also indicates end of optionals.
+            }
 
-                format = OptionalFormat.valueOf(v & 0x07); // First 3 bits.
-                tag = v >> 3;
-                if(tag === 30)
-                {
-                    tag = this.readSize();
-                }
+            v = this.readByte();
 
-                if(tag > readTag)
-                {
-                    offset = tag < 30 ? 1 : (tag < 255 ? 2 : 6); // Rewind
-                    this._buf.position -= offset;
-                    return false; // No optional data members with the requested tag.
-                }
-                
-                if(tag < readTag)
-                {
-                    this.skipOpt(format); // Skip optional data members
-                }
-                else
-                {
-                    if(format !== expectedFormat)
-                    {
-                        throw new Ice.MarshalException("invalid optional data member `" + tag + "': unexpected format");
-                    }
-                    return true;
-                }
-            }
-        },
-        writeOptImpl: function(tag, format)
-        {
-            if(this.isWriteEncoding_1_0())
+            if(v === OPTIONAL_END_MARKER)
             {
-                return false; // Optional members aren't supported with the 1.0 encoding.
+                this._buf.position -= 1; // Rewind.
+                return false;
             }
 
-            var v = format.value;
-            if(tag < 30)
+            format = OptionalFormat.valueOf(v & 0x07); // First 3 bits.
+            tag = v >> 3;
+            if(tag === 30)
             {
-                v |= tag << 3;
-                this.writeByte(v);
+                tag = this.readSize();
             }
-            else
+
+            if(tag > readTag)
             {
-                v |= 0x0F0; // tag = 30
-                this.writeByte(v);
-                this.writeSize(tag);
+                offset = tag < 30 ? 1 : (tag < 255 ? 2 : 6); // Rewind
+                this._buf.position -= offset;
+                return false; // No optional data members with the requested tag.
             }
-            return true;
-        },
-        skipOpt: function(format)
-        {
-            switch(format)
+            
+            if(tag < readTag)
             {
-                case OptionalFormat.F1:
-                    this.skip(1);
-                    break;
-                case OptionalFormat.F2:
-                    this.skip(2);
-                    break;
-                case OptionalFormat.F4:
-                    this.skip(4);
-                    break;
-                case OptionalFormat.F8:
-                    this.skip(8);
-                    break;
-                case OptionalFormat.Size:
-                    this.skipSize();
-                    break;
-                case OptionalFormat.VSize:
-                    this.skip(this.readSize());
-                    break;
-                case OptionalFormat.FSize:
-                    this.skip(this.readInt());
-                    break;
-                case OptionalFormat.Class:
-                    this.readObject(null, Ice.Object);
-                    break;
+                this.skipOpt(format); // Skip optional data members
             }
-        },
-        skipOpts: function()
-        {
-            var b, v, format;
-            //
-            // Skip remaining un-read optional members.
-            //
-            while(true)
+            else
             {
-                if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz)
-                {
-                    return; // End of encapsulation also indicates end of optionals.
-                }
-
-                b = this.readByte();
-                v = b < 0 ? b + 256 : b;
-                if(v === OPTIONAL_END_MARKER)
+                if(format !== expectedFormat)
                 {
-                    return;
+                    throw new Ice.MarshalException("invalid optional data member `" + tag + "': unexpected format");
                 }
-                
-                format = OptionalFormat.valueOf(v & 0x07); // Read first 3 bits.
-                if((v >> 3) === 30)
-                {
-                    this.skipSize();
-                }
-                this.skipOpt(format);
+                return true;
             }
-        },
-        skip: function(size)
+        }
+    },
+    writeOptImpl: function(tag, format)
+    {
+        if(this.isWriteEncoding_1_0())
         {
-            if(size > this._buf.remaining)
-            {
-                throw new Ice.UnmarshalOutOfBoundsException();
-            }
-            this._buf.position += size;
-        },
-        skipSize: function()
+            return false; // Optional members aren't supported with the 1.0 encoding.
+        }
+
+        var v = format.value;
+        if(tag < 30)
         {
-            var b = this.readByte();
-            if(b === 255)
-            {
-                this.skip(4);
-            }
-        },
-        isEmpty: function()
+            v |= tag << 3;
+            this.writeByte(v);
+        }
+        else
         {
-            return this._buf.empty();
-        },
-        expand: function(n)
+            v |= 0x0F0; // tag = 30
+            this.writeByte(v);
+            this.writeSize(tag);
+        }
+        return true;
+    },
+    skipOpt: function(format)
+    {
+        switch(format)
+        {
+            case OptionalFormat.F1:
+                this.skip(1);
+                break;
+            case OptionalFormat.F2:
+                this.skip(2);
+                break;
+            case OptionalFormat.F4:
+                this.skip(4);
+                break;
+            case OptionalFormat.F8:
+                this.skip(8);
+                break;
+            case OptionalFormat.Size:
+                this.skipSize();
+                break;
+            case OptionalFormat.VSize:
+                this.skip(this.readSize());
+                break;
+            case OptionalFormat.FSize:
+                this.skip(this.readInt());
+                break;
+            case OptionalFormat.Class:
+                this.readObject(null, Ice.Object);
+                break;
+        }
+    },
+    skipOpts: function()
+    {
+        var b, v, format;
+        //
+        // Skip remaining un-read optional members.
+        //
+        while(true)
         {
-            if(!this._unlimited && this._buf && this._buf.position + n > this._messageSizeMax)
+            if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz)
             {
-                ExUtil.throwMemoryLimitException(this._buf.position + n, this._messageSizeMax);
+                return; // End of encapsulation also indicates end of optionals.
             }
-            this._buf.expand(n);
-        },
-        createObject: function(id)
-        {
-            var obj = null, Class;
-            try
+
+            b = this.readByte();
+            v = b < 0 ? b + 256 : b;
+            if(v === OPTIONAL_END_MARKER)
             {
-                var typeId = id.length > 2 ? id.substr(2).replace(/::/g, ".") : "";
-                /*jshint -W061 */
-                Class = eval(typeId);
-                /*jshint +W061 */
-                if(Class !== undefined)
-                {
-                    obj = new Class();
-                }
+                return;
             }
-            catch(ex)
+            
+            format = OptionalFormat.valueOf(v & 0x07); // Read first 3 bits.
+            if((v >> 3) === 30)
             {
-                throw new Ice.NoObjectFactoryException("no object factory", id, ex);
+                this.skipSize();
             }
-
-            return obj;
-        },
-        getTypeId: function(compactId)
+            this.skipOpt(format);
+        }
+    },
+    skip: function(size)
+    {
+        if(size > this._buf.remaining)
         {
-            var typeId = Ice.CompactIdRegistry.get(compactId);
-            return typeId === undefined ? "" : typeId;
-        },
-        isReadEncoding_1_0: function()
+            throw new Ice.UnmarshalOutOfBoundsException();
+        }
+        this._buf.position += size;
+    },
+    skipSize: function()
+    {
+        var b = this.readByte();
+        if(b === 255)
         {
-            return this._readEncapsStack !== null ? this._readEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0);
-        },
-        isWriteEncoding_1_0: function()
+            this.skip(4);
+        }
+    },
+    isEmpty: function()
+    {
+        return this._buf.empty();
+    },
+    expand: function(n)
+    {
+        if(!this._unlimited && this._buf && this._buf.position + n > this._messageSizeMax)
         {
-            return this._writeEncapsStack ? this._writeEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0);
-        },
-        initReadEncaps: function()
+            ExUtil.throwMemoryLimitException(this._buf.position + n, this._messageSizeMax);
+        }
+        this._buf.expand(n);
+    },
+    createObject: function(id)
+    {
+        var obj = null, Class;
+        try
         {
-            if(this._readEncapsStack === null) // Lazy initialization
+            var typeId = id.length > 2 ? id.substr(2).replace(/::/g, ".") : "";
+            /*jshint -W061 */
+            Class = __M.type(typeId);
+            /*jshint +W061 */
+            if(Class !== undefined)
             {
-                this._readEncapsStack = this._readEncapsCache;
-                if(this._readEncapsStack !== null)
-                {
-                    this._readEncapsCache = this._readEncapsCache.next;
-                }
-                else
-                {
-                    this._readEncapsStack = new ReadEncaps();
-                }
-                this._readEncapsStack.setEncoding(this._encoding);
-                this._readEncapsStack.sz = this._buf.limit;
+                obj = new Class();
             }
+        }
+        catch(ex)
+        {
+            throw new Ice.NoObjectFactoryException("no object factory", id, ex);
+        }
 
-            if(this._readEncapsStack.decoder === null) // Lazy initialization.
+        return obj;
+    },
+    getTypeId: function(compactId)
+    {
+        var typeId = Ice.CompactIdRegistry.get(compactId);
+        return typeId === undefined ? "" : typeId;
+    },
+    isReadEncoding_1_0: function()
+    {
+        return this._readEncapsStack !== null ? this._readEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0);
+    },
+    isWriteEncoding_1_0: function()
+    {
+        return this._writeEncapsStack ? this._writeEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0);
+    },
+    initReadEncaps: function()
+    {
+        if(this._readEncapsStack === null) // Lazy initialization
+        {
+            this._readEncapsStack = this._readEncapsCache;
+            if(this._readEncapsStack !== null)
             {
-                var factoryManager = this._instance.servantFactoryManager();
-                if(this._readEncapsStack.encoding_1_0)
-                {
-                    this._readEncapsStack.decoder = new EncapsDecoder10(this, this._readEncapsStack, this._sliceObjects, factoryManager);
-                }
-                else
-                {
-                    this._readEncapsStack.decoder = new EncapsDecoder11(this, this._readEncapsStack, this._sliceObjects, factoryManager);
-                }
+                this._readEncapsCache = this._readEncapsCache.next;
             }
-        },
-        initWriteEncaps: function()
-        {
-            if(!this._writeEncapsStack) // Lazy initialization
+            else
             {
-                this._writeEncapsStack = this._writeEncapsCache;
-                if(this._writeEncapsStack)
-                {
-                    this._writeEncapsCache = this._writeEncapsCache.next;
-                }
-                else
-                {
-                    this._writeEncapsStack = new WriteEncaps();
-                }
-                this._writeEncapsStack.setEncoding(this._encoding);
+                this._readEncapsStack = new ReadEncaps();
             }
+            this._readEncapsStack.setEncoding(this._encoding);
+            this._readEncapsStack.sz = this._buf.limit;
+        }
 
-            if(this._writeEncapsStack.format === FormatType.DefaultFormat)
+        if(this._readEncapsStack.decoder === null) // Lazy initialization.
+        {
+            var factoryManager = this._instance.servantFactoryManager();
+            if(this._readEncapsStack.encoding_1_0)
             {
-                this._writeEncapsStack.format = this._instance.defaultsAndOverrides().defaultFormat;
+                this._readEncapsStack.decoder = new EncapsDecoder10(this, this._readEncapsStack, this._sliceObjects, factoryManager);
             }
-
-            if(!this._writeEncapsStack.encoder) // Lazy initialization.
+            else
             {
-                if(this._writeEncapsStack.encoding_1_0)
-                {
-                    this._writeEncapsStack.encoder = new EncapsEncoder10(this, this._writeEncapsStack);
-                }
-                else
-                {
-                    this._writeEncapsStack.encoder = new EncapsEncoder11(this, this._writeEncapsStack);
-                }
+                this._readEncapsStack.decoder = new EncapsDecoder11(this, this._readEncapsStack, this._sliceObjects, factoryManager);
             }
-        },
-        createUserException: function(id)
+        }
+    },
+    initWriteEncaps: function()
+    {
+        if(!this._writeEncapsStack) // Lazy initialization
         {
-            var userEx = null, Class;
-
-            try
+            this._writeEncapsStack = this._writeEncapsCache;
+            if(this._writeEncapsStack)
             {
-                var typeId = id.length > 2 ? id.substr(2).replace(/::/g, ".") : "";
-                /*jshint -W061 */
-                Class = eval(typeId);
-                /*jshint +W061 */
-                if(Class !== undefined)
-                {
-                    userEx = new Class();
-                }
+                this._writeEncapsCache = this._writeEncapsCache.next;
             }
-            catch(ex)
+            else
             {
-                throw new Ice.MarshalException(ex);
+                this._writeEncapsStack = new WriteEncaps();
             }
-
-            return userEx;
+            this._writeEncapsStack.setEncoding(this._encoding);
         }
-    });
-    
-    var defineProperty = Object.defineProperty;
-    
-    defineProperty(BasicStream.prototype, "pos", {
-        get: function() { return this._buf.position; },
-        set: function(n) { this._buf.position = n; }
-    });
-
-    defineProperty(BasicStream.prototype, "size", {
-        get: function() { return this._buf.limit; }
-    });
-    
-    defineProperty(BasicStream.prototype, "instance", {
-        get: function() { return this._instance; }
-    });
 
-    defineProperty(BasicStream.prototype, "closure", {
-        get: function() { return this._type; },
-        set: function(type) { this._type = type; }
-    });
+        if(this._writeEncapsStack.format === FormatType.DefaultFormat)
+        {
+            this._writeEncapsStack.format = this._instance.defaultsAndOverrides().defaultFormat;
+        }
 
-    defineProperty(BasicStream.prototype, "buffer", {
-        get: function() { return this._buf; }
-    });
-    
-    var defineBuiltinHelper = function(write, read, sz, format)
+        if(!this._writeEncapsStack.encoder) // Lazy initialization.
+        {
+            if(this._writeEncapsStack.encoding_1_0)
+            {
+                this._writeEncapsStack.encoder = new EncapsEncoder10(this, this._writeEncapsStack);
+            }
+            else
+            {
+                this._writeEncapsStack.encoder = new EncapsEncoder11(this, this._writeEncapsStack);
+            }
+        }
+    },
+    createUserException: function(id)
     {
-        var helper = {
-            write: function(os, v) { return write.call(os, v); },
-            read: function(is) { return read.call(is); },
-            writeOpt: function(os, tag, v) { os.writeOptValue(tag, format, write, v); },
-            readOpt: function(is, tag) { return is.readOptValue(tag, format, read); },
-        };
-        defineProperty(helper, "minWireSize", {
-            get: function() { return sz; }
-        });
-        return helper;
-    };
+        var userEx = null, Class;
 
-    var stream = BasicStream.prototype;
-    Ice.ByteHelper = defineBuiltinHelper(stream.writeByte, stream.readByte, 1, Ice.OptionalFormat.F1);
-    Ice.BoolHelper = defineBuiltinHelper(stream.writeBool, stream.readBool, 1, Ice.OptionalFormat.F1);
-    Ice.ShortHelper = defineBuiltinHelper(stream.writeShort, stream.readShort, 2, Ice.OptionalFormat.F2);
-    Ice.IntHelper = defineBuiltinHelper(stream.writeInt, stream.readInt, 4, Ice.OptionalFormat.F4);
-    Ice.LongHelper = defineBuiltinHelper(stream.writeLong, stream.readLong, 8, Ice.OptionalFormat.F8);
-    Ice.FloatHelper = defineBuiltinHelper(stream.writeFloat, stream.readFloat, 4, Ice.OptionalFormat.F4);
-    Ice.DoubleHelper = defineBuiltinHelper(stream.writeDouble, stream.readDouble, 8, Ice.OptionalFormat.F8);
-    Ice.StringHelper = defineBuiltinHelper(stream.writeString, stream.readString, 1, Ice.OptionalFormat.VSize);
-    
-    Ice.ObjectHelper = {
-        write: function(os, v)
-        {
-            os.writeObject(v);
-        },
-        read: function(is)
-        {
-            var o;
-            is.readObject(function(v) { o = v; }, Ice.Object);
-            return o;
-        },
-        writeOpt: function(os, tag, v)
-        {
-            os.writeOptValue(tag, Ice.OptionalFormat.Class, stream.writeObject, v);
-        },
-        readOpt: function(is, tag)
-        {
-            var o;
-            is.readOptObject(tag, function(v) { o = v; }, Ice.Object);
-            return o;
-        },
+        try
+        {
+            var typeId = id.length > 2 ? id.substr(2).replace(/::/g, ".") : "";
+            /*jshint -W061 */
+            Class = __M.type(typeId);
+            /*jshint +W061 */
+            if(Class !== undefined)
+            {
+                userEx = new Class();
+            }
+        }
+        catch(ex)
+        {
+            throw new Ice.MarshalException(ex);
+        }
+
+        return userEx;
+    }
+});
+
+var defineProperty = Object.defineProperty;
+
+defineProperty(BasicStream.prototype, "pos", {
+    get: function() { return this._buf.position; },
+    set: function(n) { this._buf.position = n; }
+});
+
+defineProperty(BasicStream.prototype, "size", {
+    get: function() { return this._buf.limit; }
+});
+
+defineProperty(BasicStream.prototype, "instance", {
+    get: function() { return this._instance; }
+});
+
+defineProperty(BasicStream.prototype, "closure", {
+    get: function() { return this._type; },
+    set: function(type) { this._type = type; }
+});
+
+defineProperty(BasicStream.prototype, "buffer", {
+    get: function() { return this._buf; }
+});
+
+var defineBuiltinHelper = function(write, read, sz, format)
+{
+    var helper = {
+        write: function(os, v) { return write.call(os, v); },
+        read: function(is) { return read.call(is); },
+        writeOpt: function(os, tag, v) { os.writeOptValue(tag, format, write, v); },
+        readOpt: function(is, tag) { return is.readOptValue(tag, format, read); },
     };
-    
-    defineProperty(Ice.ObjectHelper, "minWireSize", {
-        get: function() { return 1; }
+    defineProperty(helper, "minWireSize", {
+        get: function() { return sz; }
     });
-
-    Ice.BasicStream = BasicStream;
-    global.Ice = Ice;
-}(typeof (global) === "undefined" ? window : global));
+    return helper;
+};
+
+var stream = BasicStream.prototype;
+Ice.ByteHelper = defineBuiltinHelper(stream.writeByte, stream.readByte, 1, Ice.OptionalFormat.F1);
+Ice.BoolHelper = defineBuiltinHelper(stream.writeBool, stream.readBool, 1, Ice.OptionalFormat.F1);
+Ice.ShortHelper = defineBuiltinHelper(stream.writeShort, stream.readShort, 2, Ice.OptionalFormat.F2);
+Ice.IntHelper = defineBuiltinHelper(stream.writeInt, stream.readInt, 4, Ice.OptionalFormat.F4);
+Ice.LongHelper = defineBuiltinHelper(stream.writeLong, stream.readLong, 8, Ice.OptionalFormat.F8);
+Ice.FloatHelper = defineBuiltinHelper(stream.writeFloat, stream.readFloat, 4, Ice.OptionalFormat.F4);
+Ice.DoubleHelper = defineBuiltinHelper(stream.writeDouble, stream.readDouble, 8, Ice.OptionalFormat.F8);
+Ice.StringHelper = defineBuiltinHelper(stream.writeString, stream.readString, 1, Ice.OptionalFormat.VSize);
+
+Ice.ObjectHelper = {
+    write: function(os, v)
+    {
+        os.writeObject(v);
+    },
+    read: function(is)
+    {
+        var o;
+        is.readObject(function(v) { o = v; }, Ice.Object);
+        return o;
+    },
+    writeOpt: function(os, tag, v)
+    {
+        os.writeOptValue(tag, Ice.OptionalFormat.Class, stream.writeObject, v);
+    },
+    readOpt: function(is, tag)
+    {
+        var o;
+        is.readOptObject(tag, function(v) { o = v; }, Ice.Object);
+        return o;
+    },
+};
+
+defineProperty(Ice.ObjectHelper, "minWireSize", {
+    get: function() { return 1; }
+});
+
+Ice.BasicStream = BasicStream;
+module.exports.Ice = Ice;