initial check-in

20 files changed, 10040 insertions, 0 deletions

diff --git a/cpp/src/Transform/.depend b/cpp/src/Transform/.depend
new file mode 100644
index 00000000000..d7e730e4f6b
--- /dev/null
+++ b/cpp/src/Transform/.depend
@@ -0,0 +1,11 @@
+Grammar.o: Grammar.cpp ../Transform/GrammarUtil.h ../Transform/Node.h ../Transform/Data.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h ../Transform/Parser.h
+Scanner.o: Scanner.cpp ../../include/IceUtil/Config.h ../Transform/GrammarUtil.h ../Transform/Node.h ../Transform/Data.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h ../Transform/Parser.h ../Transform/Grammar.h
+Analyzer.o: Analyzer.cpp ../Transform/Analyzer.h ../../include/Slice/Parser.h ../../include/IceUtil/Shared.h ../../include/IceUtil/Config.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h
+Transformer.o: Transformer.cpp ../../include/Transform/Transformer.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/Transform/Exception.h ../Transform/TransformUtil.h ../Transform/Data.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h ../Transform/Parser.h ../Transform/Node.h ../Transform/Analyzer.h ../../include/IceXML/Parser.h
+Data.o: Data.cpp ../Transform/Data.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h ../Transform/TransformUtil.h
+Error.o: Error.cpp ../Transform/Error.h ../../include/Slice/Parser.h ../../include/IceUtil/Shared.h ../../include/IceUtil/Config.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/InputUtil.h ../../include/Transform/Exception.h ../Transform/TransformUtil.h
+Exception.o: Exception.cpp ../../include/Transform/Exception.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h
+Node.o: Node.cpp ../Transform/Node.h ../Transform/Data.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h
+TransformUtil.o: TransformUtil.cpp ../Transform/TransformUtil.h ../../include/Slice/Parser.h ../../include/IceUtil/Shared.h ../../include/IceUtil/Config.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/InputUtil.h
+Parser.o: Parser.cpp ../Transform/Parser.h ../Transform/Node.h ../Transform/Data.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/IceUtil/Config.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/IceUtil/OutputUtil.h ../Transform/Error.h ../Transform/GrammarUtil.h
+TransformDB.o: TransformDB.cpp ../../include/Slice/Preprocessor.h ../../include/IceUtil/Config.h ../../include/Transform/Transformer.h ../../include/Ice/Ice.h ../../include/Ice/Initialize.h ../../include/Ice/CommunicatorF.h ../../include/Ice/LocalObjectF.h ../../include/Ice/Handle.h ../../include/IceUtil/Handle.h ../../include/IceUtil/Exception.h ../../include/Ice/Config.h ../../include/Ice/ProxyF.h ../../include/Ice/ProxyHandle.h ../../include/Ice/ObjectF.h ../../include/Ice/Exception.h ../../include/Ice/LocalObject.h ../../include/IceUtil/Shared.h ../../include/Ice/PropertiesF.h ../../include/Ice/InstanceF.h ../../include/Ice/BuiltinSequences.h ../../include/Ice/Proxy.h ../../include/IceUtil/Mutex.h ../../include/IceUtil/Lock.h ../../include/IceUtil/ThreadException.h ../../include/Ice/ProxyFactoryF.h ../../include/Ice/ConnectionF.h ../../include/Ice/EndpointF.h ../../include/Ice/ObjectAdapterF.h ../../include/Ice/ReferenceF.h ../../include/Ice/OutgoingAsyncF.h ../../include/Ice/Current.h ../../include/Ice/Identity.h ../../include/Ice/Facet.h ../../include/Ice/Object.h ../../include/Ice/IncomingAsyncF.h ../../include/Ice/Outgoing.h ../../include/IceUtil/Monitor.h ../../include/IceUtil/Cond.h ../../include/IceUtil/Time.h ../../include/Ice/BasicStream.h ../../include/Ice/ObjectFactoryF.h ../../include/Ice/Buffer.h ../../include/Ice/Incoming.h ../../include/Ice/ServantLocatorF.h ../../include/Ice/ServantManagerF.h ../../include/Ice/Direct.h ../../include/Ice/LocalException.h ../../include/Ice/Properties.h ../../include/Ice/Logger.h ../../include/Ice/LoggerUtil.h ../../include/Ice/LoggerF.h ../../include/Ice/Stats.h ../../include/Ice/Communicator.h ../../include/Ice/StatsF.h ../../include/Ice/RouterF.h ../../include/Ice/LocatorF.h ../../include/Ice/PluginF.h ../../include/Ice/ObjectFactory.h ../../include/Ice/ObjectAdapter.h ../../include/Ice/ServantLocator.h ../../include/Ice/IdentityUtil.h ../../include/Ice/OutgoingAsync.h ../../include/Ice/IncomingAsync.h ../../include/Ice/Application.h ../../include/Slice/Parser.h ../../include/IceUtil/InputUtil.h ../../include/Transform/Exception.h ../Transform/TransformUtil.h
diff --git a/cpp/src/Transform/Analyzer.cpp b/cpp/src/Transform/Analyzer.cpp
new file mode 100644
index 00000000000..b31a4bd75ed
--- /dev/null
+++ b/cpp/src/Transform/Analyzer.cpp
@@ -0,0 +1,1146 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Analyzer.h>
+#include <IceUtil/OutputUtil.h>
+#include <map>
+
+using namespace std;
+using namespace Slice;
+using namespace IceUtil;
+
+namespace Transform
+{
+
+string typeToString(const TypePtr&);
+
+//
+// TransformVisitor visits the old definitions and compares them with
+// the new definitions.
+//
+class TransformVisitor : public ParserVisitor
+{
+public:
+
+    TransformVisitor(XMLOutput&, const UnitPtr&, const TypePtr&, const TypePtr&, const TypePtr&, const TypePtr&, bool,
+                     vector<string>&, vector<string>&);
+
+    virtual bool visitClassDefStart(const ClassDefPtr&);
+    virtual bool visitStructStart(const StructPtr&);
+    virtual void visitSequence(const SequencePtr&);
+    virtual void visitDictionary(const DictionaryPtr&);
+    virtual void visitEnum(const EnumPtr&);
+
+private:
+
+    void compareMembers(const DataMemberList&, const DataMemberList&);
+    void compareTypes(const string&, const TypePtr&, const TypePtr&);
+    void typeChange(const string&, const TypePtr&, const TypePtr&);
+    bool checkClasses(const ClassDeclPtr&, const ClassDeclPtr&);
+
+    XMLOutput& _out;
+    UnitPtr _newUnit;
+    bool _ignoreTypeChanges;
+    vector<string>& _missingTypes;
+    vector<string>& _errors;
+};
+
+//
+// InitVisitor visits the new definitions to find any that are not present
+// in the old definitions, and generates init elements for them.
+//
+class InitVisitor : public ParserVisitor
+{
+public:
+
+    InitVisitor(XMLOutput&, const UnitPtr&);
+
+    virtual bool visitClassDefStart(const ClassDefPtr&);
+    virtual bool visitStructStart(const StructPtr&);
+    virtual void visitSequence(const SequencePtr&);
+    virtual void visitDictionary(const DictionaryPtr&);
+    virtual void visitEnum(const EnumPtr&);
+
+private:
+
+    XMLOutput& _out;
+    UnitPtr _oldUnit;
+};
+
+}
+
+string
+Transform::typeToString(const TypePtr& type)
+{
+    BuiltinPtr b = BuiltinPtr::dynamicCast(type);
+    if(b)
+    {
+        return b->kindAsString();
+    }
+    else
+    {
+        ContainedPtr cont = ContainedPtr::dynamicCast(type);
+        assert(cont);
+        return cont->scoped();
+    }
+}
+
+////////////////////////////////////
+// TransformVisitor
+////////////////////////////////////
+
+Transform::TransformVisitor::TransformVisitor(XMLOutput& out, const UnitPtr& newUnit,
+                                              const TypePtr& oldKey, const TypePtr& newKey,
+                                              const TypePtr& oldValue, const TypePtr& newValue,
+                                              bool ignoreTypeChanges, vector<string>& missingTypes,
+                                              vector<string>& errors) :
+    _out(out), _newUnit(newUnit), _ignoreTypeChanges(ignoreTypeChanges), _missingTypes(missingTypes), _errors(errors)
+{
+    out << se("database");
+
+    string oldKeyName = typeToString(oldKey);
+    string newKeyName = typeToString(newKey);
+    if(oldKeyName == newKeyName)
+    {
+        out << attr("key", oldKeyName);
+    }
+    else
+    {
+        out << attr("key", oldKeyName + "," + newKeyName);
+    }
+
+    string oldValueName = typeToString(oldValue);
+    string newValueName = typeToString(newValue);
+    if(oldValueName == newValueName)
+    {
+        out << attr("value", oldValueName);
+    }
+    else
+    {
+        out << attr("value", oldValueName + "," + newValueName);
+    }
+
+    out << se("record");
+    compareTypes("database key", oldKey, newKey);
+    compareTypes("database value", oldValue, newValue);
+    out << ee;
+
+    out << ee;
+}
+
+bool
+Transform::TransformVisitor::visitClassDefStart(const ClassDefPtr& v)
+{
+    if(v->isInterface() || v->isLocal())
+    {
+        return false;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        _missingTypes.push_back(scoped);
+        return false;
+    }
+
+    ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
+    if(!decl || decl->isInterface())
+    {
+        if(!_ignoreTypeChanges)
+        {
+            typeChange(scoped, v->declaration(), l.front());
+        }
+        return false;
+    }
+
+    ClassDefPtr newClass = decl->definition();
+    if(!newClass)
+    {
+        _missingTypes.push_back(scoped);
+        return false;
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- class " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+
+    DataMemberList oldMembers = v->allDataMembers();
+    DataMemberList newMembers = newClass->allDataMembers();
+    compareMembers(oldMembers, newMembers);
+
+    _out << ee;
+
+    return false;
+}
+
+bool
+Transform::TransformVisitor::visitStructStart(const StructPtr& v)
+{
+    if(v->isLocal())
+    {
+        return false;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        _missingTypes.push_back(scoped);
+        return false;
+    }
+
+    StructPtr newStruct = StructPtr::dynamicCast(l.front());
+    if(!newStruct)
+    {
+        if(!_ignoreTypeChanges)
+        {
+            typeChange(scoped, v, l.front());
+        }
+        return false;
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- struct " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+
+    DataMemberList oldMembers = v->dataMembers();
+    DataMemberList newMembers = newStruct->dataMembers();
+    compareMembers(oldMembers, newMembers);
+
+    _out << ee;
+
+    return false;
+}
+
+void
+Transform::TransformVisitor::visitSequence(const SequencePtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        _missingTypes.push_back(scoped);
+        return;
+    }
+
+    SequencePtr newSeq = SequencePtr::dynamicCast(l.front());
+    if(!newSeq)
+    {
+        if(!_ignoreTypeChanges)
+        {
+            typeChange(scoped, v, l.front());
+        }
+        return;
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- sequence " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+
+    compareTypes(scoped + " sequence type", v->type(), newSeq->type());
+
+    _out << ee;
+}
+
+void
+Transform::TransformVisitor::visitDictionary(const DictionaryPtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        _missingTypes.push_back(scoped);
+        return;
+    }
+
+    DictionaryPtr newDict = DictionaryPtr::dynamicCast(l.front());
+    if(!newDict)
+    {
+        if(!_ignoreTypeChanges)
+        {
+            typeChange(scoped, v, l.front());
+        }
+        return;
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- dictionary " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+
+    compareTypes(scoped + " key type", v->keyType(), newDict->keyType());
+    compareTypes(scoped + " value type", v->valueType(), newDict->valueType());
+
+    _out << ee;
+}
+
+void
+Transform::TransformVisitor::visitEnum(const EnumPtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _newUnit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        _missingTypes.push_back(scoped);
+        return;
+    }
+
+    EnumPtr newEnum = EnumPtr::dynamicCast(l.front());
+    if(!newEnum)
+    {
+        if(!_ignoreTypeChanges)
+        {
+            typeChange(scoped, v, l.front());
+        }
+        return;
+    }
+
+    map<string, int> m;
+    {
+        Slice::EnumeratorList enumerators = newEnum->getEnumerators();
+        int i = 0;
+        for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
+        {
+            m.insert(map<string, int>::value_type((*p)->name(), i));
+        }
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- enum " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+
+    Slice::EnumeratorList enumerators = v->getEnumerators();
+    int i = 0;
+    for(Slice::EnumeratorList::iterator p = enumerators.begin(); p != enumerators.end(); ++p, ++i)
+    {
+        map<string, int>::const_iterator q = m.find((*p)->name());
+        if(q == m.end())
+        {
+            _out.nl();
+            _out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has been removed -->";
+        }
+        else if(q->second != i)
+        {
+            _out.nl();
+            _out << "<!-- NOTICE: enumerator `" << (*p)->name() << "' has changed position -->";
+        }
+    }
+
+    _out << ee;
+}
+
+void
+Transform::TransformVisitor::compareMembers(const DataMemberList& oldMembers, const DataMemberList& newMembers)
+{
+    map<string, DataMemberPtr> oldMap, newMap;
+    map<string, DataMemberPtr>::iterator q;
+    DataMemberList::const_iterator p;
+
+    for(p = oldMembers.begin(); p != oldMembers.end(); ++p)
+    {
+        oldMap.insert(pair<const string, const DataMemberPtr>((*p)->name(), *p));
+    }
+
+    for(p = newMembers.begin(); p != newMembers.end(); ++p)
+    {
+        newMap.insert(pair<const string, const DataMemberPtr>((*p)->name(), *p));
+    }
+
+    for(p = oldMembers.begin(); p != oldMembers.end(); ++p)
+    {
+        string name = (*p)->name();
+        q = newMap.find(name);
+        if(q == newMap.end())
+        {
+            _out.nl();
+            _out << "<!-- NOTICE: " << name << " has been removed -->";
+        }
+        else
+        {
+            TypePtr oldType = (*p)->type();
+            TypePtr newType = q->second->type();
+            compareTypes(name, oldType, newType);
+
+            //
+            // Remove this entry from the map to indicate that we've
+            // already seen it.
+            //
+            newMap.erase(q);
+        }
+    }
+
+    //
+    // Iterate over the remaining entries in newMap. These represent
+    // members that were added in the new definition.
+    //
+    for(q = newMap.begin(); q != newMap.end(); ++q)
+    {
+        _out.nl();
+        _out << "<!-- NOTICE: " << q->first << " has been added -->";
+    }
+}
+
+void
+Transform::TransformVisitor::compareTypes(const string& desc, const TypePtr& oldType, const TypePtr& newType)
+{
+    assert(!oldType->isLocal());
+    if(newType->isLocal())
+    {
+        ostringstream ostr;
+        ostr << desc << " has changed to a local type";
+        _errors.push_back(ostr.str());
+        return;
+    }
+
+    BuiltinPtr b = BuiltinPtr::dynamicCast(oldType);
+    if(b)
+    {
+        BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
+        switch(b->kind())
+        {
+        case Builtin::KindByte:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindBool:
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindBool:
+        {
+            if(newb && (newb->kind() == Builtin::KindBool || newb->kind() == Builtin::KindString))
+            {
+                return;
+            }
+
+            break;
+        }
+        case Builtin::KindShort:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindBool:
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindInt:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindBool:
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindLong:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindBool:
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindFloat:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindBool:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindDouble:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindString:
+                {
+                    return;
+                }
+                case Builtin::KindByte:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindBool:
+                case Builtin::KindObject:
+                case Builtin::KindObjectProxy:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+            }
+
+            break;
+        }
+        case Builtin::KindString:
+        {
+            if(newb)
+            {
+                switch(newb->kind())
+                {
+                case Builtin::KindByte:
+                case Builtin::KindBool:
+                case Builtin::KindShort:
+                case Builtin::KindInt:
+                case Builtin::KindLong:
+                case Builtin::KindFloat:
+                case Builtin::KindDouble:
+                case Builtin::KindString:
+                case Builtin::KindObjectProxy:
+                {
+                    return;
+                }
+                case Builtin::KindObject:
+                case Builtin::KindLocalObject:
+                {
+                    break;
+                }
+                }
+
+                break;
+            }
+
+            if(EnumPtr::dynamicCast(newType))
+            {
+                return;
+            }
+
+            if(ProxyPtr::dynamicCast(newType))
+            {
+                return;
+            }
+
+            break;
+        }
+        case Builtin::KindObject:
+        {
+            //
+            // Allow change from Object to class. Validation has to
+            // be done during transformation, when the actual type of
+            // an instance can be compared for compatibility with the
+            // new type.
+            //
+            ClassDeclPtr cl = ClassDeclPtr::dynamicCast(newType);
+            if(cl || (newb && newb->kind() == Builtin::KindObject))
+            {
+                return;
+            }
+
+            break;
+        }
+        case Builtin::KindObjectProxy:
+        {
+            ProxyPtr p = ProxyPtr::dynamicCast(newType);
+            if(p || (newb && newb->kind() == Builtin::KindObjectProxy) || (newb && newb->kind() == Builtin::KindString))
+            {
+                return;
+            }
+
+            break;
+        }
+        case Builtin::KindLocalObject:
+        {
+            assert(false);
+            break;
+        }
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    ClassDeclPtr cl = ClassDeclPtr::dynamicCast(oldType);
+    if(cl)
+    {
+        //
+        // Allow target type of Object.
+        //
+        BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
+        if(newb && newb->kind() == Builtin::KindObject)
+        {
+            return;
+        }
+
+        ClassDeclPtr newcl = ClassDeclPtr::dynamicCast(newType);
+        if(newcl && checkClasses(cl, newcl))
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    StructPtr s = StructPtr::dynamicCast(oldType);
+    if(s)
+    {
+        StructPtr news = StructPtr::dynamicCast(newType);
+        if(news && s->scoped() == news->scoped())
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    ProxyPtr proxy = ProxyPtr::dynamicCast(oldType);
+    if(proxy)
+    {
+        //
+        // Allow target type of Object* and string.
+        //
+        BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
+        if(newb && (newb->kind() == Builtin::KindObjectProxy || newb->kind() == Builtin::KindString))
+        {
+            return;
+        }
+
+        ProxyPtr newProxy = ProxyPtr::dynamicCast(newType);
+        if(newProxy && checkClasses(proxy->_class(), newProxy->_class()))
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    DictionaryPtr dict = DictionaryPtr::dynamicCast(oldType);
+    if(dict)
+    {
+        DictionaryPtr newDict = DictionaryPtr::dynamicCast(newType);
+        if(newDict && dict->scoped() == newDict->scoped())
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    SequencePtr seq = SequencePtr::dynamicCast(oldType);
+    if(seq)
+    {
+        SequencePtr newSeq = SequencePtr::dynamicCast(newType);
+        if(newSeq && seq->scoped() == newSeq->scoped())
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    EnumPtr en = EnumPtr::dynamicCast(oldType);
+    if(en)
+    {
+        EnumPtr newen = EnumPtr::dynamicCast(newType);
+        BuiltinPtr newb = BuiltinPtr::dynamicCast(newType);
+        if((newen && en->scoped() == newen->scoped()) || (newb && newb->kind() == Builtin::KindString))
+        {
+            return;
+        }
+
+        typeChange(desc, oldType, newType);
+        return;
+    }
+
+    assert(false);
+}
+
+void
+Transform::TransformVisitor::typeChange(const string& desc, const TypePtr& t1, const TypePtr& t2)
+{
+    BuiltinPtr b1 = BuiltinPtr::dynamicCast(t1);
+    BuiltinPtr b2 = BuiltinPtr::dynamicCast(t2);
+    ContainedPtr c1 = ContainedPtr::dynamicCast(t1);
+    ContainedPtr c2 = ContainedPtr::dynamicCast(t2);
+
+    if(_ignoreTypeChanges)
+    {
+        _out.nl();
+        _out << "<!-- NOTICE: " << desc << " has changed from ";
+        if(b1)
+        {
+            _out << b1->kindAsString();
+        }
+        else
+        {
+            assert(c1);
+            _out << c1->kindOf() << ' ' << c1->scoped();
+        }
+        _out << " to ";
+        if(b2)
+        {
+            _out << b2->kindAsString();
+        }
+        else
+        {
+            assert(c2);
+            _out << c2->kindOf() << ' ' << c2->scoped();
+        }
+        _out << " -->";
+    }
+    else
+    {
+        ostringstream ostr;
+        ostr << "unsupported type change in " << desc << " from ";
+        if(b1)
+        {
+            ostr << b1->kindAsString();
+        }
+        else
+        {
+            assert(c1);
+            ostr << c1->kindOf() << ' ' << c1->scoped();
+        }
+        ostr << " to ";
+        if(b2)
+        {
+            ostr << b2->kindAsString();
+        }
+        else
+        {
+            assert(c2);
+            ostr << c2->kindOf() << ' ' << c2->scoped();
+        }
+        _errors.push_back(ostr.str());
+    }
+}
+
+bool
+Transform::TransformVisitor::checkClasses(const ClassDeclPtr& from, const ClassDeclPtr& to)
+{
+    string fromScoped = from->scoped();
+    string toScoped = to->scoped();
+
+    if(fromScoped == toScoped)
+    {
+        return true;
+    }
+
+    //
+    // The types don't match, so check them for compatibility. Specifically,
+    // look up the old type id in the new Slice and see if it has the target
+    // type as a base class.
+    //
+    TypeList l = to->unit()->lookupTypeNoBuiltin(from->scoped(), false);
+    if(!l.empty())
+    {
+        ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
+        if(decl)
+        {
+            ClassDefPtr def = decl->definition();
+            if(def)
+            {
+                ClassList bases = def->allBases();
+                for(ClassList::iterator p = bases.begin(); p != bases.end(); ++p)
+                {
+                    if((*p)->scoped() == toScoped)
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+////////////////////////////////////
+// InitVisitor
+////////////////////////////////////
+
+Transform::InitVisitor::InitVisitor(XMLOutput& out, const UnitPtr& oldUnit) :
+    _out(out), _oldUnit(oldUnit)
+{
+}
+
+bool
+Transform::InitVisitor::visitClassDefStart(const ClassDefPtr& v)
+{
+    if(v->isInterface() || v->isLocal())
+    {
+        return false;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
+    if(!l.empty())
+    {
+        ClassDeclPtr decl = ClassDeclPtr::dynamicCast(l.front());
+        if(!decl || decl->isInterface())
+        {
+            BuiltinPtr b1 = BuiltinPtr::dynamicCast(l.front());
+            ContainedPtr c1 = ContainedPtr::dynamicCast(l.front());
+
+            _out.nl();
+            _out << "<!-- NOTICE: " << scoped << " has changed from ";
+            if(b1)
+            {
+                _out << b1->kindAsString();
+            }
+            else
+            {
+                assert(c1);
+                _out << c1->kindOf();
+            }
+            _out << " to class";
+            _out << " -->";
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- class " << scoped << " -->";
+    _out << se("init") << attr("type", scoped);
+    _out << ee;
+
+    return false;
+}
+
+bool
+Transform::InitVisitor::visitStructStart(const StructPtr& v)
+{
+    if(v->isLocal())
+    {
+        return false;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
+    if(!l.empty())
+    {
+        StructPtr s = StructPtr::dynamicCast(l.front());
+        if(!s)
+        {
+            BuiltinPtr b1 = BuiltinPtr::dynamicCast(l.front());
+            ContainedPtr c1 = ContainedPtr::dynamicCast(l.front());
+
+            _out.nl();
+            _out << "<!-- NOTICE: " << scoped << " has changed from ";
+            if(b1)
+            {
+                _out << b1->kindAsString();
+            }
+            else
+            {
+                assert(c1);
+                _out << c1->kindOf();
+            }
+            _out << " to struct";
+            _out << " -->";
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- struct " << scoped << " -->";
+    _out << se("init") << attr("type", scoped);
+    _out << ee;
+
+    return false;
+}
+
+void
+Transform::InitVisitor::visitSequence(const SequencePtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
+    if(!l.empty())
+    {
+        SequencePtr s = SequencePtr::dynamicCast(l.front());
+        if(!s)
+        {
+            BuiltinPtr b1 = BuiltinPtr::dynamicCast(l.front());
+            ContainedPtr c1 = ContainedPtr::dynamicCast(l.front());
+
+            _out.nl();
+            _out << "<!-- NOTICE: " << scoped << " has changed from ";
+            if(b1)
+            {
+                _out << b1->kindAsString();
+            }
+            else
+            {
+                assert(c1);
+                _out << c1->kindOf();
+            }
+            _out << " to sequence";
+            _out << " -->";
+        }
+        else
+        {
+            return;
+        }
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- sequence " << scoped << " -->";
+    _out << se("transform") << attr("type", scoped);
+    _out << ee;
+}
+
+void
+Transform::InitVisitor::visitDictionary(const DictionaryPtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
+    if(!l.empty())
+    {
+        DictionaryPtr d = DictionaryPtr::dynamicCast(l.front());
+        if(!d)
+        {
+            BuiltinPtr b1 = BuiltinPtr::dynamicCast(l.front());
+            ContainedPtr c1 = ContainedPtr::dynamicCast(l.front());
+
+            _out.nl();
+            _out << "<!-- NOTICE: " << scoped << " has changed from ";
+            if(b1)
+            {
+                _out << b1->kindAsString();
+            }
+            else
+            {
+                assert(c1);
+                _out << c1->kindOf();
+            }
+            _out << " to dictionary";
+            _out << " -->";
+        }
+        else
+        {
+            return;
+        }
+    }
+
+    _out.nl();
+    _out.nl();
+    _out << "<!-- dictionary " << scoped << " -->";
+    _out << se("init") << attr("type", scoped);
+    _out << ee;
+}
+
+void
+Transform::InitVisitor::visitEnum(const EnumPtr& v)
+{
+    if(v->isLocal())
+    {
+        return;
+    }
+
+    string scoped = v->scoped();
+    TypeList l = _oldUnit->lookupTypeNoBuiltin(scoped, false);
+    if(!l.empty())
+    {
+        EnumPtr e = EnumPtr::dynamicCast(l.front());
+        if(!e)
+        {
+            BuiltinPtr b1 = BuiltinPtr::dynamicCast(l.front());
+            ContainedPtr c1 = ContainedPtr::dynamicCast(l.front());
+
+            _out.nl();
+            _out << "<!-- NOTICE: " << scoped << " has changed from ";
+            if(b1)
+            {
+                _out << b1->kindAsString();
+            }
+            else
+            {
+                assert(c1);
+                _out << c1->kindOf();
+            }
+            _out << " to enum";
+            _out << " -->";
+        }
+        else
+        {
+            return;
+        }
+    }
+
+    _out.nl();
+    _out << "<!-- enum " << scoped << " -->";
+    _out << se("init") << attr("type", scoped);
+    _out << ee;
+}
+
+Transform::Analyzer::Analyzer(const UnitPtr& oldUnit, const UnitPtr& newUnit, bool ignoreTypeChanges) :
+    _old(oldUnit), _new(newUnit), _ignoreTypeChanges(ignoreTypeChanges)
+{
+}
+
+void
+Transform::Analyzer::analyze(const TypePtr& oldKey, const TypePtr& newKey, const TypePtr& oldValue,
+                             const TypePtr& newValue, ostream& os, vector<string>& missingTypes,
+                             vector<string>& errors)
+{
+    XMLOutput out(os);
+
+    out << se("transformer");
+
+    TransformVisitor transformVisitor(out, _new, oldKey, newKey, oldValue, newValue, _ignoreTypeChanges, missingTypes,
+                                      errors);
+    _old->visit(&transformVisitor);
+
+    InitVisitor initVisitor(out, _old);
+    _new->visit(&initVisitor);
+
+    out << ee;
+    out << '\n';
+}
diff --git a/cpp/src/Transform/Analyzer.h b/cpp/src/Transform/Analyzer.h
new file mode 100644
index 00000000000..3e64ef28153
--- /dev/null
+++ b/cpp/src/Transform/Analyzer.h
@@ -0,0 +1,41 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_ANALYZER_H
+#define TRANSFORM_ANALYZER_H
+
+#include <Slice/Parser.h>
+#include <ostream>
+
+namespace Transform
+{
+
+class Analyzer
+{
+public:
+
+    Analyzer(const Slice::UnitPtr&, const Slice::UnitPtr&, bool);
+    void analyze(const Slice::TypePtr&, const Slice::TypePtr&, const Slice::TypePtr&, const Slice::TypePtr&,
+                 std::ostream&, std::vector<std::string>&, std::vector<std::string>&);
+
+private:
+
+    Slice::UnitPtr _old;
+    Slice::UnitPtr _new;
+    bool _ignoreTypeChanges;
+};
+
+}
+
+#endif
diff --git a/cpp/src/Transform/Data.cpp b/cpp/src/Transform/Data.cpp
new file mode 100644
index 00000000000..0b62d6f0b5f
--- /dev/null
+++ b/cpp/src/Transform/Data.cpp
@@ -0,0 +1,3458 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Data.h>
+#include <Transform/TransformUtil.h>
+#include <IceUtil/InputUtil.h>
+
+using namespace std;
+using namespace IceUtil;
+
+namespace Transform
+{
+
+//
+// ObjectWriter
+//
+class ObjectWriter : public Ice::Object
+{
+public:
+
+    ObjectWriter(const ObjectDataPtr&);
+
+    virtual void __write(IceInternal::BasicStream*, bool) const;
+    virtual void __read(IceInternal::BasicStream*, bool = true);
+
+private:
+
+    ObjectDataPtr _value;
+};
+
+//
+// ObjectReader
+//
+class ObjectReader : public Ice::Object
+{
+public:
+
+    ObjectReader(const DataFactoryPtr&, const Slice::TypePtr&);
+
+    virtual void __write(IceInternal::BasicStream*) const;
+    virtual void __read(IceInternal::BasicStream*, bool = true);
+
+    ObjectDataPtr getValue() const;
+
+private:
+
+    DataFactoryPtr _factory;
+    Slice::TypePtr _type;
+    ObjectDataPtr _value;
+};
+typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
+
+} // End of namespace Transform
+
+//
+// ObjectWriter
+//
+Transform::ObjectWriter::ObjectWriter(const ObjectDataPtr& value) :
+    _value(value)
+{
+}
+
+void
+Transform::ObjectWriter::__write(IceInternal::BasicStream* os, bool) const
+{
+    Slice::ClassDeclPtr decl = Slice::ClassDeclPtr::dynamicCast(_value->_type);
+    Slice::ClassDefPtr type;
+    if(decl)
+    {
+        type = decl->definition();
+    }
+    while(type)
+    {
+        os->writeTypeId(type->scoped());
+        os->startWriteSlice();
+        Slice::DataMemberList members = type->dataMembers();
+        for(Slice::DataMemberList::iterator p = members.begin(); p != members.end(); ++p)
+        {
+            DataMemberMap::const_iterator q = _value->_members.find((*p)->name());
+            assert(q != _value->_members.end());
+            q->second->marshal(*os);
+        }
+        os->endWriteSlice();
+
+        Slice::ClassList bases = type->bases();
+        if(!bases.empty() && !bases.front()->isInterface())
+        {
+            type = bases.front();
+        }
+        else
+        {
+            type = 0;
+        }
+    }
+
+    //
+    // Ice::Object slice
+    //
+    os->writeTypeId(Ice::Object::ice_staticId());
+    os->startWriteSlice();
+    _value->_facetMap->marshal(*os);
+    os->endWriteSlice();
+}
+
+void
+Transform::ObjectWriter::__read(IceInternal::BasicStream*, bool)
+{
+    assert(false);
+}
+
+//
+// ObjectReader
+//
+Transform::ObjectReader::ObjectReader(const DataFactoryPtr& factory, const Slice::TypePtr& type) :
+    _factory(factory), _type(type)
+{
+}
+
+void
+Transform::ObjectReader::__write(IceInternal::BasicStream*) const
+{
+    assert(false);
+}
+
+void
+Transform::ObjectReader::__read(IceInternal::BasicStream* is, bool rid)
+{
+    const_cast<ObjectDataPtr&>(_value) = new ObjectData(_factory, _type, true);
+    Slice::ClassDeclPtr decl = Slice::ClassDeclPtr::dynamicCast(_type);
+    Slice::ClassDefPtr type;
+    if(decl)
+    {
+        type = decl->definition();
+    }
+    while(type)
+    {
+        if(rid)
+        {
+            string id;
+            is->readTypeId(id);
+            assert(id == type->scoped());
+        }
+
+        is->startReadSlice();
+        Slice::DataMemberList members = type->dataMembers();
+        for(Slice::DataMemberList::iterator p = members.begin(); p != members.end(); ++p)
+        {
+            DataMemberMap::iterator q = _value->_members.find((*p)->name());
+            assert(q != _value->_members.end());
+            q->second->unmarshal(*is);
+        }
+        is->endReadSlice();
+
+        Slice::ClassList bases = type->bases();
+        if(!bases.empty() && !bases.front()->isInterface())
+        {
+            type = bases.front();
+        }
+        else
+        {
+            type = 0;
+        }
+
+        rid = true;
+    }
+
+    //
+    // Ice::Object slice
+    //
+    if(rid)
+    {
+        string id;
+        is->readTypeId(id);
+        assert(id == Ice::Object::ice_staticId());
+    }
+    is->startReadSlice();
+    _value->_facetMap->unmarshal(*is);
+    is->endReadSlice();
+}
+
+Transform::ObjectDataPtr
+Transform::ObjectReader::getValue() const
+{
+    return _value;
+}
+
+//
+// DataInterceptor
+//
+Transform::DataInterceptor::~DataInterceptor()
+{
+}
+
+//
+// DataInitializer
+//
+Transform::DataInitializer::~DataInitializer()
+{
+}
+
+//
+// DataFactory
+//
+Transform::DataFactory::DataFactory(const Ice::CommunicatorPtr& communicator, const Slice::UnitPtr& unit,
+                                    const ErrorReporterPtr& errorReporter) :
+    _communicator(communicator), _unit(unit), _errorReporter(errorReporter), _initializersEnabled(true)
+{
+}
+
+Transform::DataPtr
+Transform::DataFactory::create(const Slice::TypePtr& type, bool readOnly)
+{
+    DataPtr data = createImpl(type, readOnly);
+    if(_initializersEnabled && !readOnly)
+    {
+        string name = typeName(type);
+        InitMap::iterator p = _initializers.find(name);
+        if(p != _initializers.end())
+        {
+            p->second->initialize(this, data, _communicator);
+        }
+    }
+    return data;
+}
+
+Transform::DataPtr
+Transform::DataFactory::createBoolean(bool b, bool readOnly)
+{
+    return new BooleanData(getBuiltin(Slice::Builtin::KindBool), _errorReporter, readOnly, b);
+}
+
+Transform::DataPtr
+Transform::DataFactory::createInteger(Ice::Long i, bool readOnly)
+{
+    return new IntegerData(getBuiltin(Slice::Builtin::KindLong), _errorReporter, readOnly, i);
+}
+
+Transform::DataPtr
+Transform::DataFactory::createDouble(double d, bool readOnly)
+{
+    return new DoubleData(getBuiltin(Slice::Builtin::KindDouble), _errorReporter, readOnly, d);
+}
+
+Transform::DataPtr
+Transform::DataFactory::createString(const string& s, bool readOnly)
+{
+    return new StringData(this, getBuiltin(Slice::Builtin::KindString), _errorReporter, readOnly, s);
+}
+
+Transform::DataPtr
+Transform::DataFactory::createNil(bool readOnly)
+{
+    return new ObjectRef(this, getBuiltin(Slice::Builtin::KindObject), readOnly);
+}
+
+Slice::BuiltinPtr
+Transform::DataFactory::getBuiltin(Slice::Builtin::Kind kind) const
+{
+    return _unit->builtin(kind);
+}
+
+void
+Transform::DataFactory::addInitializer(const string& type, const DataInitializerPtr& init)
+{
+    _initializers.insert(InitMap::value_type(type, init));
+}
+
+void
+Transform::DataFactory::enableInitializers()
+{
+    _initializersEnabled = true;
+}
+
+void
+Transform::DataFactory::disableInitializers()
+{
+    _initializersEnabled = false;
+}
+
+Transform::ErrorReporterPtr
+Transform::DataFactory::getErrorReporter() const
+{
+    return _errorReporter;
+}
+
+Transform::DataPtr
+Transform::DataFactory::createImpl(const Slice::TypePtr& type, bool readOnly)
+{
+    Slice::BuiltinPtr builtin = Slice::BuiltinPtr::dynamicCast(type);
+    if(builtin)
+    {
+        switch(builtin->kind())
+        {
+        case Slice::Builtin::KindBool:
+            return new BooleanData(builtin, _errorReporter, readOnly);
+
+        case Slice::Builtin::KindByte:
+        case Slice::Builtin::KindShort:
+        case Slice::Builtin::KindInt:
+        case Slice::Builtin::KindLong:
+            return new IntegerData(builtin, _errorReporter, readOnly);
+
+        case Slice::Builtin::KindFloat:
+        case Slice::Builtin::KindDouble:
+            return new DoubleData(builtin, _errorReporter, readOnly);
+
+        case Slice::Builtin::KindString:
+            return new StringData(this, builtin, _errorReporter, readOnly);
+
+        case Slice::Builtin::KindObject:
+            return new ObjectRef(this, builtin, readOnly);
+
+        case Slice::Builtin::KindObjectProxy:
+            return new ProxyData(builtin, _communicator, _errorReporter, readOnly);
+
+        case Slice::Builtin::KindLocalObject:
+            assert(false);
+            return 0;
+        }
+    }
+
+    Slice::SequencePtr seq = Slice::SequencePtr::dynamicCast(type);
+    if(seq)
+    {
+        return new SequenceData(this, seq, _errorReporter, readOnly);
+    }
+
+    Slice::ProxyPtr proxy = Slice::ProxyPtr::dynamicCast(type);
+    if(proxy)
+    {
+        return new ProxyData(proxy, _communicator, _errorReporter, readOnly);
+    }
+
+    Slice::StructPtr st = Slice::StructPtr::dynamicCast(type);
+    if(st)
+    {
+        return new StructData(this, st, _errorReporter, readOnly);
+    }
+
+    Slice::EnumPtr en = Slice::EnumPtr::dynamicCast(type);
+    if(en)
+    {
+        return new EnumData(en, _errorReporter, readOnly);
+    }
+
+    Slice::DictionaryPtr dict = Slice::DictionaryPtr::dynamicCast(type);
+    if(dict)
+    {
+        return new DictionaryData(this, dict, _errorReporter, readOnly);
+    }
+
+    Slice::ClassDeclPtr cl = Slice::ClassDeclPtr::dynamicCast(type);
+    if(cl)
+    {
+        Slice::ClassDefPtr def = cl->definition();
+        if(!def)
+        {
+            _errorReporter->error("class " + cl->scoped() + " declared but not defined");
+        }
+        return new ObjectRef(this, cl, readOnly);
+    }
+
+    return 0;
+}
+
+//
+// Data
+//
+Transform::Data::Data(const ErrorReporterPtr& errorReporter, bool readOnly) :
+    _errorReporter(errorReporter), _readOnly(readOnly)
+{
+}
+
+Transform::Data::~Data()
+{
+}
+
+bool
+Transform::Data::readOnly() const
+{
+    return _readOnly;
+}
+
+void
+Transform::Data::print(ostream& os) const
+{
+    ObjectDataHistory history;
+    IceUtil::Output out(os);
+    printI(out, history);
+}
+
+bool
+Transform::Data::isCompatible(const Slice::TypePtr& dest, const Slice::TypePtr& src)
+{
+    Slice::BuiltinPtr b1 = Slice::BuiltinPtr::dynamicCast(dest);
+    if(b1)
+    {
+        Slice::BuiltinPtr b2 = Slice::BuiltinPtr::dynamicCast(src);
+        switch(b1->kind())
+        {
+        case Slice::Builtin::KindByte:
+        case Slice::Builtin::KindShort:
+        case Slice::Builtin::KindInt:
+        case Slice::Builtin::KindLong:
+        {
+            if(b2)
+            {
+                switch(b2->kind())
+                {
+                case Slice::Builtin::KindByte:
+                case Slice::Builtin::KindShort:
+                case Slice::Builtin::KindInt:
+                case Slice::Builtin::KindLong:
+                case Slice::Builtin::KindString:
+                {
+                    return true;
+                }
+                case Slice::Builtin::KindBool:
+                case Slice::Builtin::KindFloat:
+                case Slice::Builtin::KindDouble:
+                case Slice::Builtin::KindObject:
+                case Slice::Builtin::KindObjectProxy:
+                case Slice::Builtin::KindLocalObject:
+                {
+                    return false;
+                }
+                }
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindBool:
+        {
+            if(b2 && (b2->kind() == Slice::Builtin::KindBool || b2->kind() == Slice::Builtin::KindString))
+            {
+                return true;
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindFloat:
+        case Slice::Builtin::KindDouble:
+        {
+            if(b2)
+            {
+                switch(b2->kind())
+                {
+                case Slice::Builtin::KindFloat:
+                case Slice::Builtin::KindDouble:
+                case Slice::Builtin::KindString:
+                {
+                    return true;
+                }
+                case Slice::Builtin::KindByte:
+                case Slice::Builtin::KindShort:
+                case Slice::Builtin::KindInt:
+                case Slice::Builtin::KindLong:
+                case Slice::Builtin::KindBool:
+                case Slice::Builtin::KindObject:
+                case Slice::Builtin::KindObjectProxy:
+                case Slice::Builtin::KindLocalObject:
+                {
+                    return false;
+                }
+                }
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindString:
+        {
+            if(b2)
+            {
+                switch(b2->kind())
+                {
+                case Slice::Builtin::KindByte:
+                case Slice::Builtin::KindBool:
+                case Slice::Builtin::KindShort:
+                case Slice::Builtin::KindInt:
+                case Slice::Builtin::KindLong:
+                case Slice::Builtin::KindFloat:
+                case Slice::Builtin::KindDouble:
+                case Slice::Builtin::KindString:
+                case Slice::Builtin::KindObjectProxy:
+                {
+                    return true;
+                }
+                case Slice::Builtin::KindObject:
+                case Slice::Builtin::KindLocalObject:
+                {
+                    return false;
+                }
+                }
+
+                return false;
+            }
+            else if(Slice::EnumPtr::dynamicCast(src))
+            {
+                return true;
+            }
+            else if(Slice::ProxyPtr::dynamicCast(src))
+            {
+                return true;
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindObject:
+        {
+            //
+            // Allow transformation from Object to class. Validation has to
+            // be done during transformation, when the actual type of
+            // an instance can be compared for compatibility with the
+            // new type.
+            //
+            Slice::ClassDeclPtr cl = Slice::ClassDeclPtr::dynamicCast(src);
+            if(cl || (b2 && b2->kind() == Slice::Builtin::KindObject))
+            {
+                return true;
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindObjectProxy:
+        {
+            Slice::ProxyPtr p = Slice::ProxyPtr::dynamicCast(src);
+            if(p || (b2 && b2->kind() == Slice::Builtin::KindObjectProxy) ||
+               (b2 && b2->kind() == Slice::Builtin::KindString))
+            {
+                return true;
+            }
+
+            return false;
+        }
+        case Slice::Builtin::KindLocalObject:
+        {
+            assert(false);
+            return false;
+        }
+        }
+
+        assert(false);
+    }
+
+    Slice::ClassDeclPtr cl1 = Slice::ClassDeclPtr::dynamicCast(dest);
+    if(cl1)
+    {
+        Slice::ClassDeclPtr cl2 = Slice::ClassDeclPtr::dynamicCast(src);
+        if(cl2 && checkClasses(cl1, cl2))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    Slice::StructPtr s1 = Slice::StructPtr::dynamicCast(dest);
+    if(s1)
+    {
+        Slice::StructPtr s2 = Slice::StructPtr::dynamicCast(src);
+        if(s2 && s1->scoped() == s2->scoped())
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    Slice::ProxyPtr p1 = Slice::ProxyPtr::dynamicCast(dest);
+    if(p1)
+    {
+        Slice::BuiltinPtr b2 = Slice::BuiltinPtr::dynamicCast(src);
+        if(b2 && (b2->kind() == Slice::Builtin::KindObjectProxy || b2->kind() == Slice::Builtin::KindString))
+        {
+            return true;
+        }
+
+        Slice::ProxyPtr p2 = Slice::ProxyPtr::dynamicCast(src);
+        if(p2 && checkClasses(p1->_class(), p2->_class()))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    Slice::DictionaryPtr d1 = Slice::DictionaryPtr::dynamicCast(dest);
+    if(d1)
+    {
+        Slice::DictionaryPtr d2 = Slice::DictionaryPtr::dynamicCast(src);
+        if(d2)
+        {
+            return isCompatible(d1->keyType(), d2->keyType()) && isCompatible(d1->valueType(), d2->valueType());
+        }
+
+        return false;
+    }
+
+    Slice::SequencePtr seq1 = Slice::SequencePtr::dynamicCast(dest);
+    if(seq1)
+    {
+        Slice::SequencePtr seq2 = Slice::SequencePtr::dynamicCast(src);
+        if(seq2)
+        {
+            return isCompatible(seq1->type(), seq2->type());
+        }
+
+        return false;
+    }
+
+    Slice::EnumPtr e1 = Slice::EnumPtr::dynamicCast(dest);
+    if(e1)
+    {
+        Slice::EnumPtr e2 = Slice::EnumPtr::dynamicCast(src);
+        Slice::BuiltinPtr b2 = Slice::BuiltinPtr::dynamicCast(src);
+        if((e2 && e1->scoped() == e2->scoped()) || (b2 && b2->kind() == Slice::Builtin::KindString))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    assert(false);
+    return false;
+}
+
+bool
+Transform::Data::checkClasses(const Slice::ClassDeclPtr& dest, const Slice::ClassDeclPtr& src)
+{
+    string s1 = dest->scoped();
+    string s2 = src->scoped();
+    if(s1 == s2)
+    {
+        return true;
+    }
+    else
+    {
+        Slice::ClassDefPtr def = src->definition();
+        if(!def)
+        {
+            _errorReporter->error("class " + s2 + " declared but not defined");
+        }
+        Slice::ClassList bases = def->allBases();
+        for(Slice::ClassList::iterator p = bases.begin(); p != bases.end(); ++p)
+        {
+            if((*p)->scoped() == s1)
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+//
+// PrimitiveData
+//
+Transform::PrimitiveData::PrimitiveData(const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly)
+{
+}
+
+Transform::DataPtr
+Transform::PrimitiveData::getMember(const string&) const
+{
+    return 0;
+}
+
+Transform::DataPtr
+Transform::PrimitiveData::getElement(const DataPtr&) const
+{
+    _errorReporter->error("element requested of primitive value");
+    return 0;
+}
+
+void
+Transform::PrimitiveData::registerObjects(ObjectDataMap&) const
+{
+}
+
+void
+Transform::PrimitiveData::destroy()
+{
+}
+
+//
+// BooleanData
+//
+Transform::BooleanData::BooleanData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                    bool readOnly) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(false)
+{
+}
+
+Transform::BooleanData::BooleanData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                    bool readOnly, bool value) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(value)
+{
+}
+
+bool
+Transform::BooleanData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::BooleanData::operator!=(const Data& rhs) const
+{
+    const BooleanData* b = dynamic_cast<const BooleanData*>(&rhs);
+    if(!b)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != b->_value;
+}
+
+bool
+Transform::BooleanData::operator<(const Data& rhs) const
+{
+    const BooleanData* b = dynamic_cast<const BooleanData*>(&rhs);
+    if(!b)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < b->_value;
+}
+
+void
+Transform::BooleanData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        BooleanDataPtr b = BooleanDataPtr::dynamicCast(data);
+        if(b)
+        {
+            _value = b->booleanValue();
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, data->getType(), false);
+        }
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::BooleanData::set(const DataPtr& value, DataInterceptor&, bool convert)
+{
+    StringDataPtr s = StringDataPtr::dynamicCast(value);
+    if(convert && s)
+    {
+        string v = s->stringValue();
+        if(v == "true")
+        {
+            _value = true;
+        }
+        else if(v == "false")
+        {
+            _value = false;
+        }
+        else
+        {
+            _errorReporter->conversionError(v, _type);
+        }
+    }
+    else
+    {
+        _value = value->booleanValue(convert);
+    }
+}
+
+Transform::DataPtr
+Transform::BooleanData::clone() const
+{
+    return new BooleanData(_type, _errorReporter, _readOnly, _value);
+}
+
+Slice::TypePtr
+Transform::BooleanData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::BooleanData::marshal(IceInternal::BasicStream& os) const
+{
+    os.write(_value);
+}
+
+void
+Transform::BooleanData::unmarshal(IceInternal::BasicStream& is)
+{
+    is.read(_value);
+}
+
+bool
+Transform::BooleanData::booleanValue(bool) const
+{
+    return _value;
+}
+
+Ice::Long
+Transform::BooleanData::integerValue(bool) const
+{
+    _errorReporter->error("boolean cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::BooleanData::doubleValue(bool) const
+{
+    _errorReporter->error("boolean cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::BooleanData::stringValue(bool convert) const
+{
+    if(convert)
+    {
+        return toString();
+    }
+    else
+    {
+        return string();
+    }
+}
+
+string
+Transform::BooleanData::toString() const
+{
+    return (_value ? "true" : "false");
+}
+
+void
+Transform::BooleanData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << "bool(" << toString() << ")";
+}
+
+//
+// IntegerData
+//
+Transform::IntegerData::IntegerData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                    bool readOnly) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(0)
+{
+}
+
+Transform::IntegerData::IntegerData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                    bool readOnly, Ice::Long value) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(value)
+{
+}
+
+bool
+Transform::IntegerData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::IntegerData::operator!=(const Data& rhs) const
+{
+    const IntegerData* i = dynamic_cast<const IntegerData*>(&rhs);
+    if(!i)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != i->_value;
+}
+
+bool
+Transform::IntegerData::operator<(const Data& rhs) const
+{
+    const IntegerData* i = dynamic_cast<const IntegerData*>(&rhs);
+    if(!i)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < i->_value;
+}
+
+void
+Transform::IntegerData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        Ice::Long value;
+        IntegerDataPtr i = IntegerDataPtr::dynamicCast(data);
+        StringDataPtr s = StringDataPtr::dynamicCast(data);
+        if(i)
+        {
+            value = i->_value;
+        }
+        else if(s)
+        {
+            string str = s->stringValue();
+            string::size_type pos;
+            if(!IceUtil::stringToInt64(str, value, pos))
+            {
+                _errorReporter->conversionError(str, _type);
+            }
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, data->getType(), false);
+        }
+
+        if(rangeCheck(value))
+        {
+            _value = value;
+        }
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::IntegerData::set(const DataPtr& value, DataInterceptor&, bool convert)
+{
+    _value = value->integerValue(convert);
+}
+
+Transform::DataPtr
+Transform::IntegerData::clone() const
+{
+    return new IntegerData(_type, _errorReporter, _readOnly, _value);
+}
+
+Slice::TypePtr
+Transform::IntegerData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::IntegerData::marshal(IceInternal::BasicStream& os) const
+{
+    rangeCheck(_value);
+
+    switch(_type->kind())
+    {
+    case Slice::Builtin::KindByte:
+    {
+        os.write(static_cast<Ice::Byte>(_value));
+        break;
+    }
+    case Slice::Builtin::KindShort:
+    {
+        os.write(static_cast<Ice::Short>(_value));
+        break;
+    }
+    case Slice::Builtin::KindInt:
+    {
+        os.write(static_cast<Ice::Int>(_value));
+        break;
+    }
+    case Slice::Builtin::KindLong:
+    {
+        os.write(_value);
+        break;
+    }
+
+    case Slice::Builtin::KindBool:
+    case Slice::Builtin::KindFloat:
+    case Slice::Builtin::KindDouble:
+    case Slice::Builtin::KindString:
+    case Slice::Builtin::KindObject:
+    case Slice::Builtin::KindObjectProxy:
+    case Slice::Builtin::KindLocalObject:
+        assert(false);
+    }
+}
+
+void
+Transform::IntegerData::unmarshal(IceInternal::BasicStream& is)
+{
+    switch(_type->kind())
+    {
+    case Slice::Builtin::KindByte:
+    {
+        Ice::Byte val;
+        is.read(val);
+        _value = val & 0xff;
+        break;
+    }
+    case Slice::Builtin::KindShort:
+    {
+        Ice::Short val;
+        is.read(val);
+        _value = val;
+        break;
+    }
+    case Slice::Builtin::KindInt:
+    {
+        Ice::Int val;
+        is.read(val);
+        _value = val;
+        break;
+    }
+    case Slice::Builtin::KindLong:
+    {
+        is.read(_value);
+        break;
+    }
+
+    case Slice::Builtin::KindBool:
+    case Slice::Builtin::KindFloat:
+    case Slice::Builtin::KindDouble:
+    case Slice::Builtin::KindString:
+    case Slice::Builtin::KindObject:
+    case Slice::Builtin::KindObjectProxy:
+    case Slice::Builtin::KindLocalObject:
+        assert(false);
+    }
+}
+
+bool
+Transform::IntegerData::booleanValue(bool) const
+{
+    _errorReporter->error("integer cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::IntegerData::integerValue(bool) const
+{
+    return _value;
+}
+
+double
+Transform::IntegerData::doubleValue(bool convert) const
+{
+    if(convert)
+    {
+        return _value;
+    }
+    else
+    {
+        _errorReporter->error("integer cannot be converted to double");
+        return 0;
+    }
+}
+
+string
+Transform::IntegerData::stringValue(bool convert) const
+{
+    if(convert)
+    {
+        return toString();
+    }
+    else
+    {
+        _errorReporter->error("integer cannot be converted to string");
+        return string();
+    }
+}
+
+string
+Transform::IntegerData::toString() const
+{
+    return toString(_value);
+}
+
+bool
+Transform::IntegerData::rangeCheck(Ice::Long value) const
+{
+    switch(_type->kind())
+    {
+    case Slice::Builtin::KindByte:
+    {
+        if(value < 0 || value > 255)
+        {
+            _errorReporter->rangeError(toString(value), _type);
+        }
+        else
+        {
+            return true;
+        }
+        break;
+    }
+
+    case Slice::Builtin::KindShort:
+    {
+        if(value < SHRT_MIN || value > SHRT_MAX)
+        {
+            _errorReporter->rangeError(toString(value), _type);
+        }
+        else
+        {
+            return true;
+        }
+        break;
+    }
+
+    case Slice::Builtin::KindInt:
+    {
+        if(value < INT_MIN || value > INT_MAX)
+        {
+            _errorReporter->rangeError(toString(value), _type);
+        }
+        else
+        {
+            return true;
+        }
+        break;
+    }
+
+    case Slice::Builtin::KindLong:
+    {
+        return true;
+    }
+
+    case Slice::Builtin::KindBool:
+    case Slice::Builtin::KindFloat:
+    case Slice::Builtin::KindDouble:
+    case Slice::Builtin::KindString:
+    case Slice::Builtin::KindObject:
+    case Slice::Builtin::KindObjectProxy:
+    case Slice::Builtin::KindLocalObject:
+        assert(false);
+    }
+
+    return false;
+}
+
+string
+Transform::IntegerData::toString(Ice::Long value)
+{
+    char buf[64];
+#ifdef WIN32
+    sprintf(buf, "%I64d", value);
+#else
+    sprintf(buf, "%lld", value);
+#endif
+    return string(buf);
+}
+
+void
+Transform::IntegerData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << "integer(" << toString() << ")";
+}
+
+//
+// DoubleData
+//
+Transform::DoubleData::DoubleData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                  bool readOnly) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(0)
+{
+}
+
+Transform::DoubleData::DoubleData(const Slice::BuiltinPtr& type, const ErrorReporterPtr& errorReporter,
+                                  bool readOnly, double value) :
+    PrimitiveData(errorReporter, readOnly), _type(type), _value(value)
+{
+}
+
+bool
+Transform::DoubleData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::DoubleData::operator!=(const Data& rhs) const
+{
+    const DoubleData* d = dynamic_cast<const DoubleData*>(&rhs);
+    if(!d)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != d->_value;
+}
+
+bool
+Transform::DoubleData::operator<(const Data& rhs) const
+{
+    const DoubleData* d = dynamic_cast<const DoubleData*>(&rhs);
+    if(!d)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < d->_value;
+}
+
+void
+Transform::DoubleData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        DoubleDataPtr d = DoubleDataPtr::dynamicCast(data);
+        StringDataPtr s = StringDataPtr::dynamicCast(data);
+        if(d)
+        {
+            _value = d->doubleValue();
+        }
+        else if(s)
+        {
+            string str = s->stringValue();
+            const char* start = str.c_str();
+            char* end;
+            double v = strtod(start, &end);
+            if(errno == ERANGE)
+            {
+                _errorReporter->rangeError(str, _type);
+            }
+            else
+            {
+                while(*end)
+                {
+                    if(!isspace(*end))
+                    {
+                        _errorReporter->conversionError(str, _type);
+                        break;
+                    }
+                    end++;
+                }
+                if(!*end)
+                {
+                    _value = v;
+                }
+            }
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, data->getType(), false);
+        }
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::DoubleData::set(const DataPtr& value, DataInterceptor&, bool convert)
+{
+    _value = value->doubleValue(convert);
+}
+
+Transform::DataPtr
+Transform::DoubleData::clone() const
+{
+    return new DoubleData(_type, _errorReporter, _readOnly, _value);
+}
+
+Slice::TypePtr
+Transform::DoubleData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::DoubleData::marshal(IceInternal::BasicStream& os) const
+{
+    switch(_type->kind())
+    {
+    case Slice::Builtin::KindFloat:
+    {
+        os.write(static_cast<Ice::Float>(_value));
+        break;
+    }
+    case Slice::Builtin::KindDouble:
+    {
+        os.write(_value);
+        break;
+    }
+
+    case Slice::Builtin::KindByte:
+    case Slice::Builtin::KindShort:
+    case Slice::Builtin::KindInt:
+    case Slice::Builtin::KindLong:
+    case Slice::Builtin::KindBool:
+    case Slice::Builtin::KindString:
+    case Slice::Builtin::KindObject:
+    case Slice::Builtin::KindObjectProxy:
+    case Slice::Builtin::KindLocalObject:
+        assert(false);
+    }
+}
+
+void
+Transform::DoubleData::unmarshal(IceInternal::BasicStream& is)
+{
+    switch(_type->kind())
+    {
+    case Slice::Builtin::KindFloat:
+    {
+        Ice::Float val;
+        is.read(val);
+        _value = val;
+        break;
+    }
+    case Slice::Builtin::KindDouble:
+    {
+        is.read(_value);
+        break;
+    }
+
+    case Slice::Builtin::KindByte:
+    case Slice::Builtin::KindShort:
+    case Slice::Builtin::KindInt:
+    case Slice::Builtin::KindLong:
+    case Slice::Builtin::KindBool:
+    case Slice::Builtin::KindString:
+    case Slice::Builtin::KindObject:
+    case Slice::Builtin::KindObjectProxy:
+    case Slice::Builtin::KindLocalObject:
+        assert(false);
+    }
+}
+
+bool
+Transform::DoubleData::booleanValue(bool) const
+{
+    _errorReporter->error("double cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::DoubleData::integerValue(bool convert) const
+{
+    if(convert)
+    {
+        return static_cast<Ice::Long>(_value);
+    }
+    else
+    {
+        _errorReporter->error("double cannot be converted to integer");
+        return 0;
+    }
+}
+
+double
+Transform::DoubleData::doubleValue(bool) const
+{
+    return _value;
+}
+
+string
+Transform::DoubleData::stringValue(bool convert) const
+{
+    if(convert)
+    {
+        return toString();
+    }
+    else
+    {
+        _errorReporter->error("double cannot be converted to string");
+        return string();
+    }
+}
+
+string
+Transform::DoubleData::toString() const
+{
+    char buff[64];
+    sprintf(buff, "%g", _value);
+    return string(buff);
+}
+
+void
+Transform::DoubleData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << "double(" << toString() << ")";
+}
+
+//
+// StringData
+//
+Transform::StringData::StringData(const DataFactoryPtr& factory, const Slice::BuiltinPtr& type,
+                                  const ErrorReporterPtr& errorReporter, bool readOnly) :
+    PrimitiveData(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    setValue("");
+}
+
+Transform::StringData::StringData(const DataFactoryPtr& factory, const Slice::BuiltinPtr& type,
+                                  const ErrorReporterPtr& errorReporter, bool readOnly, const string& value) :
+    PrimitiveData(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    setValue(value);
+}
+
+Transform::DataPtr
+Transform::StringData::getMember(const string& member) const
+{
+    if(member == "length")
+    {
+        return _length;
+    }
+
+    return 0;
+}
+
+bool
+Transform::StringData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::StringData::operator!=(const Data& rhs) const
+{
+    const StringData* s = dynamic_cast<const StringData*>(&rhs);
+    if(!s)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != s->_value;
+}
+
+bool
+Transform::StringData::operator<(const Data& rhs) const
+{
+    const StringData* s = dynamic_cast<const StringData*>(&rhs);
+    if(!s)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < s->_value;
+}
+
+void
+Transform::StringData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        StringDataPtr s = StringDataPtr::dynamicCast(data);
+        BooleanDataPtr b = BooleanDataPtr::dynamicCast(data);
+        IntegerDataPtr i = IntegerDataPtr::dynamicCast(data);
+        DoubleDataPtr d = DoubleDataPtr::dynamicCast(data);
+        EnumDataPtr e = EnumDataPtr::dynamicCast(data);
+        ProxyDataPtr p = ProxyDataPtr::dynamicCast(data);
+        if(s || b || i || d || e || p)
+        {
+            setValue(data->toString());
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, data->getType(), false);
+        }
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::StringData::set(const DataPtr& value, DataInterceptor&, bool convert)
+{
+    setValue(value->stringValue(convert));
+}
+
+Transform::DataPtr
+Transform::StringData::clone() const
+{
+    return new StringData(_factory, _type, _errorReporter, _readOnly, _value);
+}
+
+Slice::TypePtr
+Transform::StringData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::StringData::marshal(IceInternal::BasicStream& os) const
+{
+    os.write(_value);
+}
+
+void
+Transform::StringData::unmarshal(IceInternal::BasicStream& is)
+{
+    string s;
+    is.read(s);
+    setValue(s);
+}
+
+bool
+Transform::StringData::booleanValue(bool) const
+{
+    _errorReporter->error("string cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::StringData::integerValue(bool) const
+{
+    _errorReporter->error("string cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::StringData::doubleValue(bool) const
+{
+    _errorReporter->error("string cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::StringData::stringValue(bool) const
+{
+    return _value;
+}
+
+string
+Transform::StringData::toString() const
+{
+    return _value;
+}
+
+void
+Transform::StringData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << "'" << toString() << "'";
+}
+
+void
+Transform::StringData::setValue(const string& value)
+{
+    _value = value;
+    _length = _factory->createInteger(static_cast<Ice::Long>(_value.size()), true);
+}
+
+//
+// ProxyData
+//
+Transform::ProxyData::ProxyData(const Slice::TypePtr& type, const Ice::CommunicatorPtr& communicator,
+                                const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly), _type(type), _communicator(communicator)
+{
+}
+
+Transform::ProxyData::ProxyData(const Slice::TypePtr& type, const Ice::CommunicatorPtr& communicator,
+                                const ErrorReporterPtr& errorReporter, bool readOnly, const Ice::ObjectPrx& value) :
+    Data(errorReporter, readOnly), _type(type), _communicator(communicator), _value(value)
+{
+}
+
+Transform::DataPtr
+Transform::ProxyData::getMember(const string& member) const
+{
+    // TODO: Support members (id, facet, etc.)?
+#if 0
+    if(member == "length")
+    {
+        return new IntegerData(_value.length());
+    }
+#endif
+
+    return 0;
+}
+
+Transform::DataPtr
+Transform::ProxyData::getElement(const DataPtr&) const
+{
+    _errorReporter->error("element requested of proxy value");
+    return 0;
+}
+
+bool
+Transform::ProxyData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::ProxyData::operator!=(const Data& rhs) const
+{
+    const ProxyData* p = dynamic_cast<const ProxyData*>(&rhs);
+    if(!p)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != p->_value;
+}
+
+bool
+Transform::ProxyData::operator<(const Data& rhs) const
+{
+    const ProxyData* p = dynamic_cast<const ProxyData*>(&rhs);
+    if(!p)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < p->_value;
+}
+
+void
+Transform::ProxyData::registerObjects(ObjectDataMap&) const
+{
+}
+
+void
+Transform::ProxyData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::ProxyData::set(const DataPtr& value, DataInterceptor&, bool)
+{
+    transformI(value);
+}
+
+Transform::DataPtr
+Transform::ProxyData::clone() const
+{
+    return new ProxyData(_type, _communicator, _errorReporter, _readOnly, _value);
+}
+
+Slice::TypePtr
+Transform::ProxyData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::ProxyData::destroy()
+{
+}
+
+void
+Transform::ProxyData::marshal(IceInternal::BasicStream& os) const
+{
+    os.write(_value);
+}
+
+void
+Transform::ProxyData::unmarshal(IceInternal::BasicStream& is)
+{
+    is.read(_value);
+}
+
+bool
+Transform::ProxyData::booleanValue(bool) const
+{
+    _errorReporter->error("proxy cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::ProxyData::integerValue(bool) const
+{
+    _errorReporter->error("proxy cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::ProxyData::doubleValue(bool) const
+{
+    _errorReporter->error("proxy cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::ProxyData::stringValue(bool) const
+{
+    _errorReporter->error("proxy cannot be converted to string");
+    return string();
+}
+
+string
+Transform::ProxyData::toString() const
+{
+    if(_value && _str.empty())
+    {
+        const_cast<string&>(_str) = _communicator->proxyToString(_value);
+    }
+    return _str;
+}
+
+Ice::ObjectPrx
+Transform::ProxyData::getValue() const
+{
+    return _value;
+}
+
+void
+Transform::ProxyData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << typeName(_type) << "*(" << toString() << ")";
+}
+
+void
+Transform::ProxyData::transformI(const DataPtr& data)
+{
+    ProxyDataPtr p = ProxyDataPtr::dynamicCast(data);
+    StringDataPtr s = StringDataPtr::dynamicCast(data);
+    if(p)
+    {
+        _value = p->getValue();
+        _str.clear();
+    }
+    else if(s)
+    {
+        setValue(s->stringValue());
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+void
+Transform::ProxyData::setValue(const string& str)
+{
+    try
+    {
+        _value = _communicator->stringToProxy(str);
+        _str = str;
+    }
+    catch(const Ice::LocalException&)
+    {
+        _errorReporter->conversionError(str, _type);
+    }
+}
+
+//
+// StructData
+//
+Transform::StructData::StructData(const DataFactoryPtr& factory, const Slice::StructPtr& type,
+                                  const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly), _type(type)
+{
+    Slice::DataMemberList members = type->dataMembers();
+    for(Slice::DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
+    {
+        DataPtr value = factory->create((*q)->type(), _readOnly);
+        assert(value);
+        _members[(*q)->name()] = value;
+    }
+}
+
+Transform::StructData::StructData(const Slice::StructPtr& type, const ErrorReporterPtr& errorReporter, bool readOnly,
+                                  const DataMemberMap& members) :
+    Data(errorReporter, readOnly), _type(type)
+{
+    for(DataMemberMap::const_iterator p = members.begin(); p != members.end(); ++p)
+    {
+        _members[p->first] = p->second->clone();
+    }
+}
+
+Transform::DataPtr
+Transform::StructData::getMember(const string& member) const
+{
+    DataMemberMap::const_iterator p = _members.find(member);
+    if(p != _members.end())
+    {
+        return p->second;
+    }
+
+    return 0;
+}
+
+Transform::DataPtr
+Transform::StructData::getElement(const DataPtr&) const
+{
+    _errorReporter->error("element requested of struct value");
+    return 0;
+}
+
+bool
+Transform::StructData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::StructData::operator!=(const Data& rhs) const
+{
+    const StructData* s = dynamic_cast<const StructData*>(&rhs);
+    if(!s || _type->scoped() != s->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    assert(_members.size() == s->_members.size());
+
+    for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+    {
+        DataMemberMap::const_iterator q = s->_members.find(p->first);
+        assert(q != s->_members.end());
+
+        if(p->second != q->second)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+Transform::StructData::operator<(const Data& rhs) const
+{
+    const StructData* s = dynamic_cast<const StructData*>(&rhs);
+    if(!s || _type->scoped() != s->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    assert(_members.size() == s->_members.size());
+
+    for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+    {
+        DataMemberMap::const_iterator q = s->_members.find(p->first);
+        assert(q != s->_members.end());
+
+        if(p->second < q->second)
+        {
+            return true;
+        }
+        else if(q->second < p->second)
+        {
+            return false;
+        }
+    }
+
+    return false;
+}
+
+void
+Transform::StructData::registerObjects(ObjectDataMap& map) const
+{
+    for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+    {
+        p->second->registerObjects(map);
+    }
+}
+
+void
+Transform::StructData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data, interceptor);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::StructData::set(const DataPtr& value, DataInterceptor& interceptor, bool)
+{
+    if(value->getType()->unit().get() != _type->unit().get())
+    {
+        transform(value, interceptor);
+    }
+    else
+    {
+        transformI(value, interceptor);
+    }
+}
+
+Transform::DataPtr
+Transform::StructData::clone() const
+{
+    return new StructData(_type, _errorReporter, _readOnly, _members);
+}
+
+Slice::TypePtr
+Transform::StructData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::StructData::destroy()
+{
+    for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+    {
+        p->second->destroy();
+    }
+}
+
+void
+Transform::StructData::marshal(IceInternal::BasicStream& os) const
+{
+    Slice::DataMemberList members = _type->dataMembers();
+    for(Slice::DataMemberList::iterator p = members.begin(); p != members.end(); ++p)
+    {
+        DataMemberMap::const_iterator q = _members.find((*p)->name());
+        assert(q != _members.end());
+        q->second->marshal(os);
+    }
+}
+
+void
+Transform::StructData::unmarshal(IceInternal::BasicStream& is)
+{
+    Slice::DataMemberList members = _type->dataMembers();
+    for(Slice::DataMemberList::iterator p = members.begin(); p != members.end(); ++p)
+    {
+        DataMemberMap::const_iterator q = _members.find((*p)->name());
+        assert(q != _members.end());
+        q->second->unmarshal(is);
+    }
+}
+
+bool
+Transform::StructData::booleanValue(bool) const
+{
+    _errorReporter->error("struct " + typeName(_type) + " cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::StructData::integerValue(bool) const
+{
+    _errorReporter->error("struct " + typeName(_type) + " cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::StructData::doubleValue(bool) const
+{
+    _errorReporter->error("struct " + typeName(_type) + " cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::StructData::stringValue(bool) const
+{
+    _errorReporter->error("struct " + typeName(_type) + " cannot be converted to string");
+    return string();
+}
+
+string
+Transform::StructData::toString() const
+{
+    return stringValue();
+}
+
+Transform::DataMemberMap
+Transform::StructData::getMembers() const
+{
+    return _members;
+}
+
+void
+Transform::StructData::printI(IceUtil::Output& out, ObjectDataHistory& history) const
+{
+    out << "struct " << typeName(_type);
+    out << sb;
+    for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+    {
+        out << nl;
+        out << p->first << " = ";
+        p->second->printI(out, history);
+    }
+    out << eb;
+}
+
+void
+Transform::StructData::transformI(const DataPtr& data, DataInterceptor& interceptor)
+{
+    StructDataPtr s = StructDataPtr::dynamicCast(data);
+    if(s && _type->scoped() == s->_type->scoped())
+    {
+        //
+        // Invoke transform() on members with the same name.
+        //
+        for(DataMemberMap::iterator p = _members.begin(); p != _members.end(); ++p)
+        {
+            DataMemberMap::iterator q = s->_members.find(p->first);
+            if(q != s->_members.end())
+            {
+                p->second->transform(q->second, interceptor);
+            }
+        }
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+//
+// SequenceData
+//
+Transform::SequenceData::SequenceData(const DataFactoryPtr& factory, const Slice::SequencePtr& type,
+                                      const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    _length = _factory->createInteger(0, true);
+}
+
+Transform::SequenceData::SequenceData(const DataFactoryPtr& factory, const Slice::SequencePtr& type,
+                                      const ErrorReporterPtr& errorReporter, bool readOnly, const DataList& elements) :
+    Data(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    for(DataList::const_iterator p = elements.begin(); p != elements.end(); ++p)
+    {
+        _elements.push_back((*p)->clone());
+    }
+    _length = _factory->createInteger(static_cast<Ice::Long>(_elements.size()), true);
+}
+
+Transform::DataPtr
+Transform::SequenceData::getMember(const string& member) const
+{
+    if(member == "length")
+    {
+        return _length;
+    }
+
+    return 0;
+}
+
+Transform::DataPtr
+Transform::SequenceData::getElement(const DataPtr& element) const
+{
+    IntegerDataPtr i = IntegerDataPtr::dynamicCast(element);
+    if(!i)
+    {
+        _errorReporter->error("invalid sequence index type " + typeName(element->getType()));
+    }
+
+    Ice::Long iv = i->integerValue();
+    if(iv < 0 || iv >= _elements.size())
+    {
+        _errorReporter->error("sequence index " + i->toString() + " out of range");
+    }
+
+    return _elements[static_cast<DataList::size_type>(iv)];
+}
+
+bool
+Transform::SequenceData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::SequenceData::operator!=(const Data& rhs) const
+{
+    const SequenceData* s = dynamic_cast<const SequenceData*>(&rhs);
+    if(!s || _type->scoped() != s->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _elements != s->_elements;
+}
+
+bool
+Transform::SequenceData::operator<(const Data& rhs) const
+{
+    const SequenceData* s = dynamic_cast<const SequenceData*>(&rhs);
+    if(!s || _type->scoped() != s->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _elements < s->_elements;
+}
+
+void
+Transform::SequenceData::registerObjects(ObjectDataMap& map) const
+{
+    if(_type->type()->usesClasses())
+    {
+        for(DataList::const_iterator p = _elements.begin(); p != _elements.end(); ++p)
+        {
+            (*p)->registerObjects(map);
+        }
+    }
+}
+
+void
+Transform::SequenceData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data, interceptor);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::SequenceData::set(const DataPtr& value, DataInterceptor& interceptor, bool)
+{
+    if(value->getType()->unit().get() != _type->unit().get())
+    {
+        transform(value, interceptor);
+    }
+    else
+    {
+        transformI(value, interceptor);
+    }
+}
+
+Transform::DataPtr
+Transform::SequenceData::clone() const
+{
+    return new SequenceData(_factory, _type, _errorReporter, _readOnly, _elements);
+}
+
+Slice::TypePtr
+Transform::SequenceData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::SequenceData::destroy()
+{
+    for(DataList::const_iterator p = _elements.begin(); p != _elements.end(); ++p)
+    {
+        (*p)->destroy();
+    }
+}
+
+void
+Transform::SequenceData::marshal(IceInternal::BasicStream& os) const
+{
+    os.writeSize(_elements.size());
+    for(DataList::const_iterator p = _elements.begin(); p != _elements.end(); ++p)
+    {
+        (*p)->marshal(os);
+    }
+}
+
+void
+Transform::SequenceData::unmarshal(IceInternal::BasicStream& is)
+{
+    Slice::TypePtr type = _type->type();
+    Ice::Int sz;
+    is.readSize(sz);
+    _elements.reserve(sz);
+    for(Ice::Int i = 0; i < sz; ++i)
+    {
+        DataPtr v = _factory->create(type, _readOnly);
+        v->unmarshal(is);
+        _elements.push_back(v);
+    }
+    _length = _factory->createInteger(sz, true);
+}
+
+bool
+Transform::SequenceData::booleanValue(bool) const
+{
+    _errorReporter->error("sequence " + typeName(_type) + " cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::SequenceData::integerValue(bool) const
+{
+    _errorReporter->error("sequence " + typeName(_type) + " cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::SequenceData::doubleValue(bool) const
+{
+    _errorReporter->error("sequence " + typeName(_type) + " cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::SequenceData::stringValue(bool) const
+{
+    _errorReporter->error("sequence " + typeName(_type) + " cannot be converted to string");
+    return string();
+}
+
+string
+Transform::SequenceData::toString() const
+{
+    return stringValue();
+}
+
+Transform::DataList
+Transform::SequenceData::getElements() const
+{
+    return _elements;
+}
+
+void
+Transform::SequenceData::printI(IceUtil::Output& out, ObjectDataHistory& history) const
+{
+    out << "sequence " << typeName(_type) << " (size = " << _elements.size() << ")";
+    out << sb;
+    Ice::Int i = 0;
+    for(DataList::const_iterator p = _elements.begin(); p != _elements.end(); ++p, ++i)
+    {
+        out << nl << "[" << i << "] = ";
+        (*p)->printI(out, history);
+    }
+    out << eb;
+}
+
+void
+Transform::SequenceData::transformI(const DataPtr& data, DataInterceptor& interceptor)
+{
+    SequenceDataPtr s = SequenceDataPtr::dynamicCast(data);
+    if(s && isCompatible(_type, s->_type))
+    {
+        DataList elements;
+        for(DataList::const_iterator p = s->_elements.begin(); p != s->_elements.end(); ++p)
+        {
+            DataPtr element = _factory->create(_type->type(), _readOnly);
+            //
+            // We add the element regardless of whether transform() succeeds in order to
+            // preserve the original sequence size and order.
+            //
+            element->transform((*p), interceptor);
+            elements.push_back(element);
+        }
+        _elements = elements;
+        _length = _factory->createInteger(static_cast<Ice::Long>(_elements.size()), true);
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+//
+// EnumData
+//
+Transform::EnumData::EnumData(const Slice::EnumPtr& type, const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly), _type(type), _value(0)
+{
+    _count = static_cast<long>(type->getEnumerators().size());
+}
+
+Transform::EnumData::EnumData(const Slice::EnumPtr& type, const ErrorReporterPtr& errorReporter, bool readOnly,
+                              Ice::Int value) :
+    Data(errorReporter, readOnly), _type(type), _value(value)
+{
+    _count = static_cast<long>(type->getEnumerators().size());
+}
+
+Transform::DataPtr
+Transform::EnumData::getMember(const string&) const
+{
+    return 0;
+}
+
+Transform::DataPtr
+Transform::EnumData::getElement(const DataPtr&) const
+{
+    _errorReporter->error("element requested of enum value");
+    return 0;
+}
+
+bool
+Transform::EnumData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::EnumData::operator!=(const Data& rhs) const
+{
+    const EnumData* e = dynamic_cast<const EnumData*>(&rhs);
+    if(!e || _type->scoped() != e->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value != e->_value;
+}
+
+bool
+Transform::EnumData::operator<(const Data& rhs) const
+{
+    const EnumData* e = dynamic_cast<const EnumData*>(&rhs);
+    if(!e || _type->scoped() != e->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _value < e->_value;
+}
+
+void
+Transform::EnumData::registerObjects(ObjectDataMap& map) const
+{
+}
+
+void
+Transform::EnumData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data, interceptor);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::EnumData::set(const DataPtr& value, DataInterceptor& interceptor, bool convert)
+{
+    IntegerDataPtr i = IntegerDataPtr::dynamicCast(value);
+    if(i && convert)
+    {
+        Ice::Long v = i->integerValue();
+        if(v < 0 || v > _count)
+        {
+            _errorReporter->rangeError(i->toString(), _type);
+        }
+        else
+        {
+            _value = v;
+            _name.clear();
+        }
+    }
+    else if(value->getType()->unit().get() != _type->unit().get())
+    {
+        transform(value, interceptor);
+    }
+    else
+    {
+        transformI(value, interceptor);
+    }
+}
+
+Transform::DataPtr
+Transform::EnumData::clone() const
+{
+    return new EnumData(_type, _errorReporter, _value);
+}
+
+Slice::TypePtr
+Transform::EnumData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::EnumData::destroy()
+{
+}
+
+void
+Transform::EnumData::marshal(IceInternal::BasicStream& os) const
+{
+    if(_count <= 127)
+    {
+        os.write(static_cast<Ice::Byte>(_value));
+    }
+    else if(_count <= 32767)
+    {
+        os.write(static_cast<Ice::Short>(_value));
+    }
+    else
+    {
+        os.write(_value);
+    }
+}
+
+void
+Transform::EnumData::unmarshal(IceInternal::BasicStream& is)
+{
+    if(_count <= 127)
+    {
+        Ice::Byte val;
+        is.read(val);
+        _value = val & 0xff;
+    }
+    else if(_count <= 32767)
+    {
+        Ice::Short val;
+        is.read(val);
+        _value = val;
+    }
+    else
+    {
+        is.read(_value);
+    }
+}
+
+bool
+Transform::EnumData::booleanValue(bool) const
+{
+    _errorReporter->error("enum " + typeName(_type) + " cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::EnumData::integerValue(bool convert) const
+{
+    if(convert)
+    {
+        return _value;
+    }
+    else
+    {
+        _errorReporter->error("enum " + typeName(_type) + " cannot be converted to integer");
+        return 0;
+    }
+}
+
+double
+Transform::EnumData::doubleValue(bool) const
+{
+    _errorReporter->error("enum " + typeName(_type) + " cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::EnumData::stringValue(bool) const
+{
+    _errorReporter->error("enum " + typeName(_type) + " cannot be converted to string");
+    return string();
+}
+
+string
+Transform::EnumData::toString() const
+{
+    if(_name.empty())
+    {
+        Slice::EnumeratorList l = _type->getEnumerators();
+        Slice::EnumeratorList::const_iterator p = l.begin();
+        Ice::Int i = _value;
+        while(i > 0)
+        {
+            ++p;
+            assert(p != l.end());
+            --i;
+        }
+        const_cast<string&>(_name) = (*p)->name();
+    }
+    return _name;
+}
+
+Ice::Int
+Transform::EnumData::getValue() const
+{
+    return _value;
+}
+
+bool
+Transform::EnumData::setValue(Ice::Int v)
+{
+    if(v >= 0 && v < _count)
+    {
+        _value = v;
+        _name.clear();
+        return true;
+    }
+    return false;
+}
+
+bool
+Transform::EnumData::setValueAsString(const string& v)
+{
+    Slice::EnumeratorList l = _type->getEnumerators();
+    Slice::EnumeratorList::const_iterator p;
+    Ice::Int i = 0;
+    for(p = l.begin(); p != l.end(); ++p, ++i)
+    {
+        if((*p)->name() == v)
+        {
+            _value = i;
+            _name = v;
+            break;
+        }
+    }
+    return p != l.end();
+}
+
+void
+Transform::EnumData::printI(IceUtil::Output& out, ObjectDataHistory&) const
+{
+    out << typeName(_type) << "(" << toString() << ")";
+}
+
+void
+Transform::EnumData::transformI(const DataPtr& data, DataInterceptor& interceptor)
+{
+    EnumDataPtr e = EnumDataPtr::dynamicCast(data);
+    StringDataPtr s = StringDataPtr::dynamicCast(data);
+    if(e && _type->scoped() == e->_type->scoped())
+    {
+        //
+        // Get the enumerator's name and attempt to find it in our type.
+        //
+        string name = e->toString();
+        if(!setValueAsString(name))
+        {
+            _errorReporter->conversionError(name, _type);
+        }
+    }
+    else if(s)
+    {
+        string v = s->stringValue();
+        if(!setValueAsString(v))
+        {
+            _errorReporter->conversionError(v, _type);
+        }
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+//
+// DictionaryData
+//
+Transform::DictionaryData::DictionaryData(const DataFactoryPtr& factory, const Slice::DictionaryPtr& type,
+                                          const ErrorReporterPtr& errorReporter, bool readOnly) :
+    Data(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    _length = _factory->createInteger(0, true);
+}
+
+Transform::DictionaryData::DictionaryData(const DataFactoryPtr& factory, const Slice::DictionaryPtr& type,
+                                          const ErrorReporterPtr& errorReporter, bool readOnly, const DataMap& map) :
+    Data(errorReporter, readOnly), _factory(factory), _type(type)
+{
+    for(DataMap::const_iterator p = map.begin(); p != map.end(); ++p)
+    {
+        _map.insert(DataMap::value_type(p->first->clone(), p->second->clone()));
+    }
+    _length = _factory->createInteger(static_cast<Ice::Long>(_map.size()), true);
+}
+
+Transform::DataPtr
+Transform::DictionaryData::getMember(const string& member) const
+{
+    if(member == "length")
+    {
+        return _length;
+    }
+
+    return 0;
+}
+
+Transform::DataPtr
+Transform::DictionaryData::getElement(const DataPtr& element) const
+{
+    // TODO: Validate element's type
+
+    DataMap::const_iterator p = _map.find(element);
+    if(p != _map.end())
+    {
+        return p->second;
+    }
+
+    return 0;
+}
+
+bool
+Transform::DictionaryData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::DictionaryData::operator!=(const Data& rhs) const
+{
+    const DictionaryData* d = dynamic_cast<const DictionaryData*>(&rhs);
+    if(!d || _type->scoped() != d->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _map != d->_map;
+}
+
+bool
+Transform::DictionaryData::operator<(const Data& rhs) const
+{
+    const DictionaryData* d = dynamic_cast<const DictionaryData*>(&rhs);
+    if(!d || _type->scoped() != d->_type->scoped())
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+        assert(false);
+    }
+
+    return _map < d->_map;
+}
+
+void
+Transform::DictionaryData::registerObjects(ObjectDataMap& map) const
+{
+    if(_type->valueType()->usesClasses())
+    {
+        for(DataMap::const_iterator p = _map.begin(); p != _map.end(); ++p)
+        {
+            p->second->registerObjects(map);
+        }
+    }
+}
+
+void
+Transform::DictionaryData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data, interceptor);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::DictionaryData::set(const DataPtr& value, DataInterceptor& interceptor, bool)
+{
+    if(value->getType()->unit().get() != _type->unit().get())
+    {
+        transform(value, interceptor);
+    }
+    else
+    {
+        transformI(value, interceptor);
+    }
+}
+
+Transform::DataPtr
+Transform::DictionaryData::clone() const
+{
+    return new DictionaryData(_factory, _type, _errorReporter, _readOnly, _map);
+}
+
+Slice::TypePtr
+Transform::DictionaryData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::DictionaryData::destroy()
+{
+    for(DataMap::const_iterator p = _map.begin(); p != _map.end(); ++p)
+    {
+        p->first->destroy();
+        p->second->destroy();
+    }
+}
+
+void
+Transform::DictionaryData::marshal(IceInternal::BasicStream& os) const
+{
+    os.writeSize(_map.size());
+    for(DataMap::const_iterator p = _map.begin(); p != _map.end(); ++p)
+    {
+        p->first->marshal(os);
+        p->second->marshal(os);
+    }
+}
+
+void
+Transform::DictionaryData::unmarshal(IceInternal::BasicStream& is)
+{
+    Slice::TypePtr keyType = _type->keyType();
+    Slice::TypePtr valueType = _type->valueType();
+
+    Ice::Int sz;
+    is.readSize(sz);
+
+    for(Ice::Int i = 0; i < sz; ++i)
+    {
+        DataPtr key = _factory->create(keyType, _readOnly);
+        key->unmarshal(is);
+
+        DataPtr value = _factory->create(valueType, _readOnly);
+        value->unmarshal(is);
+
+        _map.insert(DataMap::value_type(key, value));
+    }
+
+    _length = _factory->createInteger(static_cast<Ice::Long>(_map.size()), true);
+}
+
+bool
+Transform::DictionaryData::booleanValue(bool) const
+{
+    _errorReporter->error("dictionary " + typeName(_type) + " cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::DictionaryData::integerValue(bool) const
+{
+    _errorReporter->error("dictionary " + typeName(_type) + " cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::DictionaryData::doubleValue(bool) const
+{
+    _errorReporter->error("dictionary " + typeName(_type) + " cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::DictionaryData::stringValue(bool) const
+{
+    _errorReporter->error("dictionary " + typeName(_type) + " cannot be converted to string");
+    return string();
+}
+
+string
+Transform::DictionaryData::toString() const
+{
+    return stringValue();
+}
+
+void
+Transform::DictionaryData::printI(IceUtil::Output& out, ObjectDataHistory& history) const
+{
+    out << "dictionary " << typeName(_type) << " (size = " << _map.size() << ")";
+    out << sb;
+    for(DataMap::const_iterator p = _map.begin(); p != _map.end(); ++p)
+    {
+        out << nl;
+        p->first->printI(out, history);
+        out << " => ";
+        p->second->printI(out, history);
+    }
+    out << eb;
+}
+
+void
+Transform::DictionaryData::transformI(const DataPtr& data, DataInterceptor& interceptor)
+{
+    DictionaryDataPtr d = DictionaryDataPtr::dynamicCast(data);
+    if(d && isCompatible(_type, d->_type))
+    {
+        DataMap map;
+        for(DataMap::const_iterator p = d->_map.begin(); p != d->_map.end(); ++p)
+        {
+            DataPtr key = _factory->create(_type->keyType(), _readOnly);
+            DataPtr value = _factory->create(_type->valueType(), _readOnly);
+            key->transform(p->first, interceptor);
+            value->transform(p->second, interceptor);
+            DataMap::const_iterator q = map.find(key);
+            if(q != map.end())
+            {
+                ostringstream ostr;
+                ostr << "duplicate dictionary key (";
+                key->print(ostr);
+                ostr << ")";
+                _errorReporter->warning(ostr.str());
+            }
+            else
+            {
+                map.insert(DataMap::value_type(key, value));
+            }
+        }
+        _map = map;
+        _length = _factory->createInteger(static_cast<Ice::Long>(_map.size()), true);
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+Transform::DataMap
+Transform::DictionaryData::getElements() const
+{
+    return _map;
+}
+
+void
+Transform::DictionaryData::put(const DataPtr& key, const DataPtr& value, DataInterceptor& interceptor, bool convert)
+{
+    assert(!readOnly());
+
+    if(!isCompatible(_type->keyType(), key->getType()))
+    {
+        _errorReporter->typeMismatchError(_type->keyType(), key->getType(), true);
+    }
+    if(!isCompatible(_type->valueType(), value->getType()))
+    {
+        _errorReporter->typeMismatchError(_type->valueType(), value->getType(), true);
+    }
+
+    DataPtr newKey = _factory->create(_type->keyType(), false);
+    newKey->set(key, interceptor, convert);
+    DataPtr newValue = _factory->create(_type->valueType(), false);
+    newValue->set(value, interceptor, convert);
+
+    DataMap::iterator p = _map.find(newKey);
+    if(p != _map.end())
+    {
+        p->first->destroy();
+        p->second->destroy();
+    }
+
+    _map.insert(DataMap::value_type(newKey, newValue));
+    _length = _factory->createInteger(static_cast<Ice::Long>(_map.size()), true);
+}
+
+void
+Transform::DictionaryData::remove(const DataPtr& key)
+{
+    DataMap::iterator p = _map.find(key);
+    if(p != _map.end())
+    {
+        p->first->destroy();
+        p->second->destroy();
+        _map.erase(p);
+        _length = _factory->createInteger(static_cast<Ice::Long>(_map.size()), true);
+    }
+}
+
+//
+// ObjectData
+//
+Transform::ObjectData::ObjectData(const DataFactoryPtr& factory, const Slice::TypePtr& type, bool readOnly) :
+    Data(factory->getErrorReporter(), readOnly), _type(type), _refCount(0)
+{
+    //
+    // Create a Data object for the facet map. We add this to the _members map so that
+    // the `ice_facets' member is handled like all other members.
+    //
+    Slice::TypeList l = _type->unit()->lookupType("::_FacetMap", false);
+    assert(!l.empty());
+    _facetMap = factory->create(l.front(), readOnly);
+    _members["ice_facets"] = _facetMap;
+
+    Slice::ClassDeclPtr decl = Slice::ClassDeclPtr::dynamicCast(type);
+    if(decl)
+    {
+        Slice::ClassDefPtr def = decl->definition();
+        assert(def);
+        Slice::DataMemberList members = def->allDataMembers();
+        for(Slice::DataMemberList::iterator p = members.begin(); p != members.end(); ++p)
+        {
+            _members[(*p)->name()] = factory->create((*p)->type(), _readOnly);
+        }
+        _id = factory->createString(decl->scoped(), true);
+    }
+    else
+    {
+        _id = factory->createString("::Ice::Object", true);
+    }
+}
+
+Transform::DataPtr
+Transform::ObjectData::getMember(const string& member) const
+{
+    if(member == "ice_id")
+    {
+        return _id;
+    }
+
+    DataMemberMap::const_iterator p = _members.find(member);
+    if(p != _members.end())
+    {
+        return p->second;
+    }
+
+    return 0;
+}
+
+Transform::DataPtr
+Transform::ObjectData::getElement(const DataPtr& element) const
+{
+    _errorReporter->error("element requested of object value");
+    return 0;
+}
+
+bool
+Transform::ObjectData::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::ObjectData::operator!=(const Data& rhs) const
+{
+    _errorReporter->error("object comparison not supported");
+    return false;
+}
+
+bool
+Transform::ObjectData::operator<(const Data& rhs) const
+{
+    _errorReporter->error("object comparison not supported");
+    return false;
+}
+
+void
+Transform::ObjectData::registerObjects(ObjectDataMap& map) const
+{
+    ObjectDataMap::iterator p = map.find(this);
+    if(p == map.end())
+    {
+        map.insert(ObjectDataMap::value_type(this, 0));
+        for(DataMemberMap::const_iterator q = _members.begin(); q != _members.end(); ++q)
+        {
+            q->second->registerObjects(map);
+        }
+    }
+}
+
+void
+Transform::ObjectData::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    ObjectDataPtr o = ObjectDataPtr::dynamicCast(data);
+    if(o)
+    {
+        assert(isCompatible(_type, o->_type));
+
+        //
+        // The source object must be present in the object map (we currently don't support
+        // transforming two ObjectData instances from the same Slice unit - this transform
+        // would be handled by-reference at the ObjectRef level). We must update the object
+        // map before transforming members in order to handle cycles.
+        //
+        ObjectDataMap& objectMap = interceptor.getObjectMap();
+        ObjectDataMap::iterator p = objectMap.find(o.get());
+        assert(p != objectMap.end());
+        assert(p->second == 0);
+        objectMap.erase(p);
+        objectMap.insert(ObjectDataMap::value_type(o.get(), this));
+
+        try
+        {
+            //
+            // Invoke transform() on members with the same name.
+            //
+            for(DataMemberMap::iterator p = _members.begin(); p != _members.end(); ++p)
+            {
+                DataMemberMap::iterator q = o->_members.find(p->first);
+                if(q != o->_members.end())
+                {
+                    p->second->transform(q->second, interceptor);
+                }
+            }
+        }
+        catch(...)
+        {
+            objectMap.insert(ObjectDataMap::value_type(o.get(), 0));
+            throw;
+        }
+    }
+    else
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+}
+
+void
+Transform::ObjectData::set(const DataPtr&, DataInterceptor&, bool)
+{
+    assert(false);
+}
+
+Transform::DataPtr
+Transform::ObjectData::clone() const
+{
+    assert(false);
+    return 0;
+}
+
+Slice::TypePtr
+Transform::ObjectData::getType() const
+{
+    return _type;
+}
+
+void
+Transform::ObjectData::destroy()
+{
+    assert(false);
+}
+
+void
+Transform::ObjectData::marshal(IceInternal::BasicStream& os) const
+{
+    if(!_marshaler)
+    {
+        const_cast<Ice::ObjectPtr&>(_marshaler) = new ObjectWriter(const_cast<ObjectData*>(this));
+    }
+    os.write(_marshaler);
+}
+
+void
+Transform::ObjectData::unmarshal(IceInternal::BasicStream& is)
+{
+    //
+    // Unmarshaling is done by ObjectReader.
+    //
+    assert(false);
+}
+
+bool
+Transform::ObjectData::booleanValue(bool) const
+{
+    assert(false);
+    return 0;
+}
+
+Ice::Long
+Transform::ObjectData::integerValue(bool) const
+{
+    assert(false);
+    return 0;
+}
+
+double
+Transform::ObjectData::doubleValue(bool) const
+{
+    assert(false);
+    return 0;
+}
+
+string
+Transform::ObjectData::stringValue(bool) const
+{
+    assert(false);
+    return string();
+}
+
+string
+Transform::ObjectData::toString() const
+{
+    assert(false);
+    return string();
+}
+
+void
+Transform::ObjectData::incRef()
+{
+    _refCount++;
+}
+
+void
+Transform::ObjectData::decRef()
+{
+    assert(_refCount > 0);
+    _refCount--;
+    if(_refCount == 0)
+    {
+        destroyI();
+    }
+}
+
+void
+Transform::ObjectData::printI(IceUtil::Output& out, ObjectDataHistory& history) const
+{
+    out << "class " << typeName(_type);
+    ObjectDataHistory::iterator p = history.find(this);
+    if(p != history.end())
+    {
+        out << " (cycle)";
+    }
+    else
+    {
+        history.insert(ObjectDataHistory::value_type(this, true));
+        out << sb;
+        for(DataMemberMap::const_iterator p = _members.begin(); p != _members.end(); ++p)
+        {
+            out << nl << p->first << " = ";
+            p->second->printI(out, history);
+        }
+        out << eb;
+    }
+}
+
+void
+Transform::ObjectData::destroyI()
+{
+    DataMemberMap members = _members;
+
+    _members.clear();
+    _marshaler = 0;
+
+    for(DataMemberMap::const_iterator p = members.begin(); p != members.end(); ++p)
+    {
+        p->second->destroy();
+    }
+}
+
+//
+// ObjectRef
+//
+Transform::ObjectRef::ObjectRef(const DataFactoryPtr& factory, const Slice::TypePtr& type, bool readOnly) :
+    Data(factory->getErrorReporter(), readOnly), _factory(factory), _type(type)
+{
+}
+
+Transform::ObjectRef::ObjectRef(const DataFactoryPtr& factory, const Slice::TypePtr& type, bool readOnly,
+                                const ObjectDataPtr& value) :
+    Data(factory->getErrorReporter(), readOnly), _factory(factory), _type(type), _value(value)
+{
+    _value->incRef();
+}
+
+Transform::DataPtr
+Transform::ObjectRef::getMember(const string& member) const
+{
+    if(!_value)
+    {
+        _errorReporter->error("member `" + member + "' requested of nil object");
+    }
+
+    return _value->getMember(member);
+}
+
+Transform::DataPtr
+Transform::ObjectRef::getElement(const DataPtr&) const
+{
+    _errorReporter->error("element requested of object value");
+    return 0;
+}
+
+bool
+Transform::ObjectRef::operator==(const Data& rhs) const
+{
+    return !operator!=(rhs);
+}
+
+bool
+Transform::ObjectRef::operator!=(const Data& rhs) const
+{
+    const ObjectRef* r = dynamic_cast<const ObjectRef*>(&rhs);
+    if(!r)
+    {
+        _errorReporter->typeMismatchError(_type, rhs.getType(), true);
+    }
+
+    if(!_value || !r->_value)
+    {
+        return !_value && r->_value;
+    }
+
+    //
+    // Reference comparison.
+    //
+    return _value.get() != r->_value.get();
+}
+
+bool
+Transform::ObjectRef::operator<(const Data& rhs) const
+{
+    _errorReporter->error("object comparison not supported");
+    return false;
+}
+
+void
+Transform::ObjectRef::registerObjects(ObjectDataMap& map) const
+{
+    if(_value)
+    {
+        _value->registerObjects(map);
+    }
+}
+
+void
+Transform::ObjectRef::transform(const DataPtr& data, DataInterceptor& interceptor)
+{
+    if(interceptor.preTransform(this, data))
+    {
+        transformI(data, interceptor);
+    }
+    interceptor.postTransform(this, data);
+}
+
+void
+Transform::ObjectRef::set(const DataPtr& value, DataInterceptor& interceptor, bool)
+{
+    transformI(value, interceptor);
+}
+
+Transform::DataPtr
+Transform::ObjectRef::clone() const
+{
+    return new ObjectRef(_factory, _type, _value);
+}
+
+Slice::TypePtr
+Transform::ObjectRef::getType() const
+{
+    return _type;
+}
+
+void
+Transform::ObjectRef::destroy()
+{
+    if(_value)
+    {
+        _value->decRef();
+        _value = 0;
+    }
+}
+
+void
+Transform::ObjectRef::marshal(IceInternal::BasicStream& os) const
+{
+    if(!_value)
+    {
+        os.write(Ice::ObjectPtr());
+        return;
+    }
+
+    _value->marshal(os);
+}
+
+static void
+patchObject(void* addr, Ice::ObjectPtr& v)
+{
+    if(v)
+    {
+        Transform::ObjectRef* ref = static_cast<Transform::ObjectRef*>(addr);
+        assert(ref);
+
+        Transform::ObjectReaderPtr reader = Transform::ObjectReaderPtr::dynamicCast(v);
+        assert(reader);
+
+        ref->setValue(reader->getValue());
+    }
+}
+
+void
+Transform::ObjectRef::unmarshal(IceInternal::BasicStream& is)
+{
+    is.read(patchObject, this);
+}
+
+bool
+Transform::ObjectRef::booleanValue(bool) const
+{
+    _errorReporter->error(typeName(_type) + " cannot be converted to boolean");
+    return 0;
+}
+
+Ice::Long
+Transform::ObjectRef::integerValue(bool) const
+{
+    _errorReporter->error(typeName(_type) + " cannot be converted to integer");
+    return 0;
+}
+
+double
+Transform::ObjectRef::doubleValue(bool) const
+{
+    _errorReporter->error(typeName(_type) + " cannot be converted to double");
+    return 0;
+}
+
+string
+Transform::ObjectRef::stringValue(bool) const
+{
+    _errorReporter->error(typeName(_type) + " cannot be converted to string");
+    return string();
+}
+
+string
+Transform::ObjectRef::toString() const
+{
+    return stringValue();
+}
+
+void
+Transform::ObjectRef::instantiate()
+{
+    ObjectDataPtr data = new ObjectData(_factory, _type, _readOnly);
+    setValue(data);
+}
+
+void
+Transform::ObjectRef::setValue(const ObjectDataPtr& value)
+{
+    // TODO: Type check?
+    ObjectDataPtr oldValue = _value;
+    _value = value;
+    if(_value)
+    {
+        _value->incRef();
+    }
+    if(oldValue)
+    {
+        oldValue->decRef();
+    }
+}
+
+void
+Transform::ObjectRef::printI(IceUtil::Output& out, ObjectDataHistory& history) const
+{
+    if(!_value)
+    {
+        out << typeName(_type) << "(nil)";
+    }
+    else
+    {
+        ostringstream ostr;
+        _value->printI(out, history);
+    }
+}
+
+void
+Transform::ObjectRef::transformI(const DataPtr& data, DataInterceptor& interceptor)
+{
+    ObjectRefPtr o = ObjectRefPtr::dynamicCast(data);
+    if(!o)
+    {
+        _errorReporter->typeMismatchError(_type, data->getType(), false);
+    }
+
+    if(!o->_value)
+    {
+        //
+        // Allow a nil value from type Object.
+        //
+        if(Slice::BuiltinPtr::dynamicCast(o->_type) || isCompatible(_type, o->_type))
+        {
+            setValue(0);
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, o->_type, false);
+        }
+    }
+    else
+    {
+        Slice::TypePtr otype = o->_value->getType();
+        if(isCompatible(_type, otype))
+        {
+            //
+            // If the types are in the same Slice unit, then we can simply
+            // copy the reference. Otherwise, we check the object map to
+            // see if an equivalent object has already been created, and
+            // if not, then we have to create one.
+            //
+            if(_type->unit().get() == otype->unit().get())
+            {
+                setValue(o->_value);
+            }
+            else
+            {
+                ObjectDataMap& objectMap = interceptor.getObjectMap();
+                ObjectDataMap::iterator p = objectMap.find(o->_value.get());
+                if(p != objectMap.end() && p->second)
+                {
+                    setValue(p->second);
+                }
+                else
+                {
+                    string name = typeName(otype);
+                    Slice::TypeList l = _type->unit()->lookupType(name, false);
+                    if(l.empty())
+                    {
+                        // TODO: Slice object? Or missing type exception?
+                        _errorReporter->warning("type `" + name + "' not found");
+                    }
+                    else
+                    {
+                        Slice::ClassDeclPtr decl = Slice::ClassDeclPtr::dynamicCast(l.front());
+                        if(decl)
+                        {
+                            Slice::ClassDefPtr def = decl->definition();
+                            if(!def)
+                            {
+                                _errorReporter->error("no definition for " + name);
+                            }
+                        }
+                        ObjectDataPtr data = new ObjectData(_factory, l.front(), _readOnly);
+                        data->transform(o->_value, interceptor);
+                        setValue(data);
+                    }
+                }
+            }
+        }
+        else
+        {
+            _errorReporter->typeMismatchError(_type, otype, false);
+        }
+    }
+}
+
+//
+// ObjectFactory
+//
+Transform::ObjectFactory::ObjectFactory(const DataFactoryPtr& factory, const Slice::UnitPtr& unit) :
+    _factory(factory), _unit(unit)
+{
+}
+
+Ice::ObjectPtr
+Transform::ObjectFactory::create(const string& id)
+{
+    Ice::ObjectPtr result;
+
+    if(id == Ice::Object::ice_staticId())
+    {
+        result = new ObjectReader(_factory, _unit->builtin(Slice::Builtin::KindObject));
+    }
+    else
+    {
+        Slice::TypeList l = _unit->lookupTypeNoBuiltin(id);
+        if(!l.empty())
+        {
+            Slice::ClassDeclPtr decl = Slice::ClassDeclPtr::dynamicCast(l.front());
+            if(!decl)
+            {
+                _factory->getErrorReporter()->error("Slice definition for `" + id + "' is not a class");
+            }
+            Slice::ClassDefPtr def = decl->definition();
+            if(!def)
+            {
+                _factory->getErrorReporter()->error("no class definition for `" + id + "'");
+            }
+            result = new ObjectReader(_factory, decl);
+        }
+    }
+
+    return result;
+}
+
+void
+Transform::ObjectFactory::destroy()
+{
+}
diff --git a/cpp/src/Transform/Data.h b/cpp/src/Transform/Data.h
new file mode 100644
index 00000000000..92c2268cb2d
--- /dev/null
+++ b/cpp/src/Transform/Data.h
@@ -0,0 +1,658 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_DATA_H
+#define TRANSFORM_DATA_H
+
+#include <Ice/Ice.h>
+#include <Slice/Parser.h>
+#include <IceUtil/OutputUtil.h>
+#include <Transform/Error.h>
+
+namespace Transform
+{
+
+class DataFactory;
+typedef IceUtil::Handle<DataFactory> DataFactoryPtr;
+
+class Data;
+typedef IceUtil::Handle<Data> DataPtr;
+
+typedef std::map<std::string, DataPtr> DataMemberMap;
+typedef std::vector<DataPtr> DataList;
+typedef std::map<DataPtr, DataPtr> DataMap;
+
+class ObjectWriter;
+class ObjectReader;
+
+class ObjectData;
+typedef IceUtil::Handle<ObjectData> ObjectDataPtr;
+typedef std::map<const ObjectData*, ObjectDataPtr> ObjectDataMap;
+typedef std::map<const ObjectData*, bool> ObjectDataHistory;
+
+class DataInterceptor
+{
+public:
+
+    virtual ~DataInterceptor();
+
+    virtual bool preTransform(const DataPtr&, const DataPtr&) = 0;
+    virtual void postTransform(const DataPtr&, const DataPtr&) = 0;
+    virtual ObjectDataMap& getObjectMap() = 0;
+};
+
+class DataInitializer : virtual public IceUtil::SimpleShared
+{
+public:
+
+    virtual ~DataInitializer();
+
+    virtual void initialize(const DataFactoryPtr&, const DataPtr&, const Ice::CommunicatorPtr&) = 0;
+};
+typedef IceUtil::Handle<DataInitializer> DataInitializerPtr;
+
+class DataFactory : public IceUtil::SimpleShared
+{
+public:
+
+    DataFactory(const Ice::CommunicatorPtr&, const Slice::UnitPtr&, const ErrorReporterPtr&);
+
+    DataPtr create(const Slice::TypePtr&, bool);
+    DataPtr createBoolean(bool, bool);
+    DataPtr createInteger(Ice::Long, bool);
+    DataPtr createDouble(double, bool);
+    DataPtr createString(const std::string&, bool);
+    DataPtr createNil(bool);
+
+    Slice::BuiltinPtr getBuiltin(Slice::Builtin::Kind) const;
+
+    void addInitializer(const std::string&, const DataInitializerPtr&);
+    void enableInitializers();
+    void disableInitializers();
+    ErrorReporterPtr getErrorReporter() const;
+
+private:
+
+    DataPtr createImpl(const Slice::TypePtr&, bool);
+
+    Ice::CommunicatorPtr _communicator;
+    Slice::UnitPtr _unit; // Only used for creating builtin types.
+    ErrorReporterPtr _errorReporter;
+    typedef std::map<std::string, DataInitializerPtr> InitMap;
+    InitMap _initializers;
+    bool _initializersEnabled;
+};
+
+class Data : public IceUtil::SimpleShared
+{
+public:
+
+    virtual ~Data();
+
+    virtual DataPtr getMember(const std::string&) const = 0;
+    virtual DataPtr getElement(const DataPtr&) const = 0;
+
+    virtual bool operator==(const Data&) const = 0;
+    virtual bool operator!=(const Data&) const = 0;
+    virtual bool operator<(const Data&) const = 0;
+
+    virtual void registerObjects(ObjectDataMap&) const = 0;
+    virtual void transform(const DataPtr&, DataInterceptor&) = 0;
+    virtual void set(const DataPtr&, DataInterceptor&, bool) = 0;
+    virtual DataPtr clone() const = 0;
+
+    bool readOnly() const;
+    virtual Slice::TypePtr getType() const = 0;
+    void print(std::ostream&) const;
+    virtual void destroy() = 0;
+
+    virtual void marshal(IceInternal::BasicStream&) const = 0;
+    virtual void unmarshal(IceInternal::BasicStream&) = 0;
+
+    virtual bool booleanValue(bool = false) const = 0;
+    virtual Ice::Long integerValue(bool = false) const = 0;
+    virtual double doubleValue(bool = false) const = 0;
+    virtual std::string stringValue(bool = false) const = 0;
+    virtual std::string toString() const = 0;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const = 0;
+
+protected:
+
+    Data(const ErrorReporterPtr&, bool);
+
+    bool isCompatible(const Slice::TypePtr&, const Slice::TypePtr&);
+    bool checkClasses(const Slice::ClassDeclPtr&, const Slice::ClassDeclPtr&);
+
+    ErrorReporterPtr _errorReporter;
+    bool _readOnly;
+};
+
+class PrimitiveData : public Data
+{
+public:
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void destroy();
+
+protected:
+
+    PrimitiveData(const ErrorReporterPtr&, bool);
+};
+typedef IceUtil::Handle<PrimitiveData> PrimitiveDataPtr;
+
+class BooleanData : public PrimitiveData
+{
+public:
+
+    BooleanData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool);
+    BooleanData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool, bool);
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    Slice::BuiltinPtr _type;
+    bool _value;
+};
+typedef IceUtil::Handle<BooleanData> BooleanDataPtr;
+
+class IntegerData : public PrimitiveData
+{
+public:
+
+    IntegerData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool);
+    IntegerData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool, Ice::Long);
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    bool rangeCheck(Ice::Long) const;
+    static std::string toString(Ice::Long);
+
+    Slice::BuiltinPtr _type;
+    Ice::Long _value;
+};
+typedef IceUtil::Handle<IntegerData> IntegerDataPtr;
+
+class DoubleData : public PrimitiveData
+{
+public:
+
+    DoubleData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool);
+    DoubleData(const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool, double);
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    Slice::BuiltinPtr _type;
+    double _value;
+};
+typedef IceUtil::Handle<DoubleData> DoubleDataPtr;
+
+class StringData : public PrimitiveData
+{
+public:
+
+    StringData(const DataFactoryPtr&, const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool);
+    StringData(const DataFactoryPtr&, const Slice::BuiltinPtr&, const ErrorReporterPtr&, bool, const std::string&);
+
+    virtual DataPtr getMember(const std::string&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    void setValue(const std::string&);
+
+    DataFactoryPtr _factory;
+    Slice::BuiltinPtr _type;
+    std::string _value;
+    DataPtr _length;
+};
+typedef IceUtil::Handle<StringData> StringDataPtr;
+
+class ProxyData : public Data
+{
+public:
+
+    ProxyData(const Slice::TypePtr&, const Ice::CommunicatorPtr&, const ErrorReporterPtr&, bool);
+    ProxyData(const Slice::TypePtr&, const Ice::CommunicatorPtr&, const ErrorReporterPtr&, bool, const Ice::ObjectPrx&);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    Ice::ObjectPrx getValue() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    void transformI(const DataPtr&);
+    void setValue(const std::string&);
+
+    Slice::TypePtr _type; // Can be Builtin or Proxy
+    Ice::CommunicatorPtr _communicator;
+    Ice::ObjectPrx _value;
+    std::string _str;
+};
+typedef IceUtil::Handle<ProxyData> ProxyDataPtr;
+
+class StructData : public Data
+{
+public:
+
+    StructData(const DataFactoryPtr&, const Slice::StructPtr&, const ErrorReporterPtr&, bool);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual void destroy();
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    DataMemberMap getMembers() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    StructData(const Slice::StructPtr&, const ErrorReporterPtr&, bool, const DataMemberMap&);
+
+    void transformI(const DataPtr&, DataInterceptor&);
+
+    Slice::StructPtr _type;
+    DataMemberMap _members;
+};
+typedef IceUtil::Handle<StructData> StructDataPtr;
+
+class SequenceData : public Data
+{
+public:
+
+    SequenceData(const DataFactoryPtr&, const Slice::SequencePtr&, const ErrorReporterPtr&, bool);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    DataList getElements() const;
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    SequenceData(const DataFactoryPtr&, const Slice::SequencePtr&, const ErrorReporterPtr&, bool, const DataList&);
+
+    void transformI(const DataPtr&, DataInterceptor&);
+
+    DataFactoryPtr _factory;
+    Slice::SequencePtr _type;
+    DataList _elements;
+    DataPtr _length;
+};
+typedef IceUtil::Handle<SequenceData> SequenceDataPtr;
+
+class EnumData : public Data
+{
+public:
+
+    EnumData(const Slice::EnumPtr&, const ErrorReporterPtr&, bool);
+    EnumData(const Slice::EnumPtr&, const ErrorReporterPtr&, bool, Ice::Int);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    Ice::Int getValue() const;
+
+    bool setValue(Ice::Int);
+    bool setValueAsString(const std::string&);
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    void transformI(const DataPtr&, DataInterceptor&);
+
+    Slice::EnumPtr _type;
+    Ice::Int _value;
+    std::string _name;
+    Ice::Int _count;
+};
+typedef IceUtil::Handle<EnumData> EnumDataPtr;
+
+class DictionaryData : public Data
+{
+public:
+
+    DictionaryData(const DataFactoryPtr&, const Slice::DictionaryPtr&, const ErrorReporterPtr&, bool);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    DataMap getElements() const;
+    void put(const DataPtr&, const DataPtr&, DataInterceptor&, bool);
+    void remove(const DataPtr&);
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    DictionaryData(const DataFactoryPtr&, const Slice::DictionaryPtr&, const ErrorReporterPtr&, bool, const DataMap&);
+
+    void transformI(const DataPtr&, DataInterceptor&);
+
+    DataFactoryPtr _factory;
+    Slice::DictionaryPtr _type;
+    DataMap _map;
+    DataPtr _length;
+};
+typedef IceUtil::Handle<DictionaryData> DictionaryDataPtr;
+
+class ObjectData : public Data
+{
+public:
+
+    ObjectData(const DataFactoryPtr&, const Slice::TypePtr&, bool);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    void incRef();
+    void decRef();
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    void destroyI();
+
+    Slice::TypePtr _type; // Can be Builtin (Object) or ClassDecl
+    DataPtr _facetMap;
+    DataMemberMap _members;
+    Ice::ObjectPtr _marshaler;
+    Ice::Int _refCount;
+    DataPtr _id;
+
+    friend class ObjectWriter;
+    friend class ObjectReader;
+};
+
+class ObjectRef : public Data
+{
+public:
+
+    ObjectRef(const DataFactoryPtr&, const Slice::TypePtr&, bool);
+    ObjectRef(const DataFactoryPtr&, const Slice::TypePtr&, bool, const ObjectDataPtr&);
+
+    virtual DataPtr getMember(const std::string&) const;
+    virtual DataPtr getElement(const DataPtr&) const;
+
+    virtual bool operator==(const Data&) const;
+    virtual bool operator!=(const Data&) const;
+    virtual bool operator<(const Data&) const;
+
+    virtual void registerObjects(ObjectDataMap&) const;
+    virtual void transform(const DataPtr&, DataInterceptor&);
+    virtual void set(const DataPtr&, DataInterceptor&, bool);
+    virtual DataPtr clone() const;
+
+    virtual Slice::TypePtr getType() const;
+    virtual void destroy();
+
+    virtual void marshal(IceInternal::BasicStream&) const;
+    virtual void unmarshal(IceInternal::BasicStream&);
+
+    virtual bool booleanValue(bool = false) const;
+    virtual Ice::Long integerValue(bool = false) const;
+    virtual double doubleValue(bool = false) const;
+    virtual std::string stringValue(bool = false) const;
+    virtual std::string toString() const;
+
+    void instantiate();
+    void setValue(const ObjectDataPtr&);
+
+    virtual void printI(IceUtil::Output&, ObjectDataHistory&) const;
+
+private:
+
+    void transformI(const DataPtr&, DataInterceptor&);
+
+    DataFactoryPtr _factory;
+    Slice::TypePtr _type; // Formal type: can be Builtin (Object) or ClassDecl
+    ObjectDataPtr _value;
+};
+typedef IceUtil::Handle<ObjectRef> ObjectRefPtr;
+
+class ObjectFactory : public Ice::ObjectFactory
+{
+public:
+
+    ObjectFactory(const DataFactoryPtr&, const Slice::UnitPtr&);
+
+    virtual Ice::ObjectPtr create(const std::string&);
+    virtual void destroy();
+
+private:
+
+    DataFactoryPtr _factory;
+    Slice::UnitPtr _unit;
+};
+
+} // End of namespace Transform
+
+#endif
diff --git a/cpp/src/Transform/Error.cpp b/cpp/src/Transform/Error.cpp
new file mode 100644
index 00000000000..8f4e4290ae9
--- /dev/null
+++ b/cpp/src/Transform/Error.cpp
@@ -0,0 +1,192 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Error.h>
+#include <Transform/Exception.h>
+#include <Transform/TransformUtil.h>
+
+using namespace std;
+
+//
+// ErrorReporter
+//
+Transform::ErrorReporter::ErrorReporter(ostream& out) :
+    _out(out), _raise(true)
+{
+}
+
+ostream&
+Transform::ErrorReporter::stream() const
+{
+    return _out;
+}
+
+void
+Transform::ErrorReporter::warning(const string& msg)
+{
+    if(!_descName.empty())
+    {
+        _out << "warning in <" << _descName << "> descriptor, line " << _descLine << ": " << msg << endl;
+    }
+    else
+    {
+        _out << "warning: " << msg << endl;
+    }
+}
+
+void
+Transform::ErrorReporter::error(const string& msg)
+{
+    ostringstream ostr;
+    if(!_descName.empty())
+    {
+        ostr << "error in <" << _descName << "> descriptor, line " << _descLine << ": " << msg << endl;
+    }
+    else
+    {
+        ostr << "error: " << msg << endl;
+    }
+    throw TransformException(__FILE__, __LINE__, ostr.str());
+}
+
+void
+Transform::ErrorReporter::typeMismatchError(const Slice::TypePtr& expected, const Slice::TypePtr& received, bool fatal)
+{
+    ostringstream ostr;
+    ostr << "type mismatch: expected " << typeName(expected) << " but received " << typeName(received);
+
+    if(_raise || fatal)
+    {
+        error(ostr.str());
+    }
+    else
+    {
+        warning(ostr.str());
+    }
+}
+
+void
+Transform::ErrorReporter::conversionError(const string& value, const Slice::TypePtr& type)
+{
+    ostringstream ostr;
+    ostr << "unable to convert `" << value << "' to " << typeName(type);
+
+    if(_raise)
+    {
+        error(ostr.str());
+    }
+    else
+    {
+        warning(ostr.str());
+    }
+}
+
+void
+Transform::ErrorReporter::rangeError(const string& value, const Slice::TypePtr& type)
+{
+    ostringstream ostr;
+    ostr << "value `" << value << "' is out of range for type " << typeName(type);
+
+    if(_raise)
+    {
+        error(ostr.str());
+    }
+    else
+    {
+        warning(ostr.str());
+    }
+}
+
+void
+Transform::ErrorReporter::expressionSyntaxError(const string& msg)
+{
+    assert(!_expression.empty());
+    ostringstream ostr;
+    ostr << "syntax error in expression `" << _expression << "': " << msg;
+    error(ostr.str());
+}
+
+void
+Transform::ErrorReporter::descriptorError(const string& msg, int line)
+{
+    ostringstream ostr;
+    ostr << "XML error on line " << line << ":" << endl << msg;
+    error(ostr.str());
+}
+
+void
+Transform::ErrorReporter::setDescriptor(const string& name, int line)
+{
+    _descName = name;
+    _descLine = line;
+}
+
+void
+Transform::ErrorReporter::getDescriptor(string& name, int& line)
+{
+    name = _descName;
+    line = _descLine;
+}
+
+void
+Transform::ErrorReporter::clearDescriptor()
+{
+    _descName.clear();
+}
+
+void
+Transform::ErrorReporter::setExpression(const string& expr)
+{
+    _expression = expr;
+}
+
+void
+Transform::ErrorReporter::clearExpression()
+{
+    _expression.clear();
+}
+
+bool
+Transform::ErrorReporter::raise() const
+{
+    return _raise;
+}
+
+void
+Transform::ErrorReporter::raise(bool b)
+{
+    _raise = b;
+}
+
+//
+// DescriptorErrorContext
+//
+Transform::DescriptorErrorContext::DescriptorErrorContext(const ErrorReporterPtr& errorReporter, const string& name,
+                                                          int line) :
+    _errorReporter(errorReporter)
+{
+    //
+    // Save the existing descriptor information before changing it.
+    //
+    _errorReporter->getDescriptor(_name, _line);
+    _errorReporter->setDescriptor(name, line);
+}
+
+Transform::DescriptorErrorContext::~DescriptorErrorContext()
+{
+    //
+    // Restore the original descriptor information.
+    //
+    _errorReporter->setDescriptor(_name, _line);
+}
diff --git a/cpp/src/Transform/Error.h b/cpp/src/Transform/Error.h
new file mode 100644
index 00000000000..1908905202d
--- /dev/null
+++ b/cpp/src/Transform/Error.h
@@ -0,0 +1,75 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_ERROR_H
+#define TRANSFORM_ERROR_H
+
+#include <Slice/Parser.h>
+
+namespace Transform
+{
+
+class ErrorReporter : public IceUtil::SimpleShared
+{
+public:
+
+    ErrorReporter(std::ostream&);
+
+    std::ostream& stream() const;
+
+    void warning(const std::string&);
+    void error(const std::string&);
+    void typeMismatchError(const Slice::TypePtr&, const Slice::TypePtr&, bool);
+    void conversionError(const std::string&, const Slice::TypePtr&);
+    void rangeError(const std::string&, const Slice::TypePtr&);
+    void expressionSyntaxError(const std::string&);
+    void descriptorError(const std::string&, int);
+
+    void setDescriptor(const std::string&, int);
+    void getDescriptor(std::string&, int&);
+    void clearDescriptor();
+
+    void setExpression(const std::string&);
+    void clearExpression();
+
+    bool raise() const;
+    void raise(bool);
+
+private:
+
+    std::ostream& _out;
+    std::string _descName;
+    int _descLine;
+    std::string _expression;
+    bool _raise;
+};
+typedef IceUtil::Handle<ErrorReporter> ErrorReporterPtr;
+
+class DescriptorErrorContext
+{
+public:
+
+    DescriptorErrorContext(const ErrorReporterPtr&, const std::string&, int);
+    ~DescriptorErrorContext();
+
+private:
+
+    ErrorReporterPtr _errorReporter;
+    std::string _name;
+    int _line;
+};
+
+} // End of namespace Transform
+
+#endif
diff --git a/cpp/src/Transform/Exception.cpp b/cpp/src/Transform/Exception.cpp
new file mode 100644
index 00000000000..dc25832fa9c
--- /dev/null
+++ b/cpp/src/Transform/Exception.cpp
@@ -0,0 +1,60 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Exception.h>
+
+using namespace std;
+
+//
+// TransformException
+//
+Transform::TransformException::TransformException(const char* file, int line, const string& reason) :
+    IceUtil::Exception(file, line), _reason(reason)
+{
+}
+
+string
+Transform::TransformException::ice_name() const
+{
+    return "Transform::TransformException";
+}
+
+void
+Transform::TransformException::ice_print(ostream& out) const
+{
+    IceUtil::Exception::ice_print(out);
+    out << ":\nerror occurred during transformation";
+    if(!_reason.empty())
+    {
+        out << ":\n" << _reason;
+    }
+}
+
+IceUtil::Exception*
+Transform::TransformException::ice_clone() const
+{
+    return new TransformException(ice_file(), ice_line(), _reason);
+}
+
+void
+Transform::TransformException::ice_throw() const
+{
+    throw *this;
+}
+
+string
+Transform::TransformException::reason() const
+{
+    return _reason;
+}
diff --git a/cpp/src/Transform/Grammar.y b/cpp/src/Transform/Grammar.y
new file mode 100644
index 00000000000..089d5078f84
--- /dev/null
+++ b/cpp/src/Transform/Grammar.y
@@ -0,0 +1,264 @@
+%{
+
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/GrammarUtil.h>
+
+#ifdef _WIN32
+// I get these warnings from some bison versions:
+// warning C4102: 'yyoverflowlab' : unreferenced label
+#   pragma warning( disable : 4102 )
+// warning C4065: switch statement contains 'default' but no 'case' labels
+#   pragma warning( disable : 4065 )
+#endif
+
+using namespace std;
+using namespace Transform;
+
+void
+transform_error(const char* s)
+{
+    // yacc and recent versions of Bison use "syntax error" instead
+    // of "parse error".
+
+    if(strcmp(s, "parse error") == 0)
+    {
+        parseErrorReporter->expressionSyntaxError("syntax error");
+    }
+    else
+    {
+        parseErrorReporter->expressionSyntaxError(s);
+    }
+}
+
+%}
+
+%pure_parser
+%name_prefix="transform_"
+
+%token TOK_AND
+%token TOK_OR
+%token TOK_NOT
+%token TOK_ADD
+%token TOK_SUB
+%token TOK_MUL
+%token TOK_DIV
+%token TOK_MOD
+%token TOK_LPAREN
+%token TOK_RPAREN
+%token TOK_LBRACKET
+%token TOK_RBRACKET
+%token TOK_LESS_THAN
+%token TOK_GREATER_THAN
+%token TOK_LESS_EQUAL
+%token TOK_GREATER_EQUAL
+%token TOK_EQUAL
+%token TOK_TRUE
+%token TOK_FALSE
+%token TOK_NIL
+%token TOK_SCOPE_DELIMITER
+%token TOK_IDENTIFIER
+%token TOK_STRING_LITERAL
+%token TOK_INTEGER_LITERAL
+%token TOK_FLOATING_POINT_LITERAL
+
+%left TOK_OR
+%left TOK_AND
+%nonassoc TOK_LESS_THAN TOK_GREATER_THAN TOK_LESS_EQUAL TOK_GREATER_EQUAL TOK_EQUAL
+%left TOK_ADD TOK_SUB
+%left TOK_MUL TOK_DIV TOK_MOD
+%right UNARY_OP
+
+%%
+
+// ----------------------------------------------------------------------
+start
+// ----------------------------------------------------------------------
+: expr
+{
+    parseResult = $1;
+}
+;
+
+// ----------------------------------------------------------------------
+expr
+// ----------------------------------------------------------------------
+: binary
+{
+    $$ = $1;
+}
+;
+
+// ----------------------------------------------------------------------
+binary
+// ----------------------------------------------------------------------
+: binary TOK_LESS_THAN binary
+{
+    $$ = new BinaryNode(BinOpLess, parseDataFactory, $1, $3);
+}
+| binary TOK_GREATER_THAN binary
+{
+    $$ = new BinaryNode(BinOpGreater, parseDataFactory, $1, $3);
+}
+| binary TOK_LESS_EQUAL binary
+{
+    $$ = new BinaryNode(BinOpLessEq, parseDataFactory, $1, $3);
+}
+| binary TOK_GREATER_EQUAL binary
+{
+    $$ = new BinaryNode(BinOpGrEq, parseDataFactory, $1, $3);
+}
+| binary TOK_EQUAL binary
+{
+    $$ = new BinaryNode(BinOpEq, parseDataFactory, $1, $3);
+}
+| binary TOK_OR binary
+{
+    $$ = new BinaryNode(BinOpOr, parseDataFactory, $1, $3);
+}
+| binary TOK_AND binary
+{
+    $$ = new BinaryNode(BinOpAnd, parseDataFactory, $1, $3);
+}
+| binary TOK_MUL binary
+{
+    $$ = new BinaryNode(BinOpMul, parseDataFactory, $1, $3);
+}
+| binary TOK_DIV binary
+{
+    $$ = new BinaryNode(BinOpDiv, parseDataFactory, $1, $3);
+}
+| binary TOK_MOD binary
+{
+    $$ = new BinaryNode(BinOpMod, parseDataFactory, $1, $3);
+}
+| binary TOK_ADD binary
+{
+    $$ = new BinaryNode(BinOpAdd, parseDataFactory, $1, $3);
+}
+| binary TOK_SUB binary
+{
+    $$ = new BinaryNode(BinOpSub, parseDataFactory, $1, $3);
+}
+| unary
+{
+    $$ = $1;
+}
+;
+
+// ----------------------------------------------------------------------
+unary
+// ----------------------------------------------------------------------
+: TOK_LPAREN expr TOK_RPAREN
+{
+    $$ = $2;
+}
+| TOK_SUB unary       %prec UNARY_OP
+{
+    $$ = new UnaryNode(UnaryOpNeg, parseDataFactory, $2);
+}
+| TOK_NOT unary       %prec UNARY_OP
+{
+    $$ = new UnaryNode(UnaryOpNot, parseDataFactory, $2);
+}
+| TOK_INTEGER_LITERAL
+{
+    IntegerTokPtr intVal = IntegerTokPtr::dynamicCast($1);
+    assert(intVal);
+    $$ = new DataNode(parseDataFactory->createInteger(intVal->v, true));
+}
+| TOK_FLOATING_POINT_LITERAL
+{
+    FloatingTokPtr floatVal = FloatingTokPtr::dynamicCast($1);
+    assert(floatVal);
+    $$ = new DataNode(parseDataFactory->createDouble(floatVal->v, true));
+}
+| TOK_STRING_LITERAL
+{
+    StringTokPtr stringVal = StringTokPtr::dynamicCast($1);
+    assert(stringVal);
+    $$ = new DataNode(parseDataFactory->createString(stringVal->v, true));
+}
+| TOK_TRUE
+{
+    $$ = new DataNode(parseDataFactory->createBoolean(true, true));
+}
+| TOK_FALSE
+{
+    $$ = new DataNode(parseDataFactory->createBoolean(false, true));
+}
+| TOK_NIL
+{
+    $$ = new DataNode(parseDataFactory->createNil(true));
+}
+| identifier
+{
+    IdentifierTokPtr listVal = IdentifierTokPtr::dynamicCast($1);
+    assert(listVal);
+    $$ = new IdentNode(listVal->v);
+}
+| constant
+{
+    StringTokPtr stringVal = StringTokPtr::dynamicCast($1);
+    assert(stringVal);
+    $$ = new ConstantNode(stringVal->v);
+}
+;
+
+// ----------------------------------------------------------------------
+identifier
+// ----------------------------------------------------------------------
+: identifier '.' TOK_IDENTIFIER
+{
+    IdentifierTokPtr listVal = IdentifierTokPtr::dynamicCast($1);
+    assert(listVal);
+    StringTokPtr stringVal = StringTokPtr::dynamicCast($3);
+    assert(stringVal);
+    listVal->v.push_back(stringVal->v);
+    $$ = $1;
+}
+| TOK_IDENTIFIER
+{
+    StringTokPtr stringVal = StringTokPtr::dynamicCast($1);
+    assert(stringVal);
+    IdentifierTokPtr listVal = new IdentifierTok;
+    listVal->v.push_back(stringVal->v);
+    $$ = listVal;
+}
+;
+
+// ----------------------------------------------------------------------
+constant
+// ----------------------------------------------------------------------
+: constant TOK_SCOPE_DELIMITER TOK_IDENTIFIER
+{
+    StringTokPtr stringVal = StringTokPtr::dynamicCast($1);
+    assert(stringVal);
+    StringTokPtr idVal = StringTokPtr::dynamicCast($3);
+    assert(idVal);
+    stringVal->v.append("::" + idVal->v);
+    $$ = $1;
+}
+| TOK_SCOPE_DELIMITER TOK_IDENTIFIER
+{
+    StringTokPtr idVal = StringTokPtr::dynamicCast($2);
+    assert(idVal);
+    StringTokPtr stringVal = new StringTok;
+    stringVal->v.append("::" + idVal->v);
+    $$ = stringVal;
+}
+;
+
+%%
diff --git a/cpp/src/Transform/GrammarUtil.h b/cpp/src/Transform/GrammarUtil.h
new file mode 100644
index 00000000000..9c0d4389491
--- /dev/null
+++ b/cpp/src/Transform/GrammarUtil.h
@@ -0,0 +1,144 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef FREEZE_GRAMMAR_UTIL_H
+#define FREEZE_GRAMMAR_UTIL_H
+
+#include <Transform/Node.h>
+#include <Transform/Parser.h>
+
+namespace Transform
+{
+
+extern DataFactoryPtr parseDataFactory;
+extern ErrorReporterPtr parseErrorReporter;
+extern NodePtr parseResult;
+extern int parseLine;
+
+int getInput(char*, int);
+
+class StringTok;
+class IdentifierTok;
+class BoolTok;
+class IntegerTok;
+class FloatingTok;
+
+typedef ::IceUtil::Handle<StringTok> StringTokPtr;
+typedef ::IceUtil::Handle<IdentifierTok> IdentifierTokPtr;
+typedef ::IceUtil::Handle<BoolTok> BoolTokPtr;
+typedef ::IceUtil::Handle<IntegerTok> IntegerTokPtr;
+typedef ::IceUtil::Handle<FloatingTok> FloatingTokPtr;
+
+// ----------------------------------------------------------------------
+// Token
+// ----------------------------------------------------------------------
+
+class Token : public Node
+{
+public:
+
+    Token() { }
+    virtual DataPtr evaluate(SymbolTable&) { return 0; }
+    virtual void print(std::ostream&) const {}
+};
+
+// ----------------------------------------------------------------------
+// StringTok
+// ----------------------------------------------------------------------
+
+class StringTok : public Token
+{
+public:
+
+    StringTok() { }
+
+    std::string v;
+};
+
+// ----------------------------------------------------------------------
+// IdentifierTok
+// ----------------------------------------------------------------------
+
+class IdentifierTok : public Token
+{
+public:
+
+    IdentifierTok() { }
+    Identifier v;
+};
+
+// ----------------------------------------------------------------------
+// BoolTok
+// ----------------------------------------------------------------------
+
+class BoolTok : public Token
+{
+public:
+
+    BoolTok() { }
+    bool v;
+};
+
+// ----------------------------------------------------------------------
+// IntegerTok
+// ----------------------------------------------------------------------
+
+class IntegerTok : public Token
+{
+public:
+
+    IntegerTok() { }
+    IceUtil::Int64 v;
+};
+
+// ----------------------------------------------------------------------
+// FloatingTok
+// ----------------------------------------------------------------------
+
+class FloatingTok : public Token
+{
+public:
+
+    FloatingTok() { }
+    double v;
+};
+
+} // End of namespace Transform
+
+//
+// Stuff for flex and bison
+//
+
+#define YYSTYPE Transform::NodePtr
+#define YY_DECL int transform_lex(YYSTYPE* yylvalp)
+YY_DECL;
+int transform_parse();
+
+//
+// I must set the initial stack depth to the maximum stack depth to
+// disable bison stack resizing. The bison stack resizing routines use
+// simple malloc/alloc/memcpy calls, which do not work for the
+// YYSTYPE, since YYSTYPE is a C++ type, with constructor, destructor,
+// assignment operator, etc.
+//
+#define YYMAXDEPTH  20000 // 20000 should suffice. Bison default is 10000 as maximum.
+#define YYINITDEPTH YYMAXDEPTH // Initial depth is set to max depth, for the reasons described above.
+
+//
+// Newer bison versions allow to disable stack resizing by defining
+// yyoverflow.
+//
+#define yyoverflow(a, b, c, d, e, f) transform_error(a)
+
+#endif
diff --git a/cpp/src/Transform/Makefile b/cpp/src/Transform/Makefile
new file mode 100644
index 00000000000..2ee037204cb
--- /dev/null
+++ b/cpp/src/Transform/Makefile
@@ -0,0 +1,74 @@
+# **********************************************************************
+#
+# Copyright (c) 2003
+# ZeroC, Inc.
+# Billerica, MA, USA
+#
+# All Rights Reserved.
+#
+# Ice is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License version 2 as published by
+# the Free Software Foundation.
+#
+# **********************************************************************
+
+top_srcdir	= ../..
+
+LIBFILENAME     = $(call mklibfilename,Transform,$(VERSION))
+SONAME          = $(call mksoname,Transform,$(SOVERSION))  
+LIBNAME		= $(call mklibname,Transform)
+
+TRANSFORMDB	= $(top_srcdir)/bin/transformdb
+
+TARGETS		= $(libdir)/$(LIBFILENAME) $(libdir)/$(SONAME) $(libdir)/$(LIBNAME) $(TRANSFORMDB)
+
+OBJS		= Grammar.o \
+                  Scanner.o \
+		  Analyzer.o \
+		  Transformer.o \
+		  Data.o \
+		  Error.o \
+		  Exception.o \
+                  Node.o \
+                  TransformUtil.o \
+                  Parser.o
+
+TRANSFORM_OBJS	= TransformDB.o
+
+SRCS		= $(OBJS:.o=.cpp) $(TRANSFORM_OBJS:.o=.cpp)
+
+HDIR		= $(includedir)/Transform
+
+include $(top_srcdir)/config/Make.rules
+
+CPPFLAGS	:= -I.. $(CPPFLAGS) -DTRANSFORM_API_EXPORTS $(DB_FLAGS) 
+
+$(libdir)/$(LIBFILENAME): $(OBJS)
+	rm -f $@
+	$(call mkshlib,$@,$(SONAME),$(OBJS),$(LINKWITH))
+
+$(libdir)/$(SONAME): $(libdir)/$(LIBFILENAME)
+	rm -f $@
+	ln -s $(LIBFILENAME) $@
+
+$(libdir)/$(LIBNAME): $(libdir)/$(SONAME)
+	rm -f $@
+	ln -s $(SONAME) $@
+
+$(TRANSFORMDB): $(TRANSFORM_OBJS)
+	rm -f $@
+	$(CXX) $(LDFLAGS) -o $@ $(TRANSFORM_OBJS) -lTransform -lSlice -lIceXML $(LIBS) $(DB_LIBS)
+
+clean::
+	rm -f Grammar.cpp Grammar.h
+	rm -f Scanner.cpp
+
+install:: all
+	$(INSTALL_LIBRARY) $(libdir)/$(LIBFILENAME) $(install_libdir)
+	rm -f $(install_libdir)/$(SONAME)
+	ln -s $(LIBFILENAME) $(install_libdir)/$(SONAME)
+	rm -f $(install_libdir)/$(LIBNAME)
+	ln -s $(SONAME) $(install_libdir)/$(LIBNAME)
+	$(INSTALL_PROGRAM) $(TRANSFORMDB) $(install_bindir)
+
+include .depend
diff --git a/cpp/src/Transform/Node.cpp b/cpp/src/Transform/Node.cpp
new file mode 100644
index 00000000000..0c4948f72dd
--- /dev/null
+++ b/cpp/src/Transform/Node.cpp
@@ -0,0 +1,464 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Node.h>
+
+using namespace std;
+
+ostream&
+operator<<(ostream& os, const Transform::Identifier& id)
+{
+    for(Transform::Identifier::const_iterator p = id.begin(); p != id.end(); ++p)
+    {
+        if(p != id.begin())
+        {
+            os << '.';
+        }
+        os << *p;
+    }
+    return os;
+}
+
+//
+// EvaluateException
+//
+Transform::EvaluateException::EvaluateException(const char* file, int line, const string& reason) :
+    IceUtil::Exception(file, line), _reason(reason)
+{
+}
+
+string
+Transform::EvaluateException::ice_name() const
+{
+    return "Transform::EvaluateException";
+}
+
+void
+Transform::EvaluateException::ice_print(ostream& out) const
+{
+    IceUtil::Exception::ice_print(out);
+    out << ":\nerror occurred while evaluating expression";
+    if(!_reason.empty())
+    {
+        out << ":\n" << _reason;
+    }
+}
+
+IceUtil::Exception*
+Transform::EvaluateException::ice_clone() const
+{
+    return new EvaluateException(ice_file(), ice_line(), _reason);
+}
+
+void
+Transform::EvaluateException::ice_throw() const
+{
+    throw *this;
+}
+
+string
+Transform::EvaluateException::reason() const
+{
+    return _reason;
+}
+
+//
+// SymbolTable
+//
+Transform::SymbolTable::~SymbolTable()
+{
+}
+
+//
+// Node
+//
+Transform::Node::~Node()
+{
+}
+
+//
+// BinaryNode
+//
+Transform::BinaryNode::BinaryNode(BinaryOperator op, const DataFactoryPtr& factory, const NodePtr& left,
+                                  const NodePtr& right) :
+    _op(op), _factory(factory), _left(left), _right(right)
+{
+}
+
+Transform::DataPtr
+Transform::BinaryNode::evaluate(SymbolTable& st)
+{
+    DataPtr result;
+
+    switch(_op)
+    {
+    case BinOpOr:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        if(leftValue->booleanValue())
+        {
+            result = leftValue;
+        }
+        else
+        {
+            result = _right->evaluate(st);
+        }
+        break;
+    }
+
+    case BinOpAnd:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        if(!leftValue->booleanValue())
+        {
+            result = leftValue;
+        }
+        else
+        {
+            result = _right->evaluate(st);
+        }
+        break;
+    }
+
+    case BinOpMul:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        IntegerDataPtr ileft = IntegerDataPtr::dynamicCast(leftValue);
+        IntegerDataPtr iright = IntegerDataPtr::dynamicCast(rightValue);
+        if(ileft && iright)
+        {
+            result = _factory->createInteger(leftValue->integerValue() * rightValue->integerValue(), true);
+        }
+        else
+        {
+            result = _factory->createDouble(leftValue->doubleValue(true) * rightValue->doubleValue(true), true);
+        }
+        break;
+    }
+
+    case BinOpDiv:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        IntegerDataPtr ileft = IntegerDataPtr::dynamicCast(leftValue);
+        IntegerDataPtr iright = IntegerDataPtr::dynamicCast(rightValue);
+        if(ileft && iright)
+        {
+            result = _factory->createInteger(leftValue->integerValue() / rightValue->integerValue(), true);
+        }
+        else
+        {
+            result = _factory->createDouble(leftValue->doubleValue(true) / rightValue->doubleValue(true), true);
+        }
+        break;
+    }
+
+    case BinOpMod:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        result = _factory->createInteger(leftValue->integerValue() % rightValue->integerValue(), true);
+        break;
+    }
+
+    case BinOpAdd:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        IntegerDataPtr ileft = IntegerDataPtr::dynamicCast(leftValue);
+        IntegerDataPtr iright = IntegerDataPtr::dynamicCast(rightValue);
+        if(ileft && iright)
+        {
+            result = _factory->createInteger(leftValue->integerValue() + rightValue->integerValue(), true);
+        }
+        else
+        {
+            result = _factory->createDouble(leftValue->doubleValue(true) + rightValue->doubleValue(true), true);
+        }
+        break;
+    }
+
+    case BinOpSub:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        IntegerDataPtr ileft = IntegerDataPtr::dynamicCast(leftValue);
+        IntegerDataPtr iright = IntegerDataPtr::dynamicCast(rightValue);
+        if(ileft && iright)
+        {
+            result = _factory->createInteger(leftValue->integerValue() - rightValue->integerValue(), true);
+        }
+        else
+        {
+            result = _factory->createDouble(leftValue->doubleValue(true) - rightValue->doubleValue(true), true);
+        }
+        break;
+    }
+
+    case BinOpLess:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        bool b = leftValue < rightValue;
+        result = _factory->createBoolean(b, true);
+        break;
+    }
+
+    case BinOpGreater:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        bool b = (leftValue < rightValue) || (leftValue == rightValue);
+        result = _factory->createBoolean(!b, true);
+        break;
+    }
+
+    case BinOpLessEq:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        bool b = (leftValue < rightValue) || (leftValue == rightValue);
+        result = _factory->createBoolean(b, true);
+        break;
+    }
+
+    case BinOpGrEq:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        bool b = leftValue < rightValue;
+        result = _factory->createBoolean(!b, true);
+        break;
+    }
+
+    case BinOpEq:
+    {
+        DataPtr leftValue = _left->evaluate(st);
+        DataPtr rightValue = _right->evaluate(st);
+        bool b = leftValue == rightValue;
+        result = _factory->createBoolean(b, true);
+        break;
+    }
+    }
+
+    if(!result)
+    {
+        throw EvaluateException(__FILE__, __LINE__, "invalid operands to operator " + opToString(_op));
+    }
+
+    return result;
+}
+
+void
+Transform::BinaryNode::print(ostream& os) const
+{
+    os << opToString(_op) << ": left=";
+    _left->print(os);
+    os << ", right=";
+    _right->print(os);
+}
+
+string
+Transform::BinaryNode::opToString(BinaryOperator op)
+{
+    switch(op)
+    {
+    case BinOpOr:
+        return "OR";
+
+    case BinOpAnd:
+        return "AND";
+
+    case BinOpMul:
+        return "*";
+
+    case BinOpDiv:
+        return "/";
+
+    case BinOpMod:
+        return "%";
+
+    case BinOpAdd:
+        return "+";
+
+    case BinOpSub:
+        return "-";
+
+    case BinOpLess:
+        return "<";
+
+    case BinOpGreater:
+        return ">";
+
+    case BinOpLessEq:
+        return "<=";
+
+    case BinOpGrEq:
+        return ">=";
+
+    case BinOpEq:
+        return "==";
+    }
+
+    assert(false);
+    return string();
+}
+
+//
+// UnaryNode
+//
+Transform::UnaryNode::UnaryNode(UnaryOperator op, const DataFactoryPtr& factory, const NodePtr& right) :
+    _op(op), _factory(factory), _right(right)
+{
+}
+
+Transform::DataPtr
+Transform::UnaryNode::evaluate(SymbolTable& st)
+{
+    DataPtr result;
+
+    switch(_op)
+    {
+    case UnaryOpNeg:
+    {
+        DataPtr rightValue = _right->evaluate(st);
+        IntegerDataPtr iright = IntegerDataPtr::dynamicCast(rightValue);
+        if(iright)
+        {
+            result = _factory->createInteger(-rightValue->integerValue(), true);
+        }
+        else
+        {
+            result = _factory->createDouble(-rightValue->doubleValue(), true);
+        }
+        break;
+    }
+
+    case UnaryOpNot:
+    {
+        DataPtr rightValue = _right->evaluate(st);
+        result = _factory->createBoolean(!rightValue->booleanValue(), true);
+        break;
+    }
+    }
+
+    if(!result)
+    {
+        throw EvaluateException(__FILE__, __LINE__, "invalid operand to operator " + opToString(_op));
+    }
+
+    return result;
+}
+
+void
+Transform::UnaryNode::print(ostream& os) const
+{
+    os << opToString(_op) << ": right=";
+    _right->print(os);
+}
+
+string
+Transform::UnaryNode::opToString(UnaryOperator op)
+{
+    switch(op)
+    {
+    case UnaryOpNeg:
+        return "-";
+
+    case UnaryOpNot:
+        return "!";
+    }
+
+    assert(false);
+    return string();
+}
+
+//
+// DataNode
+//
+Transform::DataNode::DataNode(const DataPtr& data) :
+    _data(data)
+{
+}
+
+Transform::DataPtr
+Transform::DataNode::evaluate(SymbolTable&)
+{
+    return _data;
+}
+
+void
+Transform::DataNode::print(ostream& os) const
+{
+    _data->print(os);
+}
+
+//
+// IdentNode
+//
+Transform::IdentNode::IdentNode(const Identifier& value) :
+    _value(value)
+{
+}
+
+Transform::DataPtr
+Transform::IdentNode::evaluate(SymbolTable& st)
+{
+    DataPtr result = st.getValue(_value);
+    if(!result)
+    {
+        ostringstream ostr;
+        print(ostr);
+        throw EvaluateException(__FILE__, __LINE__, "unknown identifier `" + ostr.str() + "'");
+    }
+    return result;
+}
+
+void
+Transform::IdentNode::print(ostream& os) const
+{
+    os << _value;
+}
+
+Transform::Identifier
+Transform::IdentNode::getValue() const
+{
+    return _value;
+}
+
+//
+// ConstantNode
+//
+Transform::ConstantNode::ConstantNode(const string& value) :
+    _value(value)
+{
+}
+
+Transform::DataPtr
+Transform::ConstantNode::evaluate(SymbolTable& st)
+{
+    DataPtr result = st.getConstantValue(_value);
+    if(!result)
+    {
+        throw EvaluateException(__FILE__, __LINE__, "unknown constant `" + _value + "'");
+    }
+    return result;
+}
+
+void
+Transform::ConstantNode::print(ostream& os) const
+{
+    os << _value;
+}
diff --git a/cpp/src/Transform/Node.h b/cpp/src/Transform/Node.h
new file mode 100644
index 00000000000..860448b8017
--- /dev/null
+++ b/cpp/src/Transform/Node.h
@@ -0,0 +1,166 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_NODE_H
+#define TRANSFORM_NODE_H
+
+#include <Transform/Data.h>
+
+namespace Transform
+{
+
+class Node;
+typedef IceUtil::Handle<Node> NodePtr;
+
+typedef std::vector<std::string> Identifier;
+
+class EvaluateException : public IceUtil::Exception
+{
+public:
+    
+    EvaluateException(const char*, int, const std::string&);
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual IceUtil::Exception* ice_clone() const;
+    virtual void ice_throw() const;
+    std::string reason() const;
+
+private:
+
+    std::string _reason;
+};
+
+class SymbolTable
+{
+public:
+
+    virtual ~SymbolTable();
+
+    virtual DataPtr getValue(const Identifier&) const = 0;
+    virtual DataPtr getConstantValue(const std::string&) const = 0;
+};
+
+class Node : public IceUtil::SimpleShared
+{
+public:
+
+    virtual ~Node();
+
+    virtual DataPtr evaluate(SymbolTable&) = 0;
+
+    virtual void print(std::ostream&) const = 0;
+};
+
+enum BinaryOperator
+{
+    BinOpOr, BinOpAnd,
+    BinOpMul, BinOpDiv, BinOpMod,
+    BinOpAdd, BinOpSub,
+    BinOpLess, BinOpGreater, BinOpLessEq, BinOpGrEq, BinOpEq
+};
+
+class BinaryNode : public Node
+{
+public:
+
+    BinaryNode(BinaryOperator, const DataFactoryPtr&, const NodePtr&, const NodePtr&);
+
+    virtual DataPtr evaluate(SymbolTable&);
+
+    virtual void print(std::ostream&) const;
+
+private:
+
+    static std::string opToString(BinaryOperator);
+
+    BinaryOperator _op;
+    DataFactoryPtr _factory;
+    NodePtr _left;
+    NodePtr _right;
+};
+
+enum UnaryOperator { UnaryOpNeg, UnaryOpNot };
+
+class UnaryNode : public Node
+{
+public:
+
+    UnaryNode(UnaryOperator, const DataFactoryPtr&, const NodePtr&);
+
+    virtual DataPtr evaluate(SymbolTable&);
+
+    virtual void print(std::ostream&) const;
+
+private:
+
+    static std::string opToString(UnaryOperator);
+
+    UnaryOperator _op;
+    DataFactoryPtr _factory;
+    NodePtr _right;
+};
+
+class DataNode : public Node
+{
+public:
+
+    DataNode(const DataPtr&);
+
+    virtual DataPtr evaluate(SymbolTable&);
+
+    virtual void print(std::ostream&) const;
+
+private:
+
+    DataPtr _data;
+};
+
+class IdentNode : public Node
+{
+public:
+
+    IdentNode(const Identifier&);
+
+    virtual DataPtr evaluate(SymbolTable&);
+
+    virtual void print(std::ostream&) const;
+
+    Identifier getValue() const;
+
+private:
+
+    Identifier _value;
+};
+typedef IceUtil::Handle<IdentNode> IdentNodePtr;
+
+class ConstantNode : public Node
+{
+public:
+
+    ConstantNode(const std::string&);
+
+    virtual DataPtr evaluate(SymbolTable&);
+
+    virtual void print(std::ostream&) const;
+
+private:
+
+    std::string _value;
+};
+
+} // End of namespace Transform
+
+std::ostream& operator<<(std::ostream&, const Transform::Identifier&);
+
+#endif
diff --git a/cpp/src/Transform/Parser.cpp b/cpp/src/Transform/Parser.cpp
new file mode 100644
index 00000000000..e7a551339cb
--- /dev/null
+++ b/cpp/src/Transform/Parser.cpp
@@ -0,0 +1,75 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Parser.h>
+#include <Transform/GrammarUtil.h>
+#include <IceUtil/Mutex.h>
+
+using namespace std;
+
+Transform::DataFactoryPtr Transform::parseDataFactory;
+Transform::ErrorReporterPtr Transform::parseErrorReporter;
+Transform::NodePtr Transform::parseResult;
+int Transform::parseLine;
+
+static string _input;
+static string::size_type _pos;
+static IceUtil::Mutex _parserMutex;
+
+//
+// Parser
+//
+Transform::NodePtr
+Transform::Parser::parse(const string& expr, const DataFactoryPtr& factory, const ErrorReporterPtr& errorReporter)
+{
+    //
+    // The bison grammar is not thread-safe.
+    //
+    IceUtil::Mutex::Lock sync(_parserMutex);
+
+    parseDataFactory = factory;
+    parseErrorReporter = errorReporter;
+    parseLine = 1;
+
+    parseErrorReporter->setExpression(expr);
+
+    _input = expr;
+    _pos = 0;
+
+    int status = transform_parse();
+    if(status != 0)
+    {
+        parseResult = 0;
+    }
+
+    parseErrorReporter->clearExpression();
+    parseErrorReporter = 0;
+
+    return parseResult;
+}
+
+int
+Transform::getInput(char* buf, int maxSize)
+{
+    if(_pos < _input.length())
+    {
+        buf[0] = _input[_pos];
+        _pos++;
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
diff --git a/cpp/src/Transform/Parser.h b/cpp/src/Transform/Parser.h
new file mode 100644
index 00000000000..c7791252cf2
--- /dev/null
+++ b/cpp/src/Transform/Parser.h
@@ -0,0 +1,33 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_PARSER_H
+#define TRANSFORM_PARSER_H
+
+#include <Transform/Node.h>
+#include <string>
+
+namespace Transform
+{
+
+class Parser
+{
+public:
+
+    static NodePtr parse(const std::string&, const DataFactoryPtr&, const ErrorReporterPtr&);
+};
+
+} // End of namespace Transform
+
+#endif
diff --git a/cpp/src/Transform/Scanner.l b/cpp/src/Transform/Scanner.l
new file mode 100644
index 00000000000..b870db79ff9
--- /dev/null
+++ b/cpp/src/Transform/Scanner.l
@@ -0,0 +1,375 @@
+%{
+
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/GrammarUtil.h>        // Before Grammar.h, so that YYSTYPE is defined
+#include <Transform/Grammar.h>
+#include <IceUtil/InputUtil.h>
+
+#include <stdlib.h>
+#include <math.h>
+
+#include <map>
+
+#ifdef _WIN32
+    // I get these warnings from some flex versions:
+    // warning C4003: not enough actual parameters for macro 'yywrap'
+#   pragma warning( disable : 4003 )
+#endif
+
+using namespace std;
+using namespace Transform;
+
+namespace Transform
+{
+
+typedef map<string, int> KeywordMap;
+static KeywordMap keywordMap;
+
+void initScanner();
+int checkKeyword(const string&);
+StringTokPtr parseString(char);
+
+}
+
+#define        YY_USER_INIT initScanner();
+
+#define        YY_INPUT(buf, result, max_size) { result = getInput(buf, max_size); }
+%}
+
+%option noyywrap
+%option never-interactive
+%option prefix="transform_"
+%option outfile="lex.yy.c"
+
+identifier              [[:alpha:]_][[:alnum:]_]*
+integer_constant        (\+|-)?((0[0-7]+)|(0x[[:xdigit:]]+)|([[:digit:]]+))
+fractional_constant     ([[:digit:]]*\.[[:digit:]]+)|([[:digit:]]+\.)
+exponent_part           (e|E)(\+|-)?[[:digit:]]+
+floating_literal        (({fractional_constant}{exponent_part}?)|([[:digit:]]+{exponent_part}))[fF]?
+
+%%
+
+"//" {
+    // C++-style comment
+    int c;
+    do
+    {
+        c = yyinput();
+        if(c == '\n')
+        {
+            parseLine++;
+        }
+    }
+    while(c != '\n' && c != EOF);
+}
+
+"/*" {
+    // C-style comment
+    while(true)
+    {
+        int c = yyinput();
+        if(c == '\n')
+        {
+            parseLine++;
+        }
+        else if(c == '*')
+        {
+            int next = yyinput();
+            if(next == '/')
+            {
+                break;
+            }
+            else
+            {
+                unput(next);
+            }
+        }
+        else if(c == EOF)
+        {
+            parseErrorReporter->expressionSyntaxError("EOF in comment");
+            break;
+        }
+    }
+}
+
+{identifier} {
+    StringTokPtr ident = new StringTok;
+    ident->v = yytext;
+    *yylvalp = ident;
+    return checkKeyword(ident->v);
+}
+
+\" {
+    StringTokPtr str = parseString('"');
+    *yylvalp = str;
+    return TOK_STRING_LITERAL;
+}
+
+\' {
+    StringTokPtr str = parseString('\'');
+    *yylvalp = str;
+    return TOK_STRING_LITERAL;
+}
+
+{integer_constant} {
+    IntegerTokPtr itp = new IntegerTok;
+    *yylvalp = itp;
+    errno = 0;
+    itp->v = IceUtil::strToInt64(yytext, 0, 0);
+    if(errno == ERANGE && (itp->v == IceUtil::Int64Min || itp->v == IceUtil::Int64Max))
+    {
+        string msg = "integer constant `";
+        msg += yytext;
+        msg += "' out of range";
+        parseErrorReporter->expressionSyntaxError(msg);
+    }
+    return TOK_INTEGER_LITERAL;
+}
+
+{floating_literal} {
+    errno = 0;
+    FloatingTokPtr ftp = new FloatingTok;
+    *yylvalp = ftp;
+    string literal(yytext);
+    char lastChar = literal[literal.size() - 1];
+    if(lastChar == 'f' || lastChar == 'F')
+    {
+        literal = literal.substr(0, literal.size() - 1);        // Clobber trailing 'f' or 'F' suffix
+    }
+    ftp->v = strtod(literal.c_str(), 0);
+    if((ftp->v == HUGE_VAL || ftp->v == -HUGE_VAL) && errno == ERANGE)
+    {
+        string msg = "floating-point constant `";
+        msg += yytext;
+        msg += "' too large (overflow)";
+        parseErrorReporter->expressionSyntaxError(msg);
+    }
+    else if(ftp->v == 0 && errno == ERANGE)
+    {
+        string msg = "floating-point constant `";
+        msg += yytext;
+        msg += "' too small (underflow)";
+        parseErrorReporter->expressionSyntaxError(msg);
+    }
+    return TOK_FLOATING_POINT_LITERAL;
+}
+
+[[:space:]] {
+    // Igore white-space
+    
+    if(yytext[0] == '\n')
+    {
+        parseLine++;
+    }
+}
+
+"<"     return TOK_LESS_THAN;
+">"     return TOK_GREATER_THAN;
+"<="    return TOK_LESS_EQUAL;
+">="    return TOK_GREATER_EQUAL;
+"=="    return TOK_EQUAL;
+"+"     return TOK_ADD;
+"-"     return TOK_SUB;
+"*"     return TOK_MUL;
+"/"     return TOK_DIV;
+"%"     return TOK_MOD;
+"("     return TOK_LPAREN;
+")"     return TOK_RPAREN;
+"["     return TOK_LBRACKET;
+"]"     return TOK_RBRACKET;
+"::"    return TOK_SCOPE_DELIMITER;
+
+. {
+    return yytext[0];
+}
+
+%%
+
+namespace Transform
+{
+
+void
+initScanner()
+{
+    keywordMap["true"] = TOK_TRUE;
+    keywordMap["false"] = TOK_FALSE;
+    keywordMap["and"] = TOK_AND;
+    keywordMap["or"] = TOK_OR;
+    keywordMap["not"] = TOK_NOT;
+    keywordMap["nil"] = TOK_NIL;
+}
+
+int
+checkKeyword(const string& id)
+{
+    KeywordMap::const_iterator pos = keywordMap.find(id);
+    if(pos != keywordMap.end())
+    {
+        return pos->second;
+    }
+    return TOK_IDENTIFIER;
+}
+
+StringTokPtr
+parseString(char start)
+{
+    StringTokPtr str = new StringTok;
+    while(true)
+    {
+        char c = static_cast<char>(yyinput());
+        if(c == start)
+        {
+            break;
+        }
+        else if(c == EOF)
+        {
+            parseErrorReporter->expressionSyntaxError("EOF in string");
+            break;
+        }
+        else if(c == '\n')
+        {
+            parseErrorReporter->expressionSyntaxError("newline in string");
+        }
+        else if(c == '\\')
+        {
+            char next = static_cast<char>(yyinput());
+            switch(next)
+            {
+                case '\\':
+                case '"':
+                case '\'':
+                {
+                    str->v += next;
+                    break;
+                }
+            
+                case 'n':
+                {
+                    str->v += '\n';
+                    break;
+                }
+            
+                case 'r':
+                {
+                    str->v += '\r';
+                    break;
+                }
+
+                case 't':
+                {
+                    str->v += '\t';
+                    break;
+                }
+            
+                case 'v':
+                {
+                    str->v += '\v';
+                    break;
+                }
+            
+                case 'f':
+                {
+                    str->v += '\f';
+                    break;
+                }
+
+                case 'a':
+                {
+                    str->v += '\a';
+                    break;
+                }
+
+                case 'b':
+                {
+                    str->v += '\b';
+                    break;
+                }
+
+                case '?':
+                {
+                    str->v += '\?';
+                    break;
+                }
+
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                {
+                    static string octalDigits = "01234567";
+                    unsigned short us = next - '0';
+                    if(octalDigits.find_first_of(next = static_cast<char>(yyinput())) != string::npos)
+                    {
+                        us = us * 8 + next - '0';
+                        if(octalDigits.find_first_of(next = static_cast<char>(yyinput())) != string::npos)
+                        {
+                            us = us * 8 + next - '0';
+                        }
+                        else
+                        {
+                            unput(next);
+                        }
+                    }
+                    else
+                    {
+                            unput(next);
+                    }
+                    str->v += static_cast<char>(us);
+                    break;
+                }
+                case 'x':
+                {
+                    IceUtil::Int64 ull = 0;
+                    while(isxdigit(next = static_cast<char>(yyinput())))
+                    {
+                        ull *= 16;
+                        if(isdigit(next))
+                        {
+                            ull += next - '0';
+                        }
+                        else if(islower(next))
+                        {
+                            ull += next - 'a' + 10;
+                        }
+                        else
+                        {
+                            ull += next - 'A' + 10;
+                        }
+                    }
+                    unput(next);
+                    str->v += static_cast<char>(ull);
+                    break;
+                }
+        
+                // TODO: add universal character names
+            
+                default:
+                {
+                    str->v += c;
+                    unput(next);
+                }
+            }
+        }
+        else
+        {
+            str->v += c;
+        }
+    }
+
+    return str;
+}
+
+} // End of namespace Transform
diff --git a/cpp/src/Transform/TransformDB.cpp b/cpp/src/Transform/TransformDB.cpp
new file mode 100644
index 00000000000..5fd6e75fa77
--- /dev/null
+++ b/cpp/src/Transform/TransformDB.cpp
@@ -0,0 +1,563 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Slice/Preprocessor.h>
+#include <Transform/Transformer.h>
+#include <Transform/TransformUtil.h>
+#include <db_cxx.h>
+#include <sys/stat.h>
+#include <fstream>
+#include <algorithm>
+
+using namespace std;
+
+#ifdef _WIN32
+#   define TRANSFORM_DB_MODE 0
+#else
+#   define TRANSFORM_DB_MODE (S_IRUSR | S_IWUSR)
+#endif
+
+static void
+usage(const char* n)
+{
+    cerr << "Usage: " << n << " [options] [dbenv db newdb]\n";
+    cerr <<
+        "Options:\n"
+        "-h, --help            Show this message.\n"
+        "-v, --version         Display the Ice version.\n"
+        "-DNAME                Define NAME as 1.\n"
+        "-DNAME=DEF            Define NAME as DEF.\n"
+        "-UNAME                Remove any definition for NAME.\n"
+        "-IDIR                 Put DIR in the include file search path.\n"
+        "-d, --debug           Print debug messages.\n"
+        "--ice                 Permit `Ice' prefix (for building Ice source code only)\n"
+        "-o FILE               Output transformation descriptors into the file FILE.\n"
+        "                      Database transformation is not performed.\n"
+        "-i                    Ignore incompatible type changes.\n"
+        "-f FILE               Execute the transformation descriptors in the file FILE.\n"
+        "                      Database transformation is not performed.\n"
+        "--old SLICE           Load old Slice definitions from the file SLICE.\n"
+        "--new SLICE           Load new Slice definitions from the file SLICE.\n"
+        "-e                    Indicates the database is an Evictor database.\n"
+        "--key TYPE[,TYPE]     Specifies the Slice types of the database key. If the\n"
+        "                      type names have not changed, only one needs to be\n"
+        "                      specified. Otherwise, the type names are specified as\n"
+        "                      old-type,new-type.\n"
+        "--value TYPE[,TYPE]   Specifies the Slice types of the database value. If the\n"
+        "                      type names have not changed, only one needs to be\n"
+        "                      specified. Otherwise, the type names are specified as\n"
+        "                      old-type,new-type.\n"
+        ;
+    // Note: --case-sensitive is intentionally not shown here!
+}
+
+static bool
+parseSlice(const string& n, const Slice::UnitPtr& u, const vector<string>& files, const string& cppArgs, bool debug)
+{
+    //
+    // Parse the Slice files.
+    //
+    for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
+    {
+        Slice::Preprocessor icecpp(n, *p, cppArgs);
+
+        FILE* cppHandle = icecpp.preprocess(false);
+
+        if(cppHandle == 0)
+        {
+            return false;
+        }
+
+        int status = u->parse(cppHandle, debug);
+
+        if(!icecpp.close())
+        {
+            return false;            
+        }
+
+        if(status != EXIT_SUCCESS)
+        {
+            return false;
+        }
+    }
+
+    u->mergeModules();
+
+    return true;
+}
+
+static int
+run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
+{
+    string cppArgs;
+    vector<string> includePaths;
+    bool debug = false;
+    bool ice = false;
+    bool caseSensitive = false;
+    string outputFile;
+    bool ignoreTypeChanges = false;
+    string inputFile;
+    vector<string> oldSlice;
+    vector<string> newSlice;
+    bool evictor = false;
+    string keyTypeNames;
+    string valueTypeNames;
+    string dbEnvName, dbName, dbNameNew;
+
+    int idx = 1;
+    while(idx < argc)
+    {
+        if(strcmp(argv[idx], "-h") == 0 || strcmp(argv[idx], "--help") == 0)
+        {
+            usage(argv[0]);
+            return EXIT_SUCCESS;
+        }
+        else if(strcmp(argv[idx], "-v") == 0 || strcmp(argv[idx], "--version") == 0)
+        {
+            cout << ICE_STRING_VERSION << endl;
+            return EXIT_SUCCESS;
+        }
+        else if(strncmp(argv[idx], "-D", 2) == 0 || strncmp(argv[idx], "-U", 2) == 0)
+        {
+            cppArgs += ' ';
+            cppArgs += argv[idx];
+
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strncmp(argv[idx], "-I", 2) == 0)
+        {
+            cppArgs += ' ';
+            cppArgs += argv[idx];
+
+            string path = argv[idx] + 2;
+            if(path.length())
+            {
+                includePaths.push_back(path);
+            }
+
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "-d") == 0 || strcmp(argv[idx], "--debug") == 0)
+        {
+            debug = true;
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "--ice") == 0)
+        {
+            ice = true;
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "--case-sensitive") == 0)
+        {
+            caseSensitive = true;
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "-o") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            outputFile = argv[idx + 1];
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(strcmp(argv[idx], "-i") == 0)
+        {
+            ignoreTypeChanges = true;
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "-f") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            inputFile = argv[idx + 1];
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(strcmp(argv[idx], "--old") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            oldSlice.push_back(argv[idx + 1]);
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(strcmp(argv[idx], "--new") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            newSlice.push_back(argv[idx + 1]);
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(strcmp(argv[idx], "-e") == 0)
+        {
+            evictor = true;
+            for(int i = idx ; i + 1 < argc ; ++i)
+            {
+                argv[i] = argv[i + 1];
+            }
+            --argc;
+        }
+        else if(strcmp(argv[idx], "--key") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            keyTypeNames = argv[idx + 1];
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(strcmp(argv[idx], "--value") == 0)
+        {
+            if(idx + 1 >= argc || argv[idx + 1][0] == '-')
+            {
+                cerr << argv[0] << ": argument expected for `" << argv[idx] << "'" << endl;
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            valueTypeNames = argv[idx + 1];
+
+            for(int i = idx ; i + 2 < argc ; ++i)
+            {
+                argv[i] = argv[i + 2];
+            }
+            argc -= 2;
+        }
+        else if(argv[idx][0] == '-')
+        {
+            cerr << argv[0] << ": unknown option `" << argv[idx] << "'" << endl;
+            usage(argv[0]);
+            return EXIT_FAILURE;
+        }
+        else
+        {
+            ++idx;
+        }
+    }
+
+    if(outputFile.empty() && argc < 4)
+    {
+        usage(argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    if(argc > 1)
+    {
+        dbEnvName = argv[1];
+    }
+    if(argc > 2)
+    {
+        dbName = argv[2];
+    }
+    if(argc > 3)
+    {
+        dbNameNew = argv[3];
+    }
+
+    Slice::UnitPtr oldUnit = Slice::Unit::createUnit(true, false, ice, caseSensitive);
+    Transform::Destroyer<Slice::UnitPtr> oldD(oldUnit);
+    if(!parseSlice(argv[0], oldUnit, oldSlice, cppArgs, debug))
+    {
+        return EXIT_FAILURE;
+    }
+
+    Slice::UnitPtr newUnit = Slice::Unit::createUnit(true, false, ice, caseSensitive);
+    Transform::Destroyer<Slice::UnitPtr> newD(newUnit);
+    if(!parseSlice(argv[0], newUnit, newSlice, cppArgs, debug))
+    {
+        return EXIT_FAILURE;
+    }
+
+    //
+    // Create the Transformer.
+    //
+    Transform::Transformer transformer(communicator, oldUnit, newUnit, ignoreTypeChanges);
+
+    //
+    // If no input file was provided, then we need to analyze the Slice types.
+    //
+    string descriptors;
+    if(inputFile.empty())
+    {
+        ostringstream out;
+        vector<string> missingTypes;
+        vector<string> analyzeErrors;
+
+        if(evictor)
+        {
+            transformer.analyze(out, missingTypes, analyzeErrors);
+        }
+        else
+        {
+            string oldKeyName, newKeyName, oldValueName, newValueName;
+            string::size_type pos;
+
+            if(keyTypeNames.empty() || valueTypeNames.empty())
+            {
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+
+            pos = keyTypeNames.find(',');
+            if(pos == 0 || pos == keyTypeNames.size())
+            {
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+            if(pos == string::npos)
+            {
+                oldKeyName = keyTypeNames;
+                newKeyName = keyTypeNames;
+            }
+            else
+            {
+                oldKeyName = keyTypeNames.substr(0, pos);
+                newKeyName = keyTypeNames.substr(pos + 1);
+            }
+
+            pos = valueTypeNames.find(',');
+            if(pos == 0 || pos == valueTypeNames.size())
+            {
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+            if(pos == string::npos)
+            {
+                oldValueName = valueTypeNames;
+                newValueName = valueTypeNames;
+            }
+            else
+            {
+                oldValueName = valueTypeNames.substr(0, pos);
+                newValueName = valueTypeNames.substr(pos + 1);
+            }
+
+            transformer.analyze(oldKeyName, newKeyName, oldValueName, newValueName, out, missingTypes, analyzeErrors);
+        }
+
+        if(!analyzeErrors.empty())
+        {
+            for(vector<string>::const_iterator p = analyzeErrors.begin(); p != analyzeErrors.end(); ++p)
+            {
+                cerr << argv[0] << ": " << *p << endl;
+            }
+        }
+
+        if(!missingTypes.empty())
+        {
+            sort(missingTypes.begin(), missingTypes.end());
+            unique(missingTypes.begin(), missingTypes.end());
+            if(!analyzeErrors.empty())
+            {
+                cerr << endl;
+            }
+            cerr << "The following types had no matching definitions in the new Slice:" << endl;
+            for(vector<string>::const_iterator p = missingTypes.begin(); p != missingTypes.end(); ++p)
+            {
+                cerr << *p << endl;
+            }
+        }
+
+        if(!analyzeErrors.empty())
+        {
+            return EXIT_FAILURE;
+        }
+
+        descriptors = out.str();
+
+        if(!outputFile.empty())
+        {
+            ofstream of(outputFile.c_str());
+            if(!of.good())
+            {
+                cerr << argv[0] << ": unable to open file `" << outputFile << "'" << endl;
+                return EXIT_FAILURE;
+            }
+            of << descriptors;
+            of.close();
+            return EXIT_SUCCESS;
+        }
+    }
+    else
+    {
+        ifstream in(inputFile.c_str());
+        char buff[1024];
+        while(true)
+        {
+            in.read(buff, 1024);
+            descriptors.append(buff, in.gcount());
+            if(in.gcount() < 1024)
+            {
+                break;
+            }
+        }
+        in.close();
+    }
+
+    DbEnv dbEnv(0);
+    Db* db = 0;
+    Db* dbNew = 0;
+    int status = EXIT_SUCCESS;
+    try
+    {
+#ifdef _WIN32
+        //
+        // Berkeley DB may use a different C++ runtime.
+        //
+        dbEnv.set_alloc(::malloc, ::realloc, ::free);
+#endif
+
+        u_int32_t flags = DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_CREATE;
+        dbEnv.open(dbEnvName.c_str(), flags, TRANSFORM_DB_MODE);
+        db = new Db(&dbEnv, 0);
+        db->open(0, dbName.c_str(), 0, DB_BTREE, DB_RDONLY, TRANSFORM_DB_MODE);
+        dbNew = new Db(&dbEnv, 0);
+        dbNew->open(0, dbNameNew.c_str(), 0, DB_BTREE, DB_CREATE | DB_TRUNCATE, TRANSFORM_DB_MODE);
+
+        istringstream istr(descriptors);
+        transformer.transform(istr, db, dbNew, cerr);
+    }
+    catch(const DbException& ex)
+    {
+        cerr << argv[0] << ": database error: " << ex.what() << endl;
+        status = EXIT_FAILURE;
+    }
+    catch(...)
+    {
+        if(db)
+        {
+            db->close(0);
+            delete db;
+        }
+        if(dbNew)
+        {
+            dbNew->close(0);
+            delete dbNew;
+        }
+        dbEnv.close(0);
+        throw;
+    }
+
+    if(db)
+    {
+        db->close(0);
+        delete db;
+    }
+    if(dbNew)
+    {
+        dbNew->close(0);
+        delete dbNew;
+    }
+    dbEnv.close(0);
+
+    return status;
+}
+
+int
+main(int argc, char* argv[])
+{
+    Ice::CommunicatorPtr communicator;
+    int status = EXIT_SUCCESS;
+    try
+    {
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
+    }
+    catch(const Transform::TransformException& ex)
+    {
+        cerr << ex.reason();
+        return EXIT_FAILURE;
+    }
+    catch(const IceUtil::Exception& ex)
+    {
+        cerr << argv[0] << ": " << ex << endl;
+        return EXIT_FAILURE;
+    }
+
+    if(communicator)
+    {
+        communicator->destroy();
+    }
+
+    return status;
+}
diff --git a/cpp/src/Transform/TransformUtil.cpp b/cpp/src/Transform/TransformUtil.cpp
new file mode 100644
index 00000000000..e2f835115a3
--- /dev/null
+++ b/cpp/src/Transform/TransformUtil.cpp
@@ -0,0 +1,33 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/TransformUtil.h>
+
+using namespace std;
+
+string
+Transform::typeName(const Slice::TypePtr& type)
+{
+    Slice::BuiltinPtr b = Slice::BuiltinPtr::dynamicCast(type);
+    if(b)
+    {
+        return b->kindAsString();
+    }
+    else
+    {
+        Slice::ContainedPtr c = Slice::ContainedPtr::dynamicCast(type);
+        assert(c);
+        return c->scoped();
+    }
+}
diff --git a/cpp/src/Transform/TransformUtil.h b/cpp/src/Transform/TransformUtil.h
new file mode 100644
index 00000000000..fab1ef8ecee
--- /dev/null
+++ b/cpp/src/Transform/TransformUtil.h
@@ -0,0 +1,52 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#ifndef TRANSFORM_TRANSFORM_UTIL_H
+#define TRANSFORM_TRANSFORM_UTIL_H
+
+#include <Slice/Parser.h>
+
+namespace Transform
+{
+
+template<class T>
+class Destroyer
+{
+public:
+
+    Destroyer() {}
+    Destroyer(T p) : _p(p) {}
+    ~Destroyer()
+    {
+        if(_p)
+            _p->destroy();
+    }
+
+    void set(T p)
+    {
+        if(_p)
+            _p->destroy();
+        _p = p;
+    }
+
+private:
+
+    T _p;
+};
+
+std::string typeName(const Slice::TypePtr&);
+
+} // End of namespace Transform
+
+#endif
diff --git a/cpp/src/Transform/Transformer.cpp b/cpp/src/Transform/Transformer.cpp
new file mode 100644
index 00000000000..f6f37a790f2
--- /dev/null
+++ b/cpp/src/Transform/Transformer.cpp
@@ -0,0 +1,2156 @@
+// **********************************************************************
+//
+// Copyright (c) 2003
+// ZeroC, Inc.
+// Billerica, MA, USA
+//
+// All Rights Reserved.
+//
+// Ice is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License version 2 as published by
+// the Free Software Foundation.
+//
+// **********************************************************************
+
+#include <Transform/Transformer.h>
+#include <Transform/TransformUtil.h>
+#include <Transform/Data.h>
+#include <Transform/Parser.h>
+#include <Transform/Error.h>
+#include <Transform/Exception.h>
+#include <Transform/Analyzer.h>
+#include <IceXML/Parser.h>
+#include <db_cxx.h>
+#include <stack>
+
+using namespace std;
+
+namespace Transform
+{
+
+class Descriptor;
+typedef IceUtil::Handle<Descriptor> DescriptorPtr;
+
+class TransformDescriptor;
+typedef IceUtil::Handle<TransformDescriptor> TransformDescriptorPtr;
+
+typedef map<string, TransformDescriptorPtr> TransformMap;
+
+class DeleteRecordException {};
+
+class TransformSymbolTable : public SymbolTable
+{
+public:
+
+    TransformSymbolTable(const DataFactoryPtr&, const Slice::UnitPtr&, const Slice::UnitPtr&, const ErrorReporterPtr&,
+                         TransformSymbolTable* = 0);
+
+    virtual DataPtr getValue(const Identifier&) const;
+    virtual DataPtr getConstantValue(const string&) const;
+
+    void add(const string&, const DataPtr&);
+
+private:
+
+    DataPtr findValue(const string&);
+
+    DataFactoryPtr _factory;
+    Slice::UnitPtr _old;
+    Slice::UnitPtr _new;
+    ErrorReporterPtr _errorReporter;
+    TransformSymbolTable* _parent;
+    typedef map<string, DataPtr> DataMap;
+    DataMap _dataMap;
+    DataMap _constantCache;
+};
+
+class Descriptor : virtual public IceUtil::SimpleShared
+{
+public:
+
+    virtual ~Descriptor();
+
+    virtual DescriptorPtr parent() const;
+    virtual void addChild(const DescriptorPtr&) = 0;
+    virtual void validate() = 0;
+    virtual void execute(TransformSymbolTable&, DataInterceptor&) = 0;
+
+    virtual DataFactoryPtr factory() const;
+    virtual Slice::UnitPtr oldUnit() const;
+    virtual Slice::UnitPtr newUnit() const;
+    virtual ErrorReporterPtr errorReporter() const;
+
+protected:
+
+    Descriptor(const DescriptorPtr&, int);
+
+    NodePtr parse(const string&) const;
+
+    Slice::TypePtr findType(const Slice::UnitPtr&, const string&);
+
+    DescriptorPtr _parent;
+    int _line;
+};
+
+class SetDescriptor : public Descriptor
+{
+public:
+
+    SetDescriptor(const DescriptorPtr&, int, const string&, const string&, const string&, const string&, bool);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    IdentNodePtr _target;
+    NodePtr _key;
+    string _keyStr;
+    NodePtr _value;
+    string _valueStr;
+    string _type;
+    bool _convert;
+};
+
+class RemoveDescriptor : public Descriptor
+{
+public:
+
+    RemoveDescriptor(const DescriptorPtr&, int, const string&, const string&);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    IdentNodePtr _target;
+    NodePtr _key;
+    string _keyStr;
+};
+
+class DeleteDescriptor : public Descriptor
+{
+public:
+
+    DeleteDescriptor(const DescriptorPtr&, int);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+};
+
+class FailDescriptor : public Descriptor
+{
+public:
+
+    FailDescriptor(const DescriptorPtr&, int, const string&);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    string _message;
+};
+
+class EchoDescriptor : public Descriptor
+{
+public:
+
+    EchoDescriptor(const DescriptorPtr&, int, const string&, const string&);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    string _message;
+    string _value;
+    NodePtr _node;
+};
+
+class ExecutableContainerDescriptor : virtual public Descriptor
+{
+public:
+
+    ExecutableContainerDescriptor(const DescriptorPtr&, int, const string&);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    string _name;
+    vector<DescriptorPtr> _children;
+};
+
+class ConditionalDescriptor : public ExecutableContainerDescriptor
+{
+public:
+
+    ConditionalDescriptor(const DescriptorPtr&, int, const string&);
+
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    string _test;
+    NodePtr _node;
+};
+
+class IterateDescriptor : public ExecutableContainerDescriptor
+{
+public:
+
+    IterateDescriptor(const DescriptorPtr&, int, const string&, const string&, const string&, const string&,
+                      const string&);
+
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+private:
+
+    IdentNodePtr _target;
+    string _key;
+    string _value;
+    string _element;
+    string _index;
+};
+
+class TransformDescriptor : public ExecutableContainerDescriptor
+{
+public:
+
+    TransformDescriptor(const DescriptorPtr&, int, const string&, bool);
+
+    string type() const;
+    bool doDefaultTransform() const;
+
+private:
+
+    bool _default;
+    Slice::TypePtr _oldType;
+    Slice::TypePtr _newType;
+};
+
+class InitDescriptor : virtual public ExecutableContainerDescriptor, virtual public DataInitializer
+{
+public:
+
+    InitDescriptor(const DescriptorPtr&, int, const string&);
+
+    virtual void initialize(const DataFactoryPtr&, const DataPtr&, const Ice::CommunicatorPtr&);
+
+    string type() const;
+
+private:
+
+    Slice::TypePtr _type;
+};
+typedef IceUtil::Handle<InitDescriptor> InitDescriptorPtr;
+
+// TODO: Is this class necessary?
+class RecordDescriptor : public ExecutableContainerDescriptor
+{
+public:
+
+    RecordDescriptor(const DescriptorPtr&, int);
+};
+typedef IceUtil::Handle<RecordDescriptor> RecordDescriptorPtr;
+
+class DatabaseDescriptor : public Descriptor
+{
+public:
+
+    DatabaseDescriptor(const DescriptorPtr&, int, const string&, const string&);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+    bool transform(IceInternal::BasicStream&, IceInternal::BasicStream&, IceInternal::BasicStream&,
+                   IceInternal::BasicStream&, const TransformMap&);
+
+private:
+
+    Slice::TypePtr _oldKey;
+    Slice::TypePtr _newKey;
+    Slice::TypePtr _oldValue;
+    Slice::TypePtr _newValue;
+    RecordDescriptorPtr _record;
+};
+typedef IceUtil::Handle<DatabaseDescriptor> DatabaseDescriptorPtr;
+
+class TransformerDescriptor : public Descriptor
+{
+public:
+
+    TransformerDescriptor(const DataFactoryPtr&, const Slice::UnitPtr&, const Slice::UnitPtr&, const ErrorReporterPtr&,
+                          int);
+
+    virtual void addChild(const DescriptorPtr&);
+    virtual void validate();
+    virtual void execute(TransformSymbolTable&, DataInterceptor&);
+
+    virtual DataFactoryPtr factory() const;
+    virtual Slice::UnitPtr oldUnit() const;
+    virtual Slice::UnitPtr newUnit() const;
+    virtual ErrorReporterPtr errorReporter() const;
+
+    void transform(const Ice::CommunicatorPtr&, Db*, Db*);
+
+private:
+
+    DataFactoryPtr _factory;
+    Slice::UnitPtr _old;
+    Slice::UnitPtr _new;
+    ErrorReporterPtr _errorReporter;
+    DatabaseDescriptorPtr _database;
+    TransformMap _transforms;
+    vector<DescriptorPtr> _children;
+};
+typedef IceUtil::Handle<TransformerDescriptor> TransformerDescriptorPtr;
+
+class DescriptorHandler : public IceXML::Handler
+{
+public:
+
+    DescriptorHandler(const DataFactoryPtr&, const Slice::UnitPtr&, const Slice::UnitPtr&, const ErrorReporterPtr&);
+
+    virtual void startElement(const std::string&, const IceXML::Attributes&, int, int);
+    virtual void endElement(const std::string&, int, int);
+    virtual void characters(const std::string&, int, int);
+    virtual void error(const std::string&, int, int);
+
+    TransformerDescriptorPtr descriptor() const;
+
+private:
+
+    DataFactoryPtr _factory;
+    Slice::UnitPtr _old;
+    Slice::UnitPtr _new;
+    ErrorReporterPtr _errorReporter;
+    DescriptorPtr _current;
+    TransformerDescriptorPtr _transformer;
+};
+
+class TransformInterceptor : public DataInterceptor
+{
+public:
+
+    TransformInterceptor(const DataFactoryPtr&, const ErrorReporterPtr&, const Slice::UnitPtr&,
+                         const Slice::UnitPtr&, const TransformMap&);
+
+    virtual bool preTransform(const DataPtr&, const DataPtr&);
+    virtual void postTransform(const DataPtr&, const DataPtr&);
+    virtual ObjectDataMap& getObjectMap();
+
+private:
+
+    DataFactoryPtr _factory;
+    ErrorReporterPtr _errorReporter;
+    Slice::UnitPtr _old;
+    Slice::UnitPtr _new;
+    const TransformMap& _transformMap;
+    ObjectDataMap _objectMap;
+};
+
+} // End of namespace Transform
+
+//
+// TransformSymbolTable
+//
+Transform::TransformSymbolTable::TransformSymbolTable(const DataFactoryPtr& factory, const Slice::UnitPtr& oldUnit,
+                                                      const Slice::UnitPtr& newUnit,
+                                                      const ErrorReporterPtr& errorReporter,
+                                                      TransformSymbolTable* parent) :
+    _factory(factory), _old(oldUnit), _new(newUnit), _errorReporter(errorReporter), _parent(parent)
+{
+}
+
+Transform::DataPtr
+Transform::TransformSymbolTable::getValue(const Identifier& id) const
+{
+    DataPtr result;
+
+    Identifier tmpid = id;
+    string s = tmpid.front();
+    tmpid.erase(tmpid.begin());
+
+    DataMap::const_iterator p = _dataMap.find(s);
+    if(p != _dataMap.end())
+    {
+        result = p->second;
+    }
+
+    if(!result && _parent)
+    {
+        result = _parent->findValue(s);
+    }
+
+    if(!result)
+    {
+        ostringstream ostr;
+        ostr << "invalid identifier `" << id << "'";
+        throw TransformException(__FILE__, __LINE__, ostr.str());
+    }
+
+    for(Identifier::const_iterator p = tmpid.begin(); p != tmpid.end(); ++p)
+    {
+        DataPtr d = result->getMember(*p);
+        if(!d)
+        {
+            ostringstream ostr;
+            ostr << "invalid identifier `" << id << "'";
+            throw TransformException(__FILE__, __LINE__, ostr.str());
+        }
+        result = d;
+    }
+
+    return result;
+}
+
+Transform::DataPtr
+Transform::TransformSymbolTable::getConstantValue(const string& name) const
+{
+    string::size_type pos;
+    Slice::UnitPtr unit;
+    string key;
+
+    DataMap::const_iterator p = _constantCache.find(name);
+    if(p != _constantCache.end())
+    {
+        return p->second;
+    }
+
+    if(_parent)
+    {
+        return _parent->getConstantValue(name);
+    }
+
+    //
+    // Name must start with "::Old" or "::New" to indicate the Slice unit.
+    //
+    pos = name.find("::Old");
+    if(pos == 0)
+    {
+        if(name.length() > 5)
+        {
+            key = name.substr(5);
+            unit = _old;
+        }
+    }
+    else
+    {
+        pos = name.find("::New");
+        if(pos == 0)
+        {
+            if(name.length() > 5)
+            {
+                key = name.substr(5);
+                unit = _new;
+            }
+        }
+    }
+
+    if(key.empty())
+    {
+        throw TransformException(__FILE__, __LINE__, "invalid constant name `" + name + "'");
+    }
+
+    Slice::ContainedList l = unit->findContents(key);
+    if(l.empty())
+    {
+        throw TransformException(__FILE__, __LINE__, "unknown constant `" + name + "'");
+    }
+
+    Slice::EnumeratorPtr e = Slice::EnumeratorPtr::dynamicCast(l.front());
+    Slice::ConstPtr c = Slice::ConstPtr::dynamicCast(l.front());
+    if(!e && !c)
+    {
+        throw TransformException(__FILE__, __LINE__, "`" + name + "' does not refer to a Slice constant or enumerator");
+    }
+
+    DataPtr result;
+
+    if(c)
+    {
+        Slice::TypePtr type = c->type();
+        string value = c->value();
+        Slice::BuiltinPtr b = Slice::BuiltinPtr::dynamicCast(type);
+        if(b)
+        {
+            switch(b->kind())
+            {
+            case Slice::Builtin::KindByte:
+            case Slice::Builtin::KindShort:
+            case Slice::Builtin::KindInt:
+            case Slice::Builtin::KindLong:
+            {
+                string::size_type pos;
+                Ice::Long n;
+                bool success = IceUtil::stringToInt64(value, n, pos);
+                assert(success);
+                result = _factory->createInteger(n, true);
+                break;
+            }
+
+            case Slice::Builtin::KindBool:
+            {
+                result = _factory->createBoolean(value == "true", true);
+                break;
+            }
+
+            case Slice::Builtin::KindFloat:
+            case Slice::Builtin::KindDouble:
+            {
+                double v = strtod(value.c_str(), 0);
+                result = _factory->createDouble(v, true);
+                break;
+            }
+
+            case Slice::Builtin::KindString:
+            {
+                result = _factory->createString(value, true);
+                break;
+            }
+
+            case Slice::Builtin::KindObject:
+            case Slice::Builtin::KindObjectProxy:
+            case Slice::Builtin::KindLocalObject:
+                assert(false);
+            }
+        }
+        else
+        {
+            Slice::EnumPtr en = Slice::EnumPtr::dynamicCast(type);
+            assert(en);
+            Slice::EnumeratorList el = en->getEnumerators();
+            for(Slice::EnumeratorList::iterator p = el.begin(); p != el.end(); ++p)
+            {
+                if((*p)->name() == value)
+                {
+                    e = *p;
+                    break;
+                }
+            }
+            assert(e);
+        }
+    }
+
+    if(!result)
+    {
+        assert(e);
+        result = _factory->create(e->type(), true);
+        EnumDataPtr ed = EnumDataPtr::dynamicCast(result);
+        assert(ed);
+        ed->setValueAsString(e->name());
+    }
+
+    //
+    // Cache the value.
+    //
+    const_cast<DataMap&>(_constantCache).insert(DataMap::value_type(name, result));
+
+    return result;
+}
+
+void
+Transform::TransformSymbolTable::add(const string& name, const DataPtr& data)
+{
+    DataPtr d = findValue(name);
+    if(d)
+    {
+        throw TransformException(__FILE__, __LINE__, "`" + name + "' is already defined");
+    }
+
+    _dataMap.insert(DataMap::value_type(name, data));
+}
+
+Transform::DataPtr
+Transform::TransformSymbolTable::findValue(const string& name)
+{
+    DataMap::const_iterator p = _dataMap.find(name);
+    if(p != _dataMap.end())
+    {
+        return p->second;
+    }
+
+    if(_parent)
+    {
+        return _parent->findValue(name);
+    }
+
+    return 0;
+}
+
+//
+// Descriptor
+//
+Transform::Descriptor::Descriptor(const DescriptorPtr& parent, int line) :
+    _parent(parent), _line(line)
+{
+}
+
+Transform::Descriptor::~Descriptor()
+{
+}
+
+Transform::DescriptorPtr
+Transform::Descriptor::parent() const
+{
+    return _parent;
+}
+
+Transform::DataFactoryPtr
+Transform::Descriptor::factory() const
+{
+    assert(_parent);
+    return _parent->factory();
+}
+
+Slice::UnitPtr
+Transform::Descriptor::oldUnit() const
+{
+    assert(_parent);
+    return _parent->oldUnit();
+}
+
+Slice::UnitPtr
+Transform::Descriptor::newUnit() const
+{
+    assert(_parent);
+    return _parent->newUnit();
+}
+
+Transform::ErrorReporterPtr
+Transform::Descriptor::errorReporter() const
+{
+    assert(_parent);
+    return _parent->errorReporter();
+}
+
+Transform::NodePtr
+Transform::Descriptor::parse(const string& expr) const
+{
+    return Parser::parse(expr, factory(), errorReporter());
+}
+
+Slice::TypePtr
+Transform::Descriptor::findType(const Slice::UnitPtr& u, const string& type)
+{
+    Slice::TypeList l;
+
+    l = u->lookupType(type, false);
+    if(l.empty())
+    {
+        errorReporter()->error("unknown type `" + type + "'");
+    }
+
+    return l.front();
+}
+
+//
+// SetDescriptor
+//
+Transform::SetDescriptor::SetDescriptor(const DescriptorPtr& parent, int line, const string& target, const string& key,
+                                        const string& value, const string& type, bool convert) :
+    Descriptor(parent, line), _keyStr(key), _valueStr(value), _type(type), _convert(convert)
+{
+    DescriptorErrorContext ctx(errorReporter(), "set", _line);
+
+    NodePtr node = parse(target);
+    _target = IdentNodePtr::dynamicCast(node);
+    if(!_target)
+    {
+        errorReporter()->error("`target' attribute is not an identifier: `" + target + "'");
+    }
+
+    if(!key.empty())
+    {
+        _key = parse(key);
+    }
+
+    if(!value.empty())
+    {
+        _value = parse(value);
+    }
+}
+
+void
+Transform::SetDescriptor::addChild(const DescriptorPtr&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "set", _line);
+    errorReporter()->error("<set> cannot have child elements");
+}
+
+void
+Transform::SetDescriptor::validate()
+{
+}
+
+void
+Transform::SetDescriptor::execute(TransformSymbolTable& sym, DataInterceptor& interceptor)
+{
+    DescriptorErrorContext ctx(errorReporter(), "set", _line);
+
+    DataPtr data = sym.getValue(_target->getValue());
+    if(data->readOnly())
+    {
+        ostringstream ostr;
+        ostr << _target->getValue();
+        errorReporter()->error("target `" + ostr.str() + "' cannot be modified");
+    }
+
+    DataPtr key;
+    if(_key)
+    {
+        try
+        {
+            key = _key->evaluate(sym);
+        }
+        catch(const EvaluateException& ex)
+        {
+            errorReporter()->error("evaluation of key `" + _keyStr + "' failed:\n" + ex.reason());
+        }
+    }
+
+    DataPtr value;
+    if(_value)
+    {
+        try
+        {
+            value = _value->evaluate(sym);
+        }
+        catch(const EvaluateException& ex)
+        {
+            errorReporter()->error("evaluation of value `" + _valueStr + "' failed:\n" + ex.reason());
+        }
+    }
+
+    Destroyer<DataPtr> valueDestroyer;
+    if(!_type.empty())
+    {
+        assert(!value);
+        Slice::TypeList l = newUnit()->lookupType(_type, false);
+        if(l.empty())
+        {
+            errorReporter()->error("type `" + _type + "' not found");
+        }
+        value = factory()->create(l.front(), false);
+        valueDestroyer.set(value);
+        ObjectRefPtr ref = ObjectRefPtr::dynamicCast(value);
+        if(!ref)
+        {
+            errorReporter()->error("type `" + _type + "' is not a class");
+        }
+        ref->instantiate();
+    }
+
+    if(_key)
+    {
+        DictionaryDataPtr dict = DictionaryDataPtr::dynamicCast(data);
+        if(!dict)
+        {
+            ostringstream ostr;
+            ostr << _target->getValue();
+            errorReporter()->error("target `" + ostr.str() + "' is not a dictionary");
+        }
+        dict->put(key, value, interceptor, _convert);
+    }
+    else
+    {
+        data->set(value, interceptor, _convert);
+    }
+}
+
+//
+// RemoveDescriptor
+//
+Transform::RemoveDescriptor::RemoveDescriptor(const DescriptorPtr& parent, int line, const string& target,
+                                              const string& key) :
+    Descriptor(parent, line), _keyStr(key)
+{
+    DescriptorErrorContext ctx(errorReporter(), "remove", _line);
+
+    NodePtr node = parse(target);
+    _target = IdentNodePtr::dynamicCast(node);
+    if(!_target)
+    {
+        errorReporter()->error("`target' attribute is not an identifier: `" + target + "'");
+    }
+
+    _key = parse(key);
+}
+
+void
+Transform::RemoveDescriptor::addChild(const DescriptorPtr&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "remove", _line);
+    errorReporter()->error("<remove> cannot have child elements");
+}
+
+void
+Transform::RemoveDescriptor::validate()
+{
+}
+
+void
+Transform::RemoveDescriptor::execute(TransformSymbolTable& sym, DataInterceptor& interceptor)
+{
+    DescriptorErrorContext ctx(errorReporter(), "remove", _line);
+
+    DataPtr key;
+    try
+    {
+        key = _key->evaluate(sym);
+    }
+    catch(const EvaluateException& ex)
+    {
+        errorReporter()->error("evaluation of key `" + _keyStr + "' failed:\n" + ex.reason());
+    }
+
+    DataPtr data = sym.getValue(_target->getValue());
+    if(data->readOnly())
+    {
+        ostringstream ostr;
+        ostr << _target->getValue();
+        errorReporter()->error("target `" + ostr.str() + "' cannot be modified");
+    }
+
+    DictionaryDataPtr dict = DictionaryDataPtr::dynamicCast(data);
+    if(!dict)
+    {
+        ostringstream ostr;
+        ostr << _target->getValue();
+        errorReporter()->error("target `" + ostr.str() + "' is not a dictionary");
+    }
+    dict->remove(key);
+}
+
+//
+// DeleteDescriptor
+//
+Transform::DeleteDescriptor::DeleteDescriptor(const DescriptorPtr& parent, int line) :
+    Descriptor(parent, line)
+{
+}
+
+void
+Transform::DeleteDescriptor::addChild(const DescriptorPtr&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "delete", _line);
+    errorReporter()->error("<delete> cannot have child elements");
+}
+
+void
+Transform::DeleteDescriptor::validate()
+{
+}
+
+void
+Transform::DeleteDescriptor::execute(TransformSymbolTable&, DataInterceptor&)
+{
+    throw DeleteRecordException();
+}
+
+//
+// FailDescriptor
+//
+Transform::FailDescriptor::FailDescriptor(const DescriptorPtr& parent, int line, const string& message) :
+    Descriptor(parent, line), _message(message)
+{
+}
+
+void
+Transform::FailDescriptor::addChild(const DescriptorPtr&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "fail", _line);
+    errorReporter()->error("<fail> cannot have child elements");
+}
+
+void
+Transform::FailDescriptor::validate()
+{
+}
+
+void
+Transform::FailDescriptor::execute(TransformSymbolTable&, DataInterceptor&)
+{
+    throw TransformException(__FILE__, __LINE__, _message);
+}
+
+//
+// EchoDescriptor
+//
+Transform::EchoDescriptor::EchoDescriptor(const DescriptorPtr& parent, int line, const string& message,
+                                          const string& value) :
+    Descriptor(parent, line), _message(message), _value(value)
+{
+    if(!value.empty())
+    {
+        _node = parse(value);
+    }
+}
+
+void
+Transform::EchoDescriptor::addChild(const DescriptorPtr&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "echo", _line);
+    errorReporter()->error("<echo> cannot have child elements");
+}
+
+void
+Transform::EchoDescriptor::validate()
+{
+}
+
+void
+Transform::EchoDescriptor::execute(TransformSymbolTable& sym, DataInterceptor&)
+{
+    DescriptorErrorContext ctx(errorReporter(), "echo", _line);
+
+    ostream& out = errorReporter()->stream();
+
+    if(!_message.empty())
+    {
+        out << _message;
+    }
+
+    if(_node)
+    {
+        try
+        {
+            DataPtr v = _node->evaluate(sym);
+            v->print(out);
+        }
+        catch(const EvaluateException& ex)
+        {
+            errorReporter()->error("evaluation of value `" + _value + "' failed:\n" + ex.reason());
+        }
+    }
+
+    out << endl;
+}
+
+//
+// ExecutableContainerDescriptor
+//
+Transform::ExecutableContainerDescriptor::ExecutableContainerDescriptor(const DescriptorPtr& parent, int line,
+                                                                        const string& name) :
+    Descriptor(parent, line), _name(name)
+{
+}
+
+void
+Transform::ExecutableContainerDescriptor::addChild(const DescriptorPtr& child)
+{
+    _children.push_back(child);
+}
+
+void
+Transform::ExecutableContainerDescriptor::validate()
+{
+    for(vector<DescriptorPtr>::iterator p = _children.begin(); p != _children.end(); ++p)
+    {
+        (*p)->validate();
+    }
+}
+
+void
+Transform::ExecutableContainerDescriptor::execute(TransformSymbolTable& sym, DataInterceptor& interceptor)
+{
+    for(vector<DescriptorPtr>::iterator p = _children.begin(); p != _children.end(); ++p)
+    {
+        (*p)->execute(sym, interceptor);
+    }
+}
+
+//
+// ConditionalDescriptor
+//
+Transform::ConditionalDescriptor::ConditionalDescriptor(const DescriptorPtr& parent, int line, const string& test) :
+    ExecutableContainerDescriptor(parent, line, "if"), Descriptor(parent, line), _test(test)
+{
+    DescriptorErrorContext ctx(errorReporter(), "if", _line);
+    _node = parse(test);
+}
+
+void
+Transform::ConditionalDescriptor::execute(TransformSymbolTable& sym, DataInterceptor& interceptor)
+{
+    DescriptorErrorContext ctx(errorReporter(), "if", _line);
+
+    try
+    {
+        DataPtr b = _node->evaluate(sym);
+        BooleanDataPtr bd = BooleanDataPtr::dynamicCast(b);
+        if(!bd)
+        {
+            errorReporter()->error("expression `" + _test + "' does not evaluate to a boolean");
+        }
+        if(bd->booleanValue())
+        {
+            ExecutableContainerDescriptor::execute(sym, interceptor);
+        }
+    }
+    catch(const EvaluateException& ex)
+    {
+        errorReporter()->error("evaluation of conditional expression `" + _test + "' failed:\n" + ex.reason());
+    }
+}
+
+//
+// IterateDescriptor
+//
+Transform::IterateDescriptor::IterateDescriptor(const DescriptorPtr& parent, int line, const string& target,
+                                                const string& key, const string& value, const string& element,
+                                                const string& index) :
+    ExecutableContainerDescriptor(parent, line, "iterate"), Descriptor(parent, line), _key(key), _value(value),
+    _element(element), _index(index)
+{
+    DescriptorErrorContext ctx(errorReporter(), "iterate", _line);
+
+    NodePtr node = parse(target);
+    _target = IdentNodePtr::dynamicCast(node);
+    if(!_target)
+    {
+        errorReporter()->error("`target' attribute is not an identifier: `" + target + "'");
+    }
+}
+
+void
+Transform::IterateDescriptor::execute(TransformSymbolTable& sym, DataInterceptor& interceptor)
+{
+    DescriptorErrorContext ctx(errorReporter(), "iterate", _line);
+
+    DataPtr data = sym.getValue(_target->getValue());
+
+    DictionaryDataPtr dict = DictionaryDataPtr::dynamicCast(data);
+    SequenceDataPtr seq = SequenceDataPtr::dynamicCast(data);
+    if(!dict && !seq)
+    {
+        ostringstream ostr;
+        ostr << _target->getValue();
+        errorReporter()->error("target `" + ostr.str() + "' is not a dictionary or sequence");
+    }
+
+    if(dict)
+    {
+        if(!_element.empty())
+        {
+            errorReporter()->error("attribute `element' specified for dictionary target");
+        }
+        if(!_index.empty())
+        {
+            errorReporter()->error("attribute `index' specified for dictionary target");
+        }
+
+        string key = _key;
+        if(key.empty())
+        {
+            key = "key";
+        }
+
+        string value = _value;
+        if(value.empty())
+        {
+            value = "value";
+        }
+
+        DataMap map = dict->getElements();
+        for(DataMap::iterator p = map.begin(); p != map.end(); ++p)
+        {
+            TransformSymbolTable elemSym(factory(), oldUnit(), newUnit(), errorReporter(), &sym);
+            elemSym.add(key, p->first);
+            elemSym.add(value, p->second);
+            ExecutableContainerDescriptor::execute(elemSym, interceptor);
+        }
+    }
+    else
+    {
+        if(!_key.empty())
+        {
+            errorReporter()->error("attribute `key' specified for sequence target");
+        }
+        if(!_value.empty())
+        {
+            errorReporter()->error("attribute `value' specified for sequence target");
+        }
+
+        string element = _element;
+        if(element.empty())
+        {
+            element = "elem";
+        }
+
+        string index = _index;
+        if(index.empty())
+        {
+            index = "i";
+        }
+
+        DataList l = seq->getElements();
+        Ice::Long i = 0;
+        for(DataList::iterator p = l.begin(); p != l.end(); ++p, ++i)
+        {
+            TransformSymbolTable elemSym(factory(), oldUnit(), newUnit(), errorReporter(), &sym);
+            elemSym.add(element, *p);
+            elemSym.add(index, factory()->createInteger(i, true));
+            ExecutableContainerDescriptor::execute(elemSym, interceptor);
+        }
+    }
+}
+
+//
+// TransformDescriptor
+//
+Transform::TransformDescriptor::TransformDescriptor(const DescriptorPtr& parent, int line, const string& type,
+                                                    bool def) :
+    ExecutableContainerDescriptor(parent, line, "transform"), Descriptor(parent, line), _default(def)
+{
+    DescriptorErrorContext ctx(errorReporter(), "transform", _line);
+
+    Slice::TypeList l;
+
+    l = oldUnit()->lookupType(type, false);
+    if(!l.empty())
+    {
+        _oldType = l.front();
+    }
+
+    l = newUnit()->lookupType(type, false);
+    if(l.empty())
+    {
+        errorReporter()->error("unable to find type `" + type + "' in new Slice definitions");
+    }
+    else
+    {
+        _newType = l.front();
+    }
+}
+
+string
+Transform::TransformDescriptor::type() const
+{
+    return typeName(_newType);
+}
+
+bool
+Transform::TransformDescriptor::doDefaultTransform() const
+{
+    return _default;
+}
+
+//
+// InitDescriptor
+//
+Transform::InitDescriptor::InitDescriptor(const DescriptorPtr& parent, int line, const string& type) :
+    ExecutableContainerDescriptor(parent, line, "init"), Descriptor(parent, line)
+{
+    DescriptorErrorContext ctx(errorReporter(), "init", _line);
+
+    Slice::TypeList l = newUnit()->lookupType(type, false);
+    if(l.empty())
+    {
+        errorReporter()->error("unable to find type `" + type + "' in new Slice definitions");
+    }
+    else
+    {
+        _type = l.front();
+    }
+}
+
+void
+Transform::InitDescriptor::initialize(const DataFactoryPtr& factory, const DataPtr& data,
+                                      const Ice::CommunicatorPtr& communicator)
+{
+    DescriptorErrorContext ctx(errorReporter(), "init", _line);
+
+#if 0 // TODO
+    // Is interceptor really necessary?
+    TransformSymbolTable sym(factory, _old, _new);
+    sym.add("value", data);
+    eh->raise(true);
+    execute(sym, interceptor);
+#endif
+}
+
+string
+Transform::InitDescriptor::type() const
+{
+    return typeName(_type);
+}
+
+//
+// RecordDescriptor
+//
+Transform::RecordDescriptor::RecordDescriptor(const DescriptorPtr& parent, int line) :
+    ExecutableContainerDescriptor(parent, line, "record"), Descriptor(parent, line)
+{
+}
+
+//
+// DatabaseDescriptor
+//
+Transform::DatabaseDescriptor::DatabaseDescriptor(const DescriptorPtr& parent, int line, const string& keyTypes,
+                                                  const string& valueTypes) :
+    Descriptor(parent, line)
+{
+    DescriptorErrorContext ctx(errorReporter(), "database", _line);
+
+    string oldKeyName, newKeyName;
+    string oldValueName, newValueName;
+    string::size_type pos;
+
+    pos = keyTypes.find(',');
+    if(pos == 0 || pos == keyTypes.size())
+    {
+        errorReporter()->error("invalid key type specification `" + keyTypes +"'");
+    }
+    if(pos == string::npos)
+    {
+        oldKeyName = keyTypes;
+        newKeyName = keyTypes;
+    }
+    else
+    {
+        oldKeyName = keyTypes.substr(0, pos);
+        newKeyName = keyTypes.substr(pos + 1);
+    }
+
+    pos = valueTypes.find(',');
+    if(pos == 0 || pos == valueTypes.size())
+    {
+        errorReporter()->error("invalid value type specification `" + valueTypes +"'");
+    }
+    if(pos == string::npos)
+    {
+        oldValueName = valueTypes;
+        newValueName = valueTypes;
+    }
+    else
+    {
+        oldValueName = valueTypes.substr(0, pos);
+        newValueName = valueTypes.substr(pos + 1);
+    }
+
+    //
+    // Look up the Slice definitions for the key and value types.
+    //
+    _oldKey = findType(oldUnit(), oldKeyName);
+    _newKey = findType(newUnit(), newKeyName);
+    _oldValue = findType(oldUnit(), oldValueName);
+    _newValue = findType(newUnit(), newValueName);
+}
+
+void
+Transform::DatabaseDescriptor::addChild(const DescriptorPtr& child)
+{
+    DescriptorErrorContext ctx(errorReporter(), "database", _line);
+
+    RecordDescriptorPtr rec = RecordDescriptorPtr::dynamicCast(child);
+    if(!rec)
+    {
+        errorReporter()->error("invalid child for <database> descriptor");
+    }
+    if(_record)
+    {
+        errorReporter()->error("only one <record> element can be specified");
+    }
+    _record = rec;
+}
+
+void
+Transform::DatabaseDescriptor::validate()
+{
+    if(!_record)
+    {
+        _record = new RecordDescriptor(this, _line);
+    }
+    _record->validate();
+}
+
+void
+Transform::DatabaseDescriptor::execute(TransformSymbolTable&, DataInterceptor&)
+{
+    assert(false);
+}
+
+bool
+Transform::DatabaseDescriptor::transform(IceInternal::BasicStream& inKey, IceInternal::BasicStream& inValue,
+                                         IceInternal::BasicStream& outKey, IceInternal::BasicStream& outValue,
+                                         const TransformMap& transforms)
+{
+    errorReporter()->raise(false);
+
+    TransformInterceptor interceptor(factory(), errorReporter(), oldUnit(), newUnit(), transforms);
+
+    //
+    // Create data representations of the old key and value types.
+    //
+    factory()->disableInitializers();
+    DataPtr oldKeyData = factory()->create(_oldKey, true);
+    Destroyer<DataPtr> oldKeyDataDestroyer(oldKeyData);
+    DataPtr oldValueData = factory()->create(_oldValue, true);
+    Destroyer<DataPtr> oldValueDataDestroyer(oldValueData);
+
+    //
+    // Unmarshal the old key and value.
+    //
+    oldKeyData->unmarshal(inKey);
+    oldValueData->unmarshal(inValue);
+    if(_oldValue->usesClasses())
+    {
+        inValue.readPendingObjects();
+        oldValueData->registerObjects(interceptor.getObjectMap());
+    }
+    factory()->enableInitializers();
+
+    //
+    // Create data representations of the new key and value types.
+    //
+    DataPtr newKeyData = factory()->create(_newKey, false);
+    Destroyer<DataPtr> newKeyDataDestroyer(newKeyData);
+    DataPtr newValueData = factory()->create(_newValue, false);
+    Destroyer<DataPtr> newValueDataDestroyer(newValueData);
+
+    //
+    // Copy the data from the old key and value to the new key and value, if possible.
+    //
+    newKeyData->transform(oldKeyData, interceptor);
+    newValueData->transform(oldValueData, interceptor);
+
+    //
+    // Execute the <record> descriptor.
+    //
+    // TODO: Revisit identifiers.
+    //
+    TransformSymbolTable sym(factory(), oldUnit(), newUnit(), errorReporter());
+    sym.add("oldkey", oldKeyData);
+    sym.add("newkey", newKeyData);
+    sym.add("oldvalue", oldValueData);
+    sym.add("newvalue", newValueData);
+    errorReporter()->raise(true);
+    _record->execute(sym, interceptor);
+
+    newKeyData->marshal(outKey);
+    newValueData->marshal(outValue);
+    if(_newValue->usesClasses())
+    {
+        outValue.writePendingObjects();
+    }
+
+    return true;
+}
+
+//
+// TransformerDescriptor
+//
+Transform::TransformerDescriptor::TransformerDescriptor(const DataFactoryPtr& factory, const Slice::UnitPtr& oldUnit,
+                                                        const Slice::UnitPtr& newUnit,
+                                                        const ErrorReporterPtr& errorReporter, int line) :
+    Descriptor(0, line), _factory(factory), _old(oldUnit), _new(newUnit), _errorReporter(errorReporter)
+{
+}
+
+void
+Transform::TransformerDescriptor::addChild(const DescriptorPtr& child)
+{
+    DescriptorErrorContext ctx(errorReporter(), "transformer", _line);
+
+    DatabaseDescriptorPtr db = DatabaseDescriptorPtr::dynamicCast(child);
+    TransformDescriptorPtr transform = TransformDescriptorPtr::dynamicCast(child);
+    InitDescriptorPtr init = InitDescriptorPtr::dynamicCast(child);
+
+    if(db)
+    {
+        if(_database)
+        {
+            errorReporter()->error("only one <database> element can be specified");
+        }
+        else
+        {
+            _database = db;
+            _children.push_back(db);
+        }
+    }
+    else if(transform)
+    {
+        string name = transform->type();
+        TransformMap::iterator p = _transforms.find(name);
+        if(p != _transforms.end())
+        {
+            errorReporter()->error("transform `" + name + "' specified more than once");
+        }
+        _transforms.insert(TransformMap::value_type(name, transform));
+        _children.push_back(transform);
+    }
+    else if(init)
+    {
+        string name = init->type();
+        _factory->addInitializer(init->type(), init);
+        _children.push_back(init);
+    }
+    else
+    {
+        errorReporter()->error("invalid child element");
+    }
+}
+
+void
+Transform::TransformerDescriptor::validate()
+{
+    DescriptorErrorContext ctx(errorReporter(), "transformer", _line);
+
+    if(!_database)
+    {
+        errorReporter()->error("no <database> element specified");
+    }
+
+    for(vector<DescriptorPtr>::iterator p = _children.begin(); p != _children.end(); ++p)
+    {
+        (*p)->validate();
+    }
+}
+
+void
+Transform::TransformerDescriptor::execute(TransformSymbolTable&, DataInterceptor&)
+{
+    assert(false);
+}
+
+Transform::DataFactoryPtr
+Transform::TransformerDescriptor::factory() const
+{
+    return _factory;
+}
+
+Slice::UnitPtr
+Transform::TransformerDescriptor::oldUnit() const
+{
+    return _old;
+}
+
+Slice::UnitPtr
+Transform::TransformerDescriptor::newUnit() const
+{
+    return _new;
+}
+
+Transform::ErrorReporterPtr
+Transform::TransformerDescriptor::errorReporter() const
+{
+    return _errorReporter;
+}
+
+void
+Transform::TransformerDescriptor::transform(const Ice::CommunicatorPtr& communicator, Db* db, Db* dbNew)
+{
+    DescriptorErrorContext ctx(errorReporter(), "transformer", _line);
+
+    Dbc* dbc = 0;
+
+    IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
+    db->cursor(0, &dbc, 0);
+
+    communicator->addObjectFactory(new Transform::ObjectFactory(_factory, _old), "");
+
+    try
+    {
+        Dbt dbKey, dbValue;
+        while(dbc->get(&dbKey, &dbValue, DB_NEXT) == 0)
+        {
+            IceInternal::BasicStream inKey(instance.get());
+            inKey.b.resize(dbKey.get_size());
+            memcpy(&inKey.b[0], dbKey.get_data(), dbKey.get_size());
+            inKey.i = inKey.b.begin();
+
+            IceInternal::BasicStream inValue(instance.get());
+            inValue.b.resize(dbValue.get_size());
+            memcpy(&inValue.b[0], dbValue.get_data(), dbValue.get_size());
+            inValue.i = inValue.b.begin();
+            inValue.startReadEncaps();
+
+            IceInternal::BasicStream outKey(instance.get());
+            IceInternal::BasicStream outValue(instance.get());
+            outValue.startWriteEncaps();
+            try
+            {
+                if(_database->transform(inKey, inValue, outKey, outValue, _transforms))
+                {
+                    outValue.endWriteEncaps();
+                    Dbt dbNewKey(&outKey.b[0], outKey.b.size()), dbNewValue(&outValue.b[0], outValue.b.size());
+                    if(dbNew->put(0, &dbNewKey, &dbNewValue, DB_NOOVERWRITE) == DB_KEYEXIST)
+                    {
+                        errorReporter()->error("duplicate key encountered");
+                    }
+                }
+            }
+            catch(const DeleteRecordException&)
+            {
+                // The record is deleted simply by not adding it to the new database.
+            }
+        }
+    }
+    catch(...)
+    {
+        if(dbc)
+        {
+            dbc->close();
+        }
+        communicator->removeObjectFactory("");
+        throw;
+    }
+
+    communicator->removeObjectFactory("");
+
+    if(dbc)
+    {
+        dbc->close();
+    }
+}
+
+//
+// DescriptorHandler
+//
+Transform::DescriptorHandler::DescriptorHandler(const DataFactoryPtr& factory, const Slice::UnitPtr& oldUnit,
+                                                const Slice::UnitPtr& newUnit, const ErrorReporterPtr& errorReporter) :
+    _factory(factory), _old(oldUnit), _new(newUnit), _errorReporter(errorReporter)
+{
+}
+
+void
+Transform::DescriptorHandler::startElement(const string& name, const IceXML::Attributes& attributes, int line,
+                                           int column)
+{
+    DescriptorPtr d;
+
+    if(name == "transformer")
+    {
+        if(_current)
+        {
+            _errorReporter->descriptorError("<transformer> must be the top-level element", line);
+        }
+
+        _transformer = new TransformerDescriptor(_factory, _old, _new, _errorReporter, line);
+        d = _transformer;
+    }
+    else if(name == "database")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<database> must be a child of <transformer>", line);
+        }
+
+        IceXML::Attributes::const_iterator p = attributes.find("key");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `key' is missing from <database>", line);
+        }
+        string keyTypes = p->second;
+
+        p = attributes.find("value");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `value' is missing from <database>", line);
+        }
+        string valueTypes = p->second;
+
+        d = new DatabaseDescriptor(_current, line, keyTypes, valueTypes);
+    }
+    else if(name == "record")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<record> must be a child of <database>", line);
+        }
+
+        d = new RecordDescriptor(_current, line);
+    }
+    else if(name == "transform")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<transform> must be a child of <transformer>", line);
+        }
+
+        IceXML::Attributes::const_iterator p;
+
+        string type;
+        p = attributes.find("type");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `type' is missing from <transform>", line);
+        }
+        type = p->second;
+
+        bool def = true;
+        p = attributes.find("default");
+        if(p != attributes.end())
+        {
+            if(p->second == "false")
+            {
+                def = false;
+            }
+        }
+
+        d = new TransformDescriptor(_current, line, type, def);
+    }
+    else if(name == "init")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<init> must be a child of <transformer>", line);
+        }
+
+        IceXML::Attributes::const_iterator p = attributes.find("type");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `type' is missing from <init>", line);
+        }
+
+        d = new InitDescriptor(_current, line, p->second);
+    }
+    else if(name == "set")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<set> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p;
+
+        string target, key, value, type;
+        bool convert = false;
+        p = attributes.find("target");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `target' is missing from <set>", line);
+        }
+        target = p->second;
+
+        p = attributes.find("key");
+        if(p != attributes.end())
+        {
+            key = p->second;
+        }
+
+        p = attributes.find("value");
+        if(p != attributes.end())
+        {
+            value = p->second;
+        }
+
+        p = attributes.find("type");
+        if(p != attributes.end())
+        {
+            type = p->second;
+        }
+
+        p = attributes.find("convert");
+        if(p != attributes.end())
+        {
+            convert = p->second == "true";
+        }
+
+        if((value.empty() && type.empty()) || (!value.empty() && !type.empty()))
+        {
+            _errorReporter->descriptorError("<set> requires one of the attributes `value' or 'type'", line);
+        }
+
+        d = new SetDescriptor(_current, line, target, key, value, type, convert);
+    }
+    else if(name == "remove")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<remove> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p;
+
+        string target, key;
+        p = attributes.find("target");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `target' is missing from <remove>", line);
+        }
+        target = p->second;
+
+        p = attributes.find("key");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `key' is missing from <remove>", line);
+        }
+        key = p->second;
+
+        d = new RemoveDescriptor(_current, line, target, key);
+    }
+    else if(name == "delete")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<delete> cannot be a top-level element", line);
+        }
+
+        d = new DeleteDescriptor(_current, line);
+    }
+    else if(name == "fail")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<fail> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p = attributes.find("message");
+        string message;
+        if(p != attributes.end())
+        {
+            message = p->second;
+        }
+
+        d = new FailDescriptor(_current, line, message);
+    }
+    else if(name == "echo")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<echo> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p;
+        string message, value;
+
+        p = attributes.find("message");
+        if(p != attributes.end())
+        {
+            message = p->second;
+        }
+
+        p = attributes.find("value");
+        if(p != attributes.end())
+        {
+            value = p->second;
+        }
+
+        d = new EchoDescriptor(_current, line, message, value);
+    }
+    else if(name == "if")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<if> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p = attributes.find("test");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `test' is missing from <if>", line);
+        }
+
+        d = new ConditionalDescriptor(_current, line, p->second);
+    }
+    else if(name == "iterate")
+    {
+        if(!_current)
+        {
+            _errorReporter->descriptorError("<iterate> cannot be a top-level element", line);
+        }
+
+        IceXML::Attributes::const_iterator p;
+        string target, key, value, element, index;
+
+        p = attributes.find("target");
+        if(p == attributes.end())
+        {
+            _errorReporter->descriptorError("required attribute `target' is missing from <iterate>", line);
+        }
+        target = p->second;
+
+        p = attributes.find("key");
+        if(p != attributes.end())
+        {
+            key = p->second;
+        }
+
+        p = attributes.find("value");
+        if(p != attributes.end())
+        {
+            value = p->second;
+        }
+
+        p = attributes.find("element");
+        if(p != attributes.end())
+        {
+            element = p->second;
+        }
+
+        p = attributes.find("index");
+        if(p != attributes.end())
+        {
+            index = p->second;
+        }
+
+        d = new IterateDescriptor(_current, line, target, key, value, element, index);
+    }
+    else
+    {
+        _errorReporter->descriptorError("unknown descriptor `" + name + "'", line);
+    }
+
+    if(_current)
+    {
+        _current->addChild(d);
+    }
+    _current = d;
+}
+
+void
+Transform::DescriptorHandler::endElement(const std::string& name, int, int)
+{
+    assert(_current);
+    _current = _current->parent();
+}
+
+void
+Transform::DescriptorHandler::characters(const std::string&, int, int)
+{
+}
+
+void
+Transform::DescriptorHandler::error(const std::string& msg, int line, int col)
+{
+    _errorReporter->descriptorError(msg, line);
+}
+
+Transform::TransformerDescriptorPtr
+Transform::DescriptorHandler::descriptor() const
+{
+    return _transformer;
+}
+
+//
+// TransformInterceptor
+//
+Transform::TransformInterceptor::TransformInterceptor(const DataFactoryPtr& factory,
+                                                      const ErrorReporterPtr& errorReporter,
+                                                      const Slice::UnitPtr& oldUnit,
+                                                      const Slice::UnitPtr& newUnit,
+                                                      const TransformMap& transformMap) :
+    _factory(factory), _errorReporter(errorReporter), _old(oldUnit), _new(newUnit), _transformMap(transformMap)
+{
+}
+
+bool
+Transform::TransformInterceptor::preTransform(const DataPtr& dest, const DataPtr&)
+{
+    //
+    // Allow a transform descriptor to disable the default transformation.
+    //
+    string type = typeName(dest->getType());
+    TransformMap::const_iterator p = _transformMap.find(type);
+    if(p != _transformMap.end())
+    {
+        return p->second->doDefaultTransform();
+    }
+
+    return true;
+}
+
+void
+Transform::TransformInterceptor::postTransform(const DataPtr& dest, const DataPtr& src)
+{
+    //
+    // Execute the type's transform (if any).
+    //
+    string type = typeName(dest->getType());
+    TransformMap::const_iterator p = _transformMap.find(type);
+    if(p != _transformMap.end())
+    {
+        bool raise = _errorReporter->raise();
+        _errorReporter->raise(true);
+        TransformSymbolTable sym(_factory, _old, _new, _errorReporter);
+        sym.add("new", dest);
+        sym.add("old", src);
+        try
+        {
+            p->second->execute(sym, *this);
+            _errorReporter->raise(raise);
+        }
+        catch(...)
+        {
+            _errorReporter->raise(raise);
+            throw;
+        }
+    }
+}
+
+Transform::ObjectDataMap&
+Transform::TransformInterceptor::getObjectMap()
+{
+    return _objectMap;
+}
+
+//
+// Transformer
+//
+Transform::Transformer::Transformer(const Ice::CommunicatorPtr& communicator, const Slice::UnitPtr& oldUnit,
+                                    const Slice::UnitPtr& newUnit, bool ignoreTypeChanges) :
+    _communicator(communicator), _old(oldUnit), _new(newUnit), _ignoreTypeChanges(ignoreTypeChanges)
+{
+}
+
+void
+Transform::Transformer::analyze(const string& oldKey, const string& newKey, const string& oldValue,
+                                const string& newValue, ostream& descriptors, Ice::StringSeq& missingTypes,
+                                Ice::StringSeq& errors)
+{
+    //
+    // Look up the Slice definitions for the key and value types.
+    //
+    Slice::TypePtr oldKeyType = findType(_old, oldKey, errors);
+    Slice::TypePtr newKeyType = findType(_new, newKey, errors);
+    Slice::TypePtr oldValueType = findType(_old, oldValue, errors);
+    Slice::TypePtr newValueType = findType(_new, newValue, errors);
+    if(!oldKeyType || !newKeyType || !oldValueType || !newValueType)
+    {
+        return;
+    }
+
+    Analyzer analyzer(_old, _new, _ignoreTypeChanges);
+    analyzer.analyze(oldKeyType, newKeyType, oldValueType, newValueType, descriptors, missingTypes, errors);
+}
+
+void
+Transform::Transformer::analyze(ostream& descriptors, Ice::StringSeq& missingTypes, Ice::StringSeq& errors)
+{
+    createEvictorSliceTypes(_old);
+    createEvictorSliceTypes(_new);
+
+    const string keyType = "::Freeze::EvictorStorageKey";
+    const string valueType = "::Freeze::ObjectRecord";
+    analyze(keyType, keyType, valueType, valueType, descriptors, missingTypes, errors);
+}
+
+void
+Transform::Transformer::transform(istream& is, Db* db, Db* dbNew, ostream& errors)
+{
+    createCoreSliceTypes(_old);
+    createCoreSliceTypes(_new);
+
+    ErrorReporterPtr errorReporter = new ErrorReporter(errors);
+
+    try
+    {
+        DataFactoryPtr factory = new DataFactory(_communicator, _new, errorReporter);
+        DescriptorHandler dh(factory, _old, _new, errorReporter);
+        IceXML::Parser::parse(is, dh);
+
+        TransformerDescriptorPtr descriptor = dh.descriptor();
+        descriptor->validate();
+        descriptor->transform(_communicator, db, dbNew);
+    }
+    catch(const IceXML::ParserException& ex)
+    {
+        errorReporter->error(ex.reason());
+    }
+}
+
+void
+Transform::Transformer::createCoreSliceTypes(const Slice::UnitPtr& unit)
+{
+    string scoped;
+    Slice::TypeList l;
+    Slice::ContainedList c;
+
+    //
+    // Create the Slice definition for _FacetMap if it doesn't exist. This type is
+    // necessary for marshaling an object's facet map.
+    //
+    l = unit->lookupTypeNoBuiltin("::_FacetMap", false);
+    if(l.empty())
+    {
+        Slice::TypePtr str = unit->builtin(Slice::Builtin::KindString);
+        Slice::TypePtr obj = unit->builtin(Slice::Builtin::KindObject);
+        unit->createDictionary("_FacetMap", str, obj, false);
+    }
+    else
+    {
+        assert(Slice::DictionaryPtr::dynamicCast(l.front()));
+    }
+}
+
+void
+Transform::Transformer::createEvictorSliceTypes(const Slice::UnitPtr& unit)
+{
+    string scoped;
+    Slice::TypeList l;
+    Slice::ContainedList c;
+
+    //
+    // Create the Ice module if necessary.
+    //
+    c = unit->lookupContained("Ice", false);
+    Slice::ModulePtr ice;
+    if(c.empty())
+    {
+        ice = unit->createModule("Ice");
+    }
+    else
+    {
+        ice = Slice::ModulePtr::dynamicCast(c.front());
+        if(!ice)
+        {
+            throw TransformException(__FILE__, __LINE__,
+                                     "the symbol `::Ice' is defined in Slice but is not a module");
+        }
+    }
+
+    //
+    // Create the Slice definition for Ice::Identity if it doesn't exist.
+    //
+    scoped = "::Ice::Identity";
+    l = unit->lookupTypeNoBuiltin(scoped, false);
+    Slice::StructPtr identity;
+    if(l.empty())
+    {
+        identity = ice->createStruct("Identity", false);
+        Slice::TypePtr str = unit->builtin(Slice::Builtin::KindString);
+        identity->createDataMember("category", str);
+        identity->createDataMember("name", str);
+    }
+    else
+    {
+        identity = Slice::StructPtr::dynamicCast(l.front());
+        if(!identity)
+        {
+            throw TransformException(__FILE__, __LINE__,
+                                     "the symbol `::Ice::Identity' is defined in Slice but is not a struct");
+        }
+    }
+
+    //
+    // Create the Slice definition for Ice::FacetPath if it doesn't exist.
+    //
+    scoped = "::Ice::FacetPath";
+    l = unit->lookupTypeNoBuiltin(scoped, false);
+    Slice::SequencePtr facetPath;
+    if(l.empty())
+    {
+        Slice::TypePtr str = unit->builtin(Slice::Builtin::KindString);
+        facetPath = ice->createSequence("FacetPath", str, false);
+    }
+    else
+    {
+        facetPath = Slice::SequencePtr::dynamicCast(l.front());
+        if(!facetPath)
+        {
+            throw TransformException(__FILE__, __LINE__,
+                                     "the symbol `::Ice::FacetPath' is defined in Slice but is not a sequence");
+        }
+    }
+
+    //
+    // Create the Freeze module if necessary.
+    //
+    c = unit->lookupContained("Freeze", false);
+    Slice::ModulePtr freeze;
+    if(c.empty())
+    {
+        freeze = unit->createModule("Freeze");
+    }
+    else
+    {
+        freeze = Slice::ModulePtr::dynamicCast(c.front());
+        if(!freeze)
+        {
+            throw TransformException(__FILE__, __LINE__,
+                                     "the symbol `::Freeze' is defined in Slice but is not a module");
+        }
+    }
+
+    //
+    // Create the Slice definition for Freeze::EvictorStorageKey if it doesn't exist.
+    //
+    scoped = "::Freeze::EvictorStorageKey";
+    l = unit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        Slice::StructPtr esk = freeze->createStruct("EvictorStorageKey", false);
+        esk->createDataMember("identity", identity);
+        esk->createDataMember("facet", facetPath);
+    }
+    else
+    {
+        if(!Slice::StructPtr::dynamicCast(l.front()))
+        {
+            throw TransformException(__FILE__, __LINE__, "the symbol `::Freeze::EvictorStorageKey' is defined in "
+                                     "Slice but is not a struct");
+        }
+    }
+
+    //
+    // Create the Slice definition for Freeze::Statistics if it doesn't exist.
+    //
+    scoped = "::Freeze::Statistics";
+    l = unit->lookupTypeNoBuiltin(scoped, false);
+    Slice::StructPtr stats;
+    if(l.empty())
+    {
+        stats = freeze->createStruct("Statistics", false);
+        Slice::TypePtr tl = unit->builtin(Slice::Builtin::KindLong);
+        stats->createDataMember("creationTime", tl);
+        stats->createDataMember("lastSaveTime", tl);
+        stats->createDataMember("avgSaveTime", tl);
+    }
+    else
+    {
+        stats = Slice::StructPtr::dynamicCast(l.front());
+        if(!stats)
+        {
+            throw TransformException(__FILE__, __LINE__, "the symbol `::Freeze::Statistics' is defined in "
+                                     "Slice but is not a struct");
+        }
+    }
+
+    //
+    // Create the Slice definition for Freeze::ObjectRecord if it doesn't exist.
+    //
+    scoped = "::Freeze::ObjectRecord";
+    l = unit->lookupTypeNoBuiltin(scoped, false);
+    if(l.empty())
+    {
+        Slice::StructPtr rec = freeze->createStruct("ObjectRecord", false);
+        Slice::TypePtr obj = unit->builtin(Slice::Builtin::KindObject);
+        rec->createDataMember("servant", obj);
+        rec->createDataMember("stats", stats);
+    }
+    else
+    {
+        if(!Slice::StructPtr::dynamicCast(l.front()))
+        {
+            throw TransformException(__FILE__, __LINE__, "the symbol `::Freeze::ObjectRecord' is defined in "
+                                     "Slice but is not a struct");
+        }
+    }
+}
+
+Slice::TypePtr
+Transform::Transformer::findType(const Slice::UnitPtr& u, const string& type, Ice::StringSeq& errors)
+{
+    Slice::TypeList l;
+
+    l = u->lookupType(type, false);
+    if(l.empty())
+    {
+        errors.push_back("error: unknown type `" + type + "'");
+        return 0;
+    }
+
+    return l.front();
+}