sequence, dictionary

43 files changed, 703 insertions, 474 deletions

diff --git a/cpp/include/Slice/Parser.h b/cpp/include/Slice/Parser.h
index c4a030b9ad9..660f5ba9992 100644
--- a/cpp/include/Slice/Parser.h
+++ b/cpp/include/Slice/Parser.h
@@ -39,8 +39,8 @@ class Proxy;
 class Struct;
 class Operation;
 class DataMember;
-class Vector;
-class Map;
+class Sequence;
+class Dictionary;
 class Enum;
 class Enumerator;
 class Native;
@@ -79,10 +79,10 @@ void ICE_API incRef(::Slice::Operation*);
 void ICE_API decRef(::Slice::Operation*);
 void ICE_API incRef(::Slice::DataMember*);
 void ICE_API decRef(::Slice::DataMember*);
-void ICE_API incRef(::Slice::Vector*);
-void ICE_API decRef(::Slice::Vector*);
-void ICE_API incRef(::Slice::Map*);
-void ICE_API decRef(::Slice::Map*);
+void ICE_API incRef(::Slice::Sequence*);
+void ICE_API decRef(::Slice::Sequence*);
+void ICE_API incRef(::Slice::Dictionary*);
+void ICE_API decRef(::Slice::Dictionary*);
 void ICE_API incRef(::Slice::Enum*);
 void ICE_API decRef(::Slice::Enum*);
 void ICE_API incRef(::Slice::Enumerator*);
@@ -111,8 +111,8 @@ typedef ::IceInternal::Handle<Proxy> ProxyPtr;
 typedef ::IceInternal::Handle<Struct> StructPtr;
 typedef ::IceInternal::Handle<Operation> OperationPtr;
 typedef ::IceInternal::Handle<DataMember> DataMemberPtr;
-typedef ::IceInternal::Handle<Vector> VectorPtr;
-typedef ::IceInternal::Handle<Map> MapPtr;
+typedef ::IceInternal::Handle<Sequence> SequencePtr;
+typedef ::IceInternal::Handle<Dictionary> DictionaryPtr;
 typedef ::IceInternal::Handle<Enum> EnumPtr;
 typedef ::IceInternal::Handle<Enumerator> EnumeratorPtr;
 typedef ::IceInternal::Handle<Native> NativePtr;
@@ -131,8 +131,8 @@ typedef std::list<ContainedPtr> ContainedList;
 typedef std::list<ModulePtr> ModuleList;
 typedef std::list<ClassDefPtr> ClassList;
 typedef std::list<StructPtr> StructList;
-typedef std::list<VectorPtr> VectorList;
-typedef std::list<MapPtr> MapList;
+typedef std::list<SequencePtr> SequenceList;
+typedef std::list<DictionaryPtr> DictionaryList;
 typedef std::list<EnumPtr> EnumList;
 typedef std::list<NativePtr> NativeList;
 typedef std::list<OperationPtr> OperationList;
@@ -158,8 +158,8 @@ public:
     virtual void visitStructEnd(const StructPtr&) { }
     virtual void visitOperation(const OperationPtr&) { }
     virtual void visitDataMember(const DataMemberPtr&) { }
-    virtual void visitVector(const VectorPtr&) { }
-    virtual void visitMap(const MapPtr&) { }
+    virtual void visitSequence(const SequencePtr&) { }
+    virtual void visitDictionary(const DictionaryPtr&) { }
     virtual void visitEnum(const EnumPtr&) { }
     virtual void visitNative(const NativePtr&) { }
 };
@@ -255,8 +255,8 @@ public:
 
     enum ContainedType
     {
-	ContainedTypeVector,
-	ContainedTypeMap,
+	ContainedTypeSequence,
+	ContainedTypeDictionary,
 	ContainedTypeEnum,
 	ContainedTypeEnumerator,
 	ContainedTypeNative,
@@ -295,8 +295,8 @@ public:
     ClassDefPtr createClassDef(const std::string&, bool, bool, const ClassList&);
     ClassDeclPtr createClassDecl(const std::string&, bool, bool);
     StructPtr createStruct(const std::string&);
-    VectorPtr createVector(const std::string&, const TypePtr&);
-    MapPtr createMap(const std::string&, const TypePtr&, const TypePtr&);
+    SequencePtr createSequence(const std::string&, const TypePtr&);
+    DictionaryPtr createDictionary(const std::string&, const TypePtr&, const TypePtr&);
     EnumPtr createEnum(const std::string&, const StringList&);
     EnumeratorPtr createEnumerator(const std::string&);
     NativePtr createNative(const std::string&);
@@ -306,8 +306,8 @@ public:
     ModuleList modules();
     ClassList classes();
     StructList structs();
-    VectorList vectors();
-    MapList maps();
+    SequenceList sequences();
+    DictionaryList dictionaries();
     EnumList enums();
     NativeList natives();
     int includeLevel();
@@ -505,10 +505,10 @@ protected:
 };
 
 // ----------------------------------------------------------------------
-// Vector
+// Sequence
 // ----------------------------------------------------------------------
 
-class ICE_API Vector : virtual public Constructed
+class ICE_API Sequence : virtual public Constructed
 {
 public:
 
@@ -518,17 +518,17 @@ public:
 
 protected:
 
-    Vector(const ContainerPtr&, const std::string&, const TypePtr&);
+    Sequence(const ContainerPtr&, const std::string&, const TypePtr&);
     friend class ICE_API Container;
 
     TypePtr _type;
 };
 
 // ----------------------------------------------------------------------
-// Map
+// Dictionary
 // ----------------------------------------------------------------------
 
-class ICE_API Map : virtual public Constructed
+class ICE_API Dictionary : virtual public Constructed
 {
 public:
 
@@ -539,7 +539,7 @@ public:
 
 protected:
 
-    Map(const ContainerPtr&, const std::string&, const TypePtr&, const TypePtr&);
+    Dictionary(const ContainerPtr&, const std::string&, const TypePtr&, const TypePtr&);
     friend class ICE_API Container;
 
     TypePtr _keyType;
diff --git a/cpp/slice/IcePack/Admin.ice b/cpp/slice/IcePack/Admin.ice
index 1d36f3a45c0..ea84a58c600 100644
--- a/cpp/slice/IcePack/Admin.ice
+++ b/cpp/slice/IcePack/Admin.ice
@@ -24,7 +24,7 @@ module IcePack
  * A vector of strings representing command line arguments.
  *
  **/
-vector<string> Args;
+sequence<string> Args;
 
 /**
  *
@@ -96,7 +96,7 @@ class ServerDescription
  * A vector of server descriptions.
  *
  **/
-vector<ServerDescription> ServerDescriptions;
+sequence<ServerDescription> ServerDescriptions;
 
 /**
  *
diff --git a/cpp/src/Slice/Grammer.y b/cpp/src/Slice/Grammer.y
index 026daa19d42..30520b322a4 100644
--- a/cpp/src/Slice/Grammer.y
+++ b/cpp/src/Slice/Grammer.y
@@ -45,8 +45,8 @@ yyerror(const char* s)
 %token ICE_OBJECT
 %token ICE_LOCAL_OBJECT
 %token ICE_NATIVE
-%token ICE_VECTOR
-%token ICE_MAP
+%token ICE_SEQUENCE
+%token ICE_DICTIONARY
 %token ICE_ENUM
 %token ICE_NONMUTATING
 %token ICE_IDENTIFIER
@@ -105,10 +105,10 @@ definition
 | native_def
 {
 }
-| vector_def
+| sequence_def
 {
 }
-| map_def
+| dictionary_def
 {
 }
 | enum_def
@@ -706,27 +706,27 @@ native_def
 ;
 
 // ----------------------------------------------------------------------
-vector_def
+sequence_def
 // ----------------------------------------------------------------------
-: ICE_VECTOR '<' type '>' ICE_IDENTIFIER
+: ICE_SEQUENCE '<' type '>' ICE_IDENTIFIER
 {
     StringTokPtr ident = StringTokPtr::dynamicCast($5);
     TypePtr type = TypePtr::dynamicCast($3);
     ContainerPtr cont = unit->currentContainer();
-    cont->createVector(ident->v, type);
+    cont->createSequence(ident->v, type);
 }
 ;
 
 // ----------------------------------------------------------------------
-map_def
+dictionary_def
 // ----------------------------------------------------------------------
-: ICE_MAP '<' type ',' type '>' ICE_IDENTIFIER
+: ICE_DICTIONARY '<' type ',' type '>' ICE_IDENTIFIER
 {
     StringTokPtr ident = StringTokPtr::dynamicCast($7);
     TypePtr keyType = TypePtr::dynamicCast($3);
     TypePtr valueType = TypePtr::dynamicCast($5);
     ContainerPtr cont = unit->currentContainer();
-    cont->createMap(ident->v, keyType, valueType);
+    cont->createDictionary(ident->v, keyType, valueType);
 }
 ;
 
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index ac26565e3a2..5b655387fd1 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -49,10 +49,10 @@ void IceInternal::incRef(Operation* p) { p->__incRef(); }
 void IceInternal::decRef(Operation* p) { p->__decRef(); }
 void IceInternal::incRef(DataMember* p) { p->__incRef(); }
 void IceInternal::decRef(DataMember* p) { p->__decRef(); }
-void IceInternal::incRef(Vector* p) { p->__incRef(); }
-void IceInternal::decRef(Vector* p) { p->__decRef(); }
-void IceInternal::incRef(Map* p) { p->__incRef(); }
-void IceInternal::decRef(Map* p) { p->__decRef(); }
+void IceInternal::incRef(Sequence* p) { p->__incRef(); }
+void IceInternal::decRef(Sequence* p) { p->__decRef(); }
+void IceInternal::incRef(Dictionary* p) { p->__incRef(); }
+void IceInternal::decRef(Dictionary* p) { p->__decRef(); }
 void IceInternal::incRef(Enum* p) { p->__incRef(); }
 void IceInternal::decRef(Enum* p) { p->__decRef(); }
 void IceInternal::incRef(Enumerator* p) { p->__incRef(); }
@@ -406,13 +406,13 @@ Slice::Container::createStruct(const string& name)
     return p;
 }
 
-VectorPtr
-Slice::Container::createVector(const string& name, const TypePtr& type)
+SequencePtr
+Slice::Container::createSequence(const string& name, const TypePtr& type)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
     {
-	VectorPtr p = VectorPtr::dynamicCast(matches.front());
+	SequencePtr p = SequencePtr::dynamicCast(matches.front());
 	if (p)
 	{
 	    if (_unit->ignRedefs())
@@ -420,7 +420,7 @@ Slice::Container::createVector(const string& name, const TypePtr& type)
 		return p;
 	    }
 
-	    string msg = "redefinition of vector `";
+	    string msg = "redefinition of sequence `";
 	    msg += name;
 	    msg += "'";
 	    _unit->error(msg);
@@ -429,23 +429,23 @@ Slice::Container::createVector(const string& name, const TypePtr& type)
 	
 	string msg = "redefinition of `";
 	msg += name;
-	msg += "' as vector";
+	msg += "' as sequence";
 	_unit->error(msg);
 	return 0;
     }
 
-    VectorPtr p = new Vector(this, name, type);
+    SequencePtr p = new Sequence(this, name, type);
     _contents.push_back(p);
     return p;
 }
 
-MapPtr
-Slice::Container::createMap(const string& name, const TypePtr& keyType, const TypePtr& valueType)
+DictionaryPtr
+Slice::Container::createDictionary(const string& name, const TypePtr& keyType, const TypePtr& valueType)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
     {
-	MapPtr p = MapPtr::dynamicCast(matches.front());
+	DictionaryPtr p = DictionaryPtr::dynamicCast(matches.front());
 	if (p)
 	{
 	    if (_unit->ignRedefs())
@@ -453,7 +453,7 @@ Slice::Container::createMap(const string& name, const TypePtr& keyType, const Ty
 		return p;
 	    }
 
-	    string msg = "redefinition of map `";
+	    string msg = "redefinition of dictionary `";
 	    msg += name;
 	    msg += "'";
 	    _unit->error(msg);
@@ -462,12 +462,12 @@ Slice::Container::createMap(const string& name, const TypePtr& keyType, const Ty
 	
 	string msg = "redefinition of `";
 	msg += name;
-	msg += "' as map";
+	msg += "' as dictionary";
 	_unit->error(msg);
 	return 0;
     }
 
-    MapPtr p = new Map(this, name, keyType, valueType);
+    DictionaryPtr p = new Dictionary(this, name, keyType, valueType);
     _contents.push_back(p);
     return p;
 }
@@ -747,13 +747,13 @@ Slice::Container::structs()
     return result;
 }
 
-VectorList
-Slice::Container::vectors()
+SequenceList
+Slice::Container::sequences()
 {
-    VectorList result;
+    SequenceList result;
     for (ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
     {
-	VectorPtr q = VectorPtr::dynamicCast(*p);
+	SequencePtr q = SequencePtr::dynamicCast(*p);
 	if (q)
 	{
 	    result.push_back(q);
@@ -762,13 +762,13 @@ Slice::Container::vectors()
     return result;
 }
 
-MapList
-Slice::Container::maps()
+DictionaryList
+Slice::Container::dictionaries()
 {
-    MapList result;
+    DictionaryList result;
     for (ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
     {
-	MapPtr q = MapPtr::dynamicCast(*p);
+	DictionaryPtr q = DictionaryPtr::dynamicCast(*p);
 	if (q)
 	{
 	    result.push_back(q);
@@ -1647,28 +1647,28 @@ Slice::Native::Native(const ContainerPtr& container, const string& name) :
 }
 
 // ----------------------------------------------------------------------
-// Vector
+// Sequence
 // ----------------------------------------------------------------------
 
 TypePtr
-Slice::Vector::type()
+Slice::Sequence::type()
 {
     return _type;
 }
 
 Slice::Contained::ContainedType
-Slice::Vector::containedType()
+Slice::Sequence::containedType()
 {
-    return ContainedTypeVector;
+    return ContainedTypeSequence;
 }
 
 void
-Slice::Vector::visit(ParserVisitor* visitor)
+Slice::Sequence::visit(ParserVisitor* visitor)
 {
-    visitor->visitVector(this);
+    visitor->visitSequence(this);
 }
 
-Slice::Vector::Vector(const ContainerPtr& container, const string& name, const TypePtr& type) :
+Slice::Sequence::Sequence(const ContainerPtr& container, const string& name, const TypePtr& type) :
     Constructed(container, name),
     Type(container->unit()),
     Contained(container, name),
@@ -1678,34 +1678,35 @@ Slice::Vector::Vector(const ContainerPtr& container, const string& name, const T
 }
 
 // ----------------------------------------------------------------------
-// Map
+// Dictionary
 // ----------------------------------------------------------------------
 
 TypePtr
-Slice::Map::keyType()
+Slice::Dictionary::keyType()
 {
     return _keyType;
 }
 
 TypePtr
-Slice::Map::valueType()
+Slice::Dictionary::valueType()
 {
     return _valueType;
 }
 
 Slice::Contained::ContainedType
-Slice::Map::containedType()
+Slice::Dictionary::containedType()
 {
-    return ContainedTypeMap;
+    return ContainedTypeDictionary;
 }
 
 void
-Slice::Map::visit(ParserVisitor* visitor)
+Slice::Dictionary::visit(ParserVisitor* visitor)
 {
-    visitor->visitMap(this);
+    visitor->visitDictionary(this);
 }
 
-Slice::Map::Map(const ContainerPtr& container, const string& name, const TypePtr& keyType, const TypePtr& valueType) :
+Slice::Dictionary::Dictionary(const ContainerPtr& container, const string& name, const TypePtr& keyType,
+			      const TypePtr& valueType) :
     Constructed(container, name),
     Type(container->unit()),
     Contained(container, name),
diff --git a/cpp/src/Slice/Scanner.l b/cpp/src/Slice/Scanner.l
index bb4980ebc32..28ae3658b92 100644
--- a/cpp/src/Slice/Scanner.l
+++ b/cpp/src/Slice/Scanner.l
@@ -181,12 +181,12 @@ L	[a-zA-Z_]
     return ICE_NATIVE;
 }
 
-"vector" {
-    return ICE_VECTOR;
+"sequence" {
+    return ICE_SEQUENCE;
 }
 
-"map" {
-    return ICE_MAP;
+"dictionary" {
+    return ICE_DICTIONARY;
 }
 
 "enum" {
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index bdd00d101c4..040da988a2c 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -280,11 +280,11 @@ Slice::Gen::TypesVisitor::visitModuleEnd(const ModulePtr& p)
 }
 
 void
-Slice::Gen::TypesVisitor::visitVector(const VectorPtr& p)
+Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
 {
     string name = p->name();
-    TypePtr subtype = p->type();
-    string s = typeToString(subtype);
+    TypePtr type = p->type();
+    string s = typeToString(type);
     if (s[0] == ':')
     {
 	s.insert(0, " ");
@@ -292,7 +292,7 @@ Slice::Gen::TypesVisitor::visitVector(const VectorPtr& p)
     H << sp;
     H << nl << "typedef ::std::vector<" << s << "> " << name << ';';
 
-    BuiltinPtr builtin = BuiltinPtr::dynamicCast(subtype);
+    BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if (!builtin)
     {
 	string scoped = p->scoped();
@@ -315,7 +315,7 @@ Slice::Gen::TypesVisitor::visitVector(const VectorPtr& p)
 	C << nl << scoped << "::const_iterator p;";
 	C << nl << "for (p = v.begin(); p != v.end(); ++p)";
 	C << sb;
-	writeMarshalUnmarshalCode(C, subtype, "*p", true);
+	writeMarshalUnmarshalCode(C, type, "*p", true);
 	C << eb;
 	C << eb;
 	C << sp;
@@ -331,7 +331,7 @@ Slice::Gen::TypesVisitor::visitVector(const VectorPtr& p)
 	C.zeroIndent();
 	C << nl << "#ifdef WIN32"; // STLBUG
 	C.restoreIndent();
-	C << nl << "v.push_back(" << typeToString(subtype) << "());";
+	C << nl << "v.push_back(" << typeToString(type) << "());";
 	C.zeroIndent();
 	C << nl << "#else";
 	C.restoreIndent();
@@ -339,13 +339,67 @@ Slice::Gen::TypesVisitor::visitVector(const VectorPtr& p)
 	C.zeroIndent();
 	C << nl << "#endif";
 	C.restoreIndent();
-	writeMarshalUnmarshalCode(C, subtype, "v.back()", false);
+	writeMarshalUnmarshalCode(C, type, "v.back()", false);
 	C << eb;
 	C << eb;
     }
 }
 
 void
+Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
+{
+    string name = p->name();
+    TypePtr keyType = p->keyType();
+    TypePtr valueType = p->valueType();
+    string ks = typeToString(keyType);
+    if (ks[0] == ':')
+    {
+	ks.insert(0, " ");
+    }
+    string vs = typeToString(valueType);
+    H << sp;
+    H << nl << "typedef ::std::map<" << ks << ", " << vs << "> " << name << ';';
+
+    string scoped = p->scoped();
+    string scope = p->scope();
+    if (scope.length())
+    {
+	scope.erase(0, 2);
+    }
+    
+    H << sp;
+    H << nl << "class __U__" << name << " { };";
+    H << nl << "void" << _dllExport << " __write(::IceInternal::Stream*, const " << name << "&, __U__" << name << ");";
+    H << nl << "void" << _dllExport << " __read(::IceInternal::Stream*, " << name << "&, __U__" << name << ");";
+    C << sp;
+    C << nl << "void" << nl << scope << "::__write(::IceInternal::Stream* __os, const " << scoped << "& v, ::"
+      << scope << "::__U__" << name << ')';
+    C << sb;
+    C << nl << "__os->write(::Ice::Int(v.size()));";
+    C << nl << scoped << "::const_iterator p;";
+    C << nl << "for (p = v.begin(); p != v.end(); ++p)";
+    C << sb;
+    writeMarshalUnmarshalCode(C, keyType, "p->first", true);
+    writeMarshalUnmarshalCode(C, valueType, "p->second", true);
+    C << eb;
+    C << eb;
+    C << sp;
+    C << nl << "void" << nl << scope << "::__read(::IceInternal::Stream* __is, " << scoped << "& v, ::" << scope
+      << "::__U__" << name << ')';
+    C << sb;
+    C << nl << "::Ice::Int sz;";
+    C << nl << "__is->read(sz);";
+    C << nl << "while (sz--)";
+    C << sb;
+    C << nl << "::std::pair<" << ks << ", " << vs << "> pair;";
+    writeMarshalUnmarshalCode(C, keyType, "pair.first", false);
+    writeMarshalUnmarshalCode(C, valueType, "pair.second", false);
+    C << nl << "v.insert(v.end(), pair);";
+    C << eb;
+    C << eb;
+}
+
+void
 Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
 {
     string name = p->name();
diff --git a/cpp/src/slice2cpp/Gen.h b/cpp/src/slice2cpp/Gen.h
index 7019d69d868..77002b264a3 100644
--- a/cpp/src/slice2cpp/Gen.h
+++ b/cpp/src/slice2cpp/Gen.h
@@ -53,7 +53,8 @@ private:
 
 	virtual void visitModuleStart(const ModulePtr&);
 	virtual void visitModuleEnd(const ModulePtr&);
-	virtual void visitVector(const VectorPtr&);
+	virtual void visitSequence(const SequencePtr&);
+	virtual void visitDictionary(const DictionaryPtr&);
 	virtual void visitEnum(const EnumPtr&);
 	virtual void visitNative(const NativePtr&);
 
diff --git a/cpp/src/slice2cpp/GenUtil.cpp b/cpp/src/slice2cpp/GenUtil.cpp
index 4249d7a7cda..1a94c7a1a41 100644
--- a/cpp/src/slice2cpp/GenUtil.cpp
+++ b/cpp/src/slice2cpp/GenUtil.cpp
@@ -287,21 +287,29 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, const string&
 	return;
     }
     
-    VectorPtr vec = VectorPtr::dynamicCast(type);
-    if (vec)
+    SequencePtr seq = SequencePtr::dynamicCast(type);
+    if (seq)
     {
-	if (BuiltinPtr::dynamicCast(vec->type()))
+	if (BuiltinPtr::dynamicCast(seq->type()))
 	{
 	    out << nl << stream << "->" << func << param << ");";
 	}
 	else
 	{
-	    out << nl << vec->scope() << "::__" << func << stream << ", " << param << ", " << vec->scope()
-		<< "::__U__" << vec->name() << "());";
+	    out << nl << seq->scope() << "::__" << func << stream << ", " << param << ", " << seq->scope()
+		<< "::__U__" << seq->name() << "());";
 	}
 	return;
     }
     
+    DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
+    if (dict)
+    {
+	out << nl << dict->scope() << "::__" << func << stream << ", " << param << ", " << dict->scope()
+	    << "::__U__" << dict->name() << "());";
+	return;
+    }
+    
     NativePtr native = NativePtr::dynamicCast(type);
     assert(!native); // TODO
     
diff --git a/cpp/src/slice2docbook/Gen.cpp b/cpp/src/slice2docbook/Gen.cpp
index f0dbc86d38c..d65d7588f23 100644
--- a/cpp/src/slice2docbook/Gen.cpp
+++ b/cpp/src/slice2docbook/Gen.cpp
@@ -173,14 +173,60 @@ Slice::Gen::visitContainer(const ContainerPtr& p)
 	end();
     }
 
-    VectorList vectors = p->vectors();
-    vectors.sort();
-    if (!vectors.empty())
+    StructList structs = p->structs();
+    structs.sort();
+    if (!structs.empty())
     {
-	start("section", "Vector Index");
+	start("section", "Struct Index");
 	start("variablelist");
 	
-	for (VectorList::iterator q = vectors.begin(); q != vectors.end(); ++q)
+	for (StructList::iterator q = structs.begin(); q != structs.end(); ++q)
+	{
+	    start("varlistentry");
+	    start("term");
+	    O << nl << toString(*q, p);
+	    end();
+	    start("listitem");
+	    printSummary(*q);
+	    end();
+	    end();
+	}
+
+	end();
+	end();
+    }
+
+    SequenceList sequences = p->sequences();
+    sequences.sort();
+    if (!sequences.empty())
+    {
+	start("section", "Sequence Index");
+	start("variablelist");
+	
+	for (SequenceList::iterator q = sequences.begin(); q != sequences.end(); ++q)
+	{
+	    start("varlistentry");
+	    start("term");
+	    O << nl << toString(*q, p);
+	    end();
+	    start("listitem");
+	    printSummary(*q);
+	    end();
+	    end();
+	}
+
+	end();
+	end();
+    }
+
+    DictionaryList dictionaries = p->dictionaries();
+    dictionaries.sort();
+    if (!dictionaries.empty())
+    {
+	start("section", "Dictionary Index");
+	start("variablelist");
+	
+	for (DictionaryList::iterator q = dictionaries.begin(); q != dictionaries.end(); ++q)
 	{
 	    start("varlistentry");
 	    start("term");
@@ -245,14 +291,14 @@ Slice::Gen::visitContainer(const ContainerPtr& p)
     end();
 
     {
-	for (VectorList::iterator q = vectors.begin(); q != vectors.end(); ++q)
+	for (SequenceList::iterator q = sequences.begin(); q != sequences.end(); ++q)
 	{
 	    TypePtr type = (*q)->type();
 	    
 	    start("section id=" + scopedToId((*q)->scoped()), (*q)->name());
 	    
 	    O.zeroIndent();
-	    O << nl << "<synopsis>vector&lt; " << toString(type, p) << " &gt; <type>" << (*q)->name()
+	    O << nl << "<synopsis>sequence&lt; " << toString(type, p) << " &gt; <type>" << (*q)->name()
 	      << "</type>;</synopsis>";
 	    O.restoreIndent();
 	    
@@ -263,6 +309,25 @@ Slice::Gen::visitContainer(const ContainerPtr& p)
     }
     
     {
+	for (DictionaryList::iterator q = dictionaries.begin(); q != dictionaries.end(); ++q)
+	{
+	    TypePtr keyType = (*q)->keyType();
+	    TypePtr valueType = (*q)->valueType();
+	    
+	    start("section id=" + scopedToId((*q)->scoped()), (*q)->name());
+	    
+	    O.zeroIndent();
+	    O << nl << "<synopsis>dictionary&lt; " << toString(keyType, p) << ", " << toString(valueType, p)
+	      << " &gt; <type>" << (*q)->name() << "</type>;</synopsis>";
+	    O.restoreIndent();
+	    
+	    printComment(*q);
+	    
+	    end();
+	}
+    }
+    
+    {
 	for (EnumList::iterator q = enums.begin(); q != enums.end(); ++q)
 	{
 	    start("section id=" + scopedToId((*q)->scoped()), (*q)->name());
@@ -504,6 +569,66 @@ Slice::Gen::visitClassDefStart(const ClassDefPtr& p)
 }
 
 void
+Slice::Gen::visitStructStart(const StructPtr& p)
+{
+    start(_chapter + " id=" + scopedToId(p->scoped()), p->scoped().substr(2));
+
+    start("section", "Overview");
+    O.zeroIndent();
+    O << nl << "<synopsis>";
+    O << "struct <structname>" << p->name() << "</structname>";
+    O << "</synopsis>";
+    O.restoreIndent();
+
+    printComment(p);
+
+    DataMemberList dataMembers = p->dataMembers();
+    dataMembers.sort();
+    if (!dataMembers.empty())
+    {
+	start("section", "Data Member Index");
+	start("variablelist");
+	
+	for (DataMemberList::iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+	{
+	    start("varlistentry");
+	    start("term");
+	    O << nl << toString(*q, p);
+	    end();
+	    start("listitem");
+	    printSummary(*q);
+	    end();
+	    end();
+	}
+
+	end();
+	end();
+    }
+
+    end();
+
+    {
+	for (DataMemberList::iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+	{
+	    TypePtr type = (*q)->type();
+	    
+	    start("section id=" + scopedToId((*q)->scoped()), (*q)->name());
+	    
+	    O.zeroIndent();
+	    O << nl << "<synopsis>" << toString(type, p) << " <structfield>" << (*q)->name()
+	      << "</structfield>;</synopsis>";
+	    O.restoreIndent();
+	    
+	    printComment(*q);
+	    
+	    end();
+	}
+    }
+	
+    end();
+}
+
+void
 Slice::Gen::printHeader()
 {
     static const char* header =
@@ -836,6 +961,14 @@ Slice::Gen::toString(const SyntaxTreeBasePtr& p, const ContainerPtr& container)
 	s = getScopedMinimized(cl, container);
     }
 
+    StructPtr st = StructPtr::dynamicCast(p);
+    if (st)
+    {
+	tag = "structname";
+	linkend = scopedToId(st->scoped());
+	s = getScopedMinimized(st, container);
+    }
+
     if (s.empty())
     {
 	ContainedPtr contained = ContainedPtr::dynamicCast(p);
diff --git a/cpp/src/slice2docbook/Gen.h b/cpp/src/slice2docbook/Gen.h
index bb2fa8c5b31..86fcc9c881f 100644
--- a/cpp/src/slice2docbook/Gen.h
+++ b/cpp/src/slice2docbook/Gen.h
@@ -34,6 +34,7 @@ public:
     virtual void visitModuleStart(const ModulePtr&);
     virtual void visitContainer(const ContainerPtr&);
     virtual void visitClassDefStart(const ClassDefPtr&);
+    virtual void visitStructStart(const StructPtr&);
 
 private:
 
diff --git a/cpp/test/Ice/operations/Exceptions.cpp b/cpp/test/Ice/operations/Exceptions.cpp
index 7d480bf0dd1..436156824e0 100644
--- a/cpp/test/Ice/operations/Exceptions.cpp
+++ b/cpp/test/Ice/operations/Exceptions.cpp
@@ -105,7 +105,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(10);
     }
-    catch(const Test::ByteV& ex)
+    catch(const Test::ByteS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Byte(0x0f));
@@ -116,7 +116,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(11);
     }
-    catch(const Test::BoolV& ex)
+    catch(const Test::BoolS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == true);
@@ -127,7 +127,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(12);
     }
-    catch(const Test::ShortV& ex)
+    catch(const Test::ShortS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 1);
@@ -138,7 +138,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(13);
     }
-    catch(const Test::IntV& ex)
+    catch(const Test::IntS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 3);
@@ -149,7 +149,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(14);
     }
-    catch(const Test::LongV& ex)
+    catch(const Test::LongS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 5);
@@ -160,7 +160,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(15);
     }
-    catch(const Test::FloatV& ex)
+    catch(const Test::FloatS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Float(7.7));
@@ -171,7 +171,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(16);
     }
-    catch(const Test::DoubleV& ex)
+    catch(const Test::DoubleS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Double(9.9));
@@ -182,7 +182,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(17);
     }
-    catch(const Test::StringV& ex)
+    catch(const Test::StringS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == "abc");
@@ -193,7 +193,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(18);
     }
-    catch(const Test::WStringV& ex)
+    catch(const Test::WStringS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == L"xxx");
@@ -204,7 +204,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(19);
     }
-    catch(const Test::ByteVV& ex)
+    catch(const Test::ByteSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -218,7 +218,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(20);
     }
-    catch(const Test::BoolVV& ex)
+    catch(const Test::BoolSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -232,7 +232,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(21);
     }
-    catch(const Test::ShortVV& ex)
+    catch(const Test::ShortSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -246,7 +246,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(22);
     }
-    catch(const Test::IntVV& ex)
+    catch(const Test::IntSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -260,7 +260,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(23);
     }
-    catch(const Test::LongVV& ex)
+    catch(const Test::LongSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -274,7 +274,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(24);
     }
-    catch(const Test::FloatVV& ex)
+    catch(const Test::FloatSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -288,7 +288,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(25);
     }
-    catch(const Test::DoubleVV& ex)
+    catch(const Test::DoubleSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -302,7 +302,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(26);
     }
-    catch(const Test::StringVV& ex)
+    catch(const Test::StringSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -316,7 +316,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(27);
     }
-    catch(const Test::WStringVV& ex)
+    catch(const Test::WStringSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
diff --git a/cpp/test/Ice/operations/Test.ice b/cpp/test/Ice/operations/Test.ice
index 57a6aff81a7..700e3ddf1da 100644
--- a/cpp/test/Ice/operations/Test.ice
+++ b/cpp/test/Ice/operations/Test.ice
@@ -23,29 +23,36 @@ enum MyEnum
 
 class MyClass;
 
-vector<byte> ByteV;
-vector<bool> BoolV;
-vector<short> ShortV;
-vector<int> IntV;
-vector<long> LongV;
-vector<float> FloatV;
-vector<double> DoubleV;
-vector<string> StringV;
-vector<wstring> WStringV;
-vector<MyEnum> MyEnumV;
-vector<MyClass*> MyClassV;
-
-vector<ByteV> ByteVV;
-vector<BoolV> BoolVV;
-vector<ShortV> ShortVV;
-vector<IntV> IntVV;
-vector<LongV> LongVV;
-vector<FloatV> FloatVV;
-vector<DoubleV> DoubleVV;
-vector<StringV> StringVV;
-vector<WStringV> WStringVV;
-vector<MyEnumV> MyEnumVV;
-vector<MyClassV> MyClassVV;
+sequence<byte> ByteS;
+sequence<bool> BoolS;
+sequence<short> ShortS;
+sequence<int> IntS;
+sequence<long> LongS;
+sequence<float> FloatS;
+sequence<double> DoubleS;
+sequence<string> StringS;
+sequence<wstring> WStringS;
+sequence<MyEnum> MyEnumS;
+sequence<MyClass*> MyClassS;
+
+sequence<ByteS> ByteSS;
+sequence<BoolS> BoolSS;
+sequence<ShortS> ShortSS;
+sequence<IntS> IntSS;
+sequence<LongS> LongSS;
+sequence<FloatS> FloatSS;
+sequence<DoubleS> DoubleSS;
+sequence<StringS> StringSS;
+sequence<WStringS> WStringSS;
+sequence<MyEnumS> MyEnumSS;
+sequence<MyClassS> MyClassSS;
+
+dictionary<byte, bool> ByteBoolD;
+dictionary<short, int> ShortIntD;
+dictionary<long, float> LongFloatD;
+dictionary<double, string> DoubleStringD;
+dictionary<wstring, MyEnum> WStringMyEnumD;
+dictionary<MyClass*, string> MyClassStringD;
 
 class MyClass
 {
@@ -75,78 +82,78 @@ class MyClass
 
     MyClass* opMyClass(MyClass* p1; MyClass* p2);
 
-    ByteV opByteV(ByteV p1, ByteV p2;
-		  ByteV p3);
+    ByteS opByteS(ByteS p1, ByteS p2;
+		  ByteS p3);
 
-    BoolV opBoolV(BoolV p1, BoolV p2;
-		  BoolV p3);	
+    BoolS opBoolS(BoolS p1, BoolS p2;
+		  BoolS p3);	
 
-    LongV opShortIntLongV(Test::ShortV p1, IntV p2, LongV p3;
-			  ::Test::ShortV p4, IntV p5, LongV p6);
+    LongS opShortIntLongS(Test::ShortS p1, IntS p2, LongS p3;
+			  ::Test::ShortS p4, IntS p5, LongS p6);
 
-    DoubleV opFloatDoubleV(FloatV p1, DoubleV p2;
-			   FloatV p3, DoubleV p4);
+    DoubleS opFloatDoubleS(FloatS p1, DoubleS p2;
+			   FloatS p3, DoubleS p4);
     
-    StringV opStringV(StringV p1, StringV p2;
-		      StringV p3);
+    StringS opStringS(StringS p1, StringS p2;
+		      StringS p3);
     
-    WStringV opWStringV(WStringV p1, WStringV p2;
-			WStringV p3);
+    WStringS opWStringS(WStringS p1, WStringS p2;
+			WStringS p3);
     
-    ByteVV opByteVV(ByteVV p1, ByteVV p2;
-		    ByteVV p3);
+    ByteSS opByteSS(ByteSS p1, ByteSS p2;
+		    ByteSS p3);
     
-    BoolVV opBoolVV(BoolVV p1, BoolVV p2;
-		    BoolVV p3);
+    BoolSS opBoolSS(BoolSS p1, BoolSS p2;
+		    BoolSS p3);
     
-    LongVV opShortIntLongVV(ShortVV p1, IntVV p2, LongVV p3;
-			    ShortVV p4, IntVV p5, LongVV p6);
+    LongSS opShortIntLongSS(ShortSS p1, IntSS p2, LongSS p3;
+			    ShortSS p4, IntSS p5, LongSS p6);
     
     
-    DoubleVV opFloatDoubleVV(FloatVV p1, DoubleVV p2;
-			     FloatVV p3, DoubleVV p4);
+    DoubleSS opFloatDoubleSS(FloatSS p1, DoubleSS p2;
+			     FloatSS p3, DoubleSS p4);
     
-    StringVV opStringVV(StringVV p1, StringVV p2;
-			StringVV p3);
-
-    WStringVV opWStringVV(WStringVV p1, WStringVV p2;
-			  WStringVV p3);
-
-    void opEx(int p) throws byte, bool, short, int, long, float, double,
-	string, wstring, ByteV, BoolV, ShortV, IntV, LongV, FloatV, DoubleV,
-	StringV, WStringV, ByteVV, BoolVV, ShortVV, IntVV, LongVV, FloatVV,
-	DoubleVV, StringVV, WStringVV, MyClass*;
-    
-/*
-    bool bool_;
-    short short_;
-    int int_;
-    long long_;
-    float float_;
-    double double_;
-    string string_;
-    wstring wstring_;
-
-    ByteV ByteV_;
-    BoolV BoolV_;
-    ShortV ShortV_;
-    IntV IntV_;
-    LongV LongV_;
-    FloatV FloatV_;
-    DoubleV DoubleV_;
-    StringV StringV_;
-    WStringV WStringV_;
-
-    ByteVV ByteVV_;
-    BoolVV BoolVV_;
-    ShortVV ShortVV_;
-    IntVV IntVV_;
-    LongVV LongVV_;
-    FloatVV FloatVV_;
-    DoubleVV DoubleVV_;
-    StringVV StringVV_;
-    WStringVV WStringVV_;
-*/
+    StringSS opStringSS(StringSS p1, StringSS p2;
+			StringSS p3);
+
+    WStringSS opWStringSS(WStringSS p1, WStringSS p2;
+			  WStringSS p3);
+
+    void opEx(int p) throws
+        byte,
+	bool,
+	short,
+	int,
+	long,
+	float,
+	double,
+	string,
+	wstring,
+	ByteS,
+	BoolS,
+	ShortS,
+	IntS,
+	LongS,
+	FloatS,
+	DoubleS,
+	StringS,
+	WStringS,
+	ByteSS,
+	BoolSS,
+	ShortSS,
+	IntSS,
+	LongSS,
+	FloatSS,
+	DoubleSS,
+	StringSS,
+	WStringSS,
+	ByteBoolD,
+	ShortIntD,
+	LongFloatD,
+	DoubleStringD,
+	WStringMyEnumD,
+	MyClassStringD,
+	MyClass*;
 };
 
 class MyDerivedClass extends MyClass
diff --git a/cpp/test/Ice/operations/TestI.cpp b/cpp/test/Ice/operations/TestI.cpp
index f2a55800a3f..600f8b5b2ec 100644
--- a/cpp/test/Ice/operations/TestI.cpp
+++ b/cpp/test/Ice/operations/TestI.cpp
@@ -104,38 +104,38 @@ MyDerivedClassI::opMyClass(const Test::MyClassPrx& p1,
     return Test::MyClassPrx::uncheckedCast(_adapter->objectToProxy(this));
 }
 
-Test::ByteV
-MyDerivedClassI::opByteV(const Test::ByteV& p1,
-			 const Test::ByteV& p2,
-			 Test::ByteV& p3)
+Test::ByteS
+MyDerivedClassI::opByteS(const Test::ByteS& p1,
+			 const Test::ByteS& p2,
+			 Test::ByteS& p3)
 {
     p3.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), p3.begin());
-    Test::ByteV r = p1;
+    Test::ByteS r = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::BoolV
-MyDerivedClassI::opBoolV(const Test::BoolV& p1,
-			 const Test::BoolV& p2,
-			 Test::BoolV& p3)
+Test::BoolS
+MyDerivedClassI::opBoolS(const Test::BoolS& p1,
+			 const Test::BoolS& p2,
+			 Test::BoolS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::BoolV r;
+    Test::BoolS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::LongV
-MyDerivedClassI::opShortIntLongV(const Test::ShortV& p1,
-				 const Test::IntV& p2,
-				 const Test::LongV& p3,
-				 Test::ShortV& p4,
-				 Test::IntV& p5,
-				 Test::LongV& p6)
+Test::LongS
+MyDerivedClassI::opShortIntLongS(const Test::ShortS& p1,
+				 const Test::IntS& p2,
+				 const Test::LongS& p3,
+				 Test::ShortS& p4,
+				 Test::IntS& p5,
+				 Test::LongS& p6)
 {
     p4 = p1;
     p5.resize(p2.size());
@@ -145,78 +145,78 @@ MyDerivedClassI::opShortIntLongV(const Test::ShortV& p1,
     return p3;
 }
 
-Test::DoubleV
-MyDerivedClassI::opFloatDoubleV(const Test::FloatV& p1,
-				const Test::DoubleV& p2,
-				Test::FloatV& p3,
-				Test::DoubleV& p4)
+Test::DoubleS
+MyDerivedClassI::opFloatDoubleS(const Test::FloatS& p1,
+				const Test::DoubleS& p2,
+				Test::FloatS& p3,
+				Test::DoubleS& p4)
 {
     p3 = p1;
     p4.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), p4.begin());
-    Test::DoubleV r = p2;
+    Test::DoubleS r = p2;
     std::copy(p1.begin(), p1.end(), std::back_inserter(r));
     return r;
 }
 
-Test::StringV
-MyDerivedClassI::opStringV(const Test::StringV& p1,
-			   const Test::StringV& p2,
-			   Test::StringV& p3)
+Test::StringS
+MyDerivedClassI::opStringS(const Test::StringS& p1,
+			   const Test::StringS& p2,
+			   Test::StringS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::StringV r;
+    Test::StringS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::WStringV
-MyDerivedClassI::opWStringV(const Test::WStringV& p1,
-			    const Test::WStringV& p2,
-			    Test::WStringV& p3)
+Test::WStringS
+MyDerivedClassI::opWStringS(const Test::WStringS& p1,
+			    const Test::WStringS& p2,
+			    Test::WStringS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::WStringV r;
+    Test::WStringS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::ByteVV
-MyDerivedClassI::opByteVV(const Test::ByteVV& p1,
-			  const Test::ByteVV& p2,
-			  Test::ByteVV& p3)
+Test::ByteSS
+MyDerivedClassI::opByteSS(const Test::ByteSS& p1,
+			  const Test::ByteSS& p2,
+			  Test::ByteSS& p3)
 {
     p3.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), p3.begin());
-    Test::ByteVV r = p1;
+    Test::ByteSS r = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::BoolVV
-MyDerivedClassI::opBoolVV(const Test::BoolVV& p1,
-			  const Test::BoolVV& p2,
-			  Test::BoolVV& p3)
+Test::BoolSS
+MyDerivedClassI::opBoolSS(const Test::BoolSS& p1,
+			  const Test::BoolSS& p2,
+			  Test::BoolSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::BoolVV r;
+    Test::BoolSS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::LongVV
-MyDerivedClassI::opShortIntLongVV(const Test::ShortVV& p1,
-				  const Test::IntVV& p2,
-				  const Test::LongVV& p3,
-				  Test::ShortVV& p4,
-				  Test::IntVV& p5,
-				  Test::LongVV& p6)
+Test::LongSS
+MyDerivedClassI::opShortIntLongSS(const Test::ShortSS& p1,
+				  const Test::IntSS& p2,
+				  const Test::LongSS& p3,
+				  Test::ShortSS& p4,
+				  Test::IntSS& p5,
+				  Test::LongSS& p6)
 {
     p4 = p1;
     p5.resize(p2.size());
@@ -226,41 +226,41 @@ MyDerivedClassI::opShortIntLongVV(const Test::ShortVV& p1,
     return p3;
 }
 
-Test::DoubleVV
-MyDerivedClassI::opFloatDoubleVV(const Test::FloatVV& p1,
-				 const Test::DoubleVV& p2,
-				 Test::FloatVV& p3,
-				 Test::DoubleVV& p4)
+Test::DoubleSS
+MyDerivedClassI::opFloatDoubleSS(const Test::FloatSS& p1,
+				 const Test::DoubleSS& p2,
+				 Test::FloatSS& p3,
+				 Test::DoubleSS& p4)
 {
     p3 = p1;
     p4.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), p4.begin());
-    Test::DoubleVV r = p2;
+    Test::DoubleSS r = p2;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::StringVV
-MyDerivedClassI::opStringVV(const Test::StringVV& p1,
-			    const Test::StringVV& p2,
-			    Test::StringVV& p3)
+Test::StringSS
+MyDerivedClassI::opStringSS(const Test::StringSS& p1,
+			    const Test::StringSS& p2,
+			    Test::StringSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::StringVV r;
+    Test::StringSS r;
     r.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), r.begin());
     return r;
 }
 
-Test::WStringVV
-MyDerivedClassI::opWStringVV(const Test::WStringVV& p1,
-			     const Test::WStringVV& p2,
-			     Test::WStringVV& p3)
+Test::WStringSS
+MyDerivedClassI::opWStringSS(const Test::WStringSS& p1,
+			     const Test::WStringSS& p2,
+			     Test::WStringSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::WStringVV r;
+    Test::WStringSS r;
     r.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), r.begin());
     return r;
@@ -323,7 +323,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 
 	case 10:
 	{
-	    Test::ByteV ex;
+	    Test::ByteS ex;
 	    ex.push_back(Ice::Byte(0x0f));
 	    ex.push_back(Ice::Byte(0xf0));
 	    throw ex;
@@ -331,7 +331,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 11:
 	{
-	    Test::BoolV ex;
+	    Test::BoolS ex;
 	    ex.push_back(true);
 	    ex.push_back(false);
 	    throw ex;
@@ -339,7 +339,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 12:
 	{
-	    Test::ShortV ex;
+	    Test::ShortS ex;
 	    ex.push_back(1);
 	    ex.push_back(2);
 	    throw ex;
@@ -347,7 +347,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 13:
 	{
-	    Test::IntV ex;
+	    Test::IntS ex;
 	    ex.push_back(3);
 	    ex.push_back(4);
 	    throw ex;
@@ -355,7 +355,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 14:
 	{
-	    Test::LongV ex;
+	    Test::LongS ex;
 	    ex.push_back(5);
 	    ex.push_back(6);
 	    throw ex;
@@ -363,7 +363,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 15:
 	{
-	    Test::FloatV ex;
+	    Test::FloatS ex;
 	    ex.push_back(Ice::Float(7.7));
 	    ex.push_back(Ice::Float(8.8));
 	    throw ex;
@@ -371,7 +371,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 16:
 	{
-	    Test::DoubleV ex;
+	    Test::DoubleS ex;
 	    ex.push_back(Ice::Double(9.9));
 	    ex.push_back(Ice::Double(10.10));
 	    throw ex;
@@ -379,7 +379,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 17:
 	{
-	    Test::StringV ex;
+	    Test::StringS ex;
 	    ex.push_back("abc");
 	    ex.push_back("def");
 	    throw ex;
@@ -387,7 +387,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 18:
 	{
-	    Test::WStringV ex;
+	    Test::WStringS ex;
 	    ex.push_back(L"xxx");
 	    ex.push_back(L"XXX");
 	    throw ex;
@@ -395,12 +395,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 19:
 	{
-	    Test::ByteV v1;
-	    Test::ByteV v2;
+	    Test::ByteS v1;
+	    Test::ByteS v2;
 	    v1.push_back(Ice::Byte(0x01));
 	    v2.push_back(Ice::Byte(0x10));
 	    v2.push_back(Ice::Byte(0x11));
-	    Test::ByteVV ex;
+	    Test::ByteSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -408,12 +408,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 20:
 	{
-	    Test::BoolV v1;
-	    Test::BoolV v2;
+	    Test::BoolS v1;
+	    Test::BoolS v2;
 	    v1.push_back(true);
 	    v2.push_back(false);
 	    v2.push_back(true);
-	    Test::BoolVV ex;
+	    Test::BoolSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -421,12 +421,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 21:
 	{
-	    Test::ShortV v1;
-	    Test::ShortV v2;
+	    Test::ShortS v1;
+	    Test::ShortS v2;
 	    v1.push_back(1);
 	    v2.push_back(2);
 	    v2.push_back(3);
-	    Test::ShortVV ex;
+	    Test::ShortSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -434,12 +434,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 22:
 	{
-	    Test::IntV v1;
-	    Test::IntV v2;
+	    Test::IntS v1;
+	    Test::IntS v2;
 	    v1.push_back(4);
 	    v2.push_back(5);
 	    v2.push_back(6);
-	    Test::IntVV ex;
+	    Test::IntSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -447,12 +447,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 23:
 	{
-	    Test::LongV v1;
-	    Test::LongV v2;
+	    Test::LongS v1;
+	    Test::LongS v2;
 	    v1.push_back(7);
 	    v2.push_back(8);
 	    v2.push_back(9);
-	    Test::LongVV ex;
+	    Test::LongSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -460,12 +460,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 24:
 	{
-	    Test::FloatV v1;
-	    Test::FloatV v2;
+	    Test::FloatS v1;
+	    Test::FloatS v2;
 	    v1.push_back(Ice::Float(10.10));
 	    v2.push_back(Ice::Float(11.11));
 	    v2.push_back(Ice::Float(12.12));
-	    Test::FloatVV ex;
+	    Test::FloatSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -473,12 +473,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 25:
 	{
-	    Test::DoubleV v1;
-	    Test::DoubleV v2;
+	    Test::DoubleS v1;
+	    Test::DoubleS v2;
 	    v1.push_back(Ice::Double(13.13));
 	    v2.push_back(Ice::Double(14.14));
 	    v2.push_back(Ice::Double(15.15));
-	    Test::DoubleVV ex;
+	    Test::DoubleSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -486,12 +486,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 26:
 	{
-	    Test::StringV v1;
-	    Test::StringV v2;
+	    Test::StringS v1;
+	    Test::StringS v2;
 	    v1.push_back("aaa");
 	    v2.push_back("bbb");
 	    v2.push_back("ccc");
-	    Test::StringVV ex;
+	    Test::StringSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -499,12 +499,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 27:
 	{
-	    Test::WStringV v1;
-	    Test::WStringV v2;
+	    Test::WStringS v1;
+	    Test::WStringS v2;
 	    v1.push_back(L"aaa");
 	    v2.push_back(L"bbb");
 	    v2.push_back(L"ccc");
-	    Test::WStringVV ex;
+	    Test::WStringSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
diff --git a/cpp/test/Ice/operations/TestI.h b/cpp/test/Ice/operations/TestI.h
index 0ac00a69816..04bbe4d5f10 100644
--- a/cpp/test/Ice/operations/TestI.h
+++ b/cpp/test/Ice/operations/TestI.h
@@ -57,61 +57,61 @@ public:
     virtual Test::MyClassPrx opMyClass(const Test::MyClassPrx&,
 				       Test::MyClassPrx&);
 
-    virtual Test::ByteV opByteV(const Test::ByteV&,
-				const Test::ByteV&,
-				Test::ByteV&);
-    
-    virtual Test::BoolV opBoolV(const Test::BoolV&,
-				const Test::BoolV&,
-				Test::BoolV&);
-    
-    virtual Test::LongV opShortIntLongV(const Test::ShortV&,
-					const Test::IntV&,
-					const Test::LongV&,
-					Test::ShortV&,
-					Test::IntV&,
-					Test::LongV&);
-    
-    virtual Test::DoubleV opFloatDoubleV(const Test::FloatV&,
-					 const Test::DoubleV&,
-					 Test::FloatV&,
-					 Test::DoubleV&);
-    
-    virtual Test::StringV opStringV(const Test::StringV&,
-				    const Test::StringV&,
-				    Test::StringV&);
-    
-    virtual Test::WStringV opWStringV(const Test::WStringV&,
-				      const Test::WStringV&,
-				      Test::WStringV&);
-    
-    virtual Test::ByteVV opByteVV(const Test::ByteVV&,
-				  const Test::ByteVV&,
-				  Test::ByteVV&);
-    
-    virtual Test::BoolVV opBoolVV(const Test::BoolVV&,
-				  const Test::BoolVV&,
-				  Test::BoolVV&);
-    
-    virtual Test::LongVV opShortIntLongVV(const Test::ShortVV&,
-					  const Test::IntVV&,
-					  const Test::LongVV&,
-					  Test::ShortVV&,
-					  Test::IntVV&,
-					  Test::LongVV&);
-    
-    virtual Test::DoubleVV opFloatDoubleVV(const Test::FloatVV&,
-					   const Test::DoubleVV&,
-					   Test::FloatVV&,
-					   Test::DoubleVV&);
-    
-    virtual Test::StringVV opStringVV(const Test::StringVV&,
-				      const Test::StringVV&,
-				      Test::StringVV&);
+    virtual Test::ByteS opByteS(const Test::ByteS&,
+				const Test::ByteS&,
+				Test::ByteS&);
+    
+    virtual Test::BoolS opBoolS(const Test::BoolS&,
+				const Test::BoolS&,
+				Test::BoolS&);
+    
+    virtual Test::LongS opShortIntLongS(const Test::ShortS&,
+					const Test::IntS&,
+					const Test::LongS&,
+					Test::ShortS&,
+					Test::IntS&,
+					Test::LongS&);
+    
+    virtual Test::DoubleS opFloatDoubleS(const Test::FloatS&,
+					 const Test::DoubleS&,
+					 Test::FloatS&,
+					 Test::DoubleS&);
+    
+    virtual Test::StringS opStringS(const Test::StringS&,
+				    const Test::StringS&,
+				    Test::StringS&);
+    
+    virtual Test::WStringS opWStringS(const Test::WStringS&,
+				      const Test::WStringS&,
+				      Test::WStringS&);
+    
+    virtual Test::ByteSS opByteSS(const Test::ByteSS&,
+				  const Test::ByteSS&,
+				  Test::ByteSS&);
+    
+    virtual Test::BoolSS opBoolSS(const Test::BoolSS&,
+				  const Test::BoolSS&,
+				  Test::BoolSS&);
+    
+    virtual Test::LongSS opShortIntLongSS(const Test::ShortSS&,
+					  const Test::IntSS&,
+					  const Test::LongSS&,
+					  Test::ShortSS&,
+					  Test::IntSS&,
+					  Test::LongSS&);
+    
+    virtual Test::DoubleSS opFloatDoubleSS(const Test::FloatSS&,
+					   const Test::DoubleSS&,
+					   Test::FloatSS&,
+					   Test::DoubleSS&);
+    
+    virtual Test::StringSS opStringSS(const Test::StringSS&,
+				      const Test::StringSS&,
+				      Test::StringSS&);
 
-    virtual Test::WStringVV opWStringVV(const Test::WStringVV&,
-					const Test::WStringVV&,
-					Test::WStringVV&);
+    virtual Test::WStringSS opWStringSS(const Test::WStringSS&,
+					const Test::WStringSS&,
+					Test::WStringSS&);
     
     virtual void opEx(Ice::Int);
 
diff --git a/cpp/test/Ice/operations/Twoways.cpp b/cpp/test/Ice/operations/Twoways.cpp
index 015199cb7ee..e050f2b0f19 100644
--- a/cpp/test/Ice/operations/Twoways.cpp
+++ b/cpp/test/Ice/operations/Twoways.cpp
@@ -142,8 +142,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ByteV bvi1;
-	Test::ByteV bvi2;
+	Test::ByteS bvi1;
+	Test::ByteS bvi2;
 
 	bvi1.push_back(Ice::Byte(0x01));
 	bvi1.push_back(Ice::Byte(0x11));
@@ -155,10 +155,10 @@ twoways(Test::MyClassPrx p)
 	bvi2.push_back(Ice::Byte(0xf3));
 	bvi2.push_back(Ice::Byte(0xf4));
 
-	Test::ByteV bvo;
-	Test::ByteV rvo;
+	Test::ByteS bvo;
+	Test::ByteS rvo;
 
-	rvo = p->opByteV(bvi1, bvi2, bvo);
+	rvo = p->opByteS(bvi1, bvi2, bvo);
 	test(bvo.size() == 4);
 	test(bvo[0] == Ice::Byte(0x22));
 	test(bvo[1] == Ice::Byte(0x12));
@@ -176,8 +176,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::BoolV bvi1;
-	Test::BoolV bvi2;
+	Test::BoolS bvi1;
+	Test::BoolS bvi2;
 
 	bvi1.push_back(true);
 	bvi1.push_back(true);
@@ -185,10 +185,10 @@ twoways(Test::MyClassPrx p)
 
 	bvi2.push_back(false);
 
-	Test::BoolV bvo;
-	Test::BoolV rvo;
+	Test::BoolS bvo;
+	Test::BoolS rvo;
 
-	rvo = p->opBoolV(bvi1, bvi2, bvo);
+	rvo = p->opBoolS(bvi1, bvi2, bvo);
 	test(bvo.size() == 4);
 	test(bvo[0]);
 	test(bvo[1]);
@@ -201,9 +201,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ShortV svi;
-	Test::IntV ivi;
-	Test::LongV lvi;
+	Test::ShortS svi;
+	Test::IntS ivi;
+	Test::LongS lvi;
 
 	svi.push_back(1);
 	svi.push_back(2);
@@ -218,12 +218,12 @@ twoways(Test::MyClassPrx p)
 	lvi.push_back(30);
 	lvi.push_back(20);
 
-	Test::ShortV svo;
-	Test::IntV ivo;
-	Test::LongV lvo;
-	Test::LongV rvo;
+	Test::ShortS svo;
+	Test::IntS ivo;
+	Test::LongS lvo;
+	Test::LongS rvo;
 
-	rvo = p->opShortIntLongV(svi, ivi, lvi, svo, ivo, lvo);
+	rvo = p->opShortIntLongS(svi, ivi, lvi, svo, ivo, lvo);
 	test(svo.size() == 3);
 	test(svo[0] == 1);
 	test(svo[1] == 2);
@@ -247,8 +247,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::FloatV fvi;
-	Test::DoubleV dvi;
+	Test::FloatS fvi;
+	Test::DoubleS dvi;
 
 	fvi.push_back(Ice::Float(3.14));
 	fvi.push_back(Ice::Float(1.11));
@@ -257,11 +257,11 @@ twoways(Test::MyClassPrx p)
 	dvi.push_back(Ice::Double(1.2E10));
 	dvi.push_back(Ice::Double(1.3E10));
 
-	Test::FloatV fvo;
-	Test::DoubleV dvo;
-	Test::DoubleV rvo;
+	Test::FloatS fvo;
+	Test::DoubleS dvo;
+	Test::DoubleS rvo;
 
-	rvo = p->opFloatDoubleV(fvi, dvi, fvo, dvo);
+	rvo = p->opFloatDoubleS(fvi, dvi, fvo, dvo);
 	test(fvo.size() == 2);
 	test(fvo[0] == ::Ice::Float(3.14));
 	test(fvo[1] == ::Ice::Float(1.11));
@@ -278,8 +278,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::StringV svi1;
-	Test::StringV svi2;
+	Test::StringS svi1;
+	Test::StringS svi2;
 
 	svi1.push_back("abc");
 	svi1.push_back("de");
@@ -287,10 +287,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2.push_back("xyz");
 
-	Test::StringV svo;
-	Test::StringV rvo;
+	Test::StringS svo;
+	Test::StringS rvo;
 
-	rvo = p->opStringV(svi1, svi2, svo);
+	rvo = p->opStringS(svi1, svi2, svo);
 	test(svo.size() == 4);
 	test(svo[0] == "abc");
 	test(svo[1] == "de");
@@ -303,8 +303,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::WStringV svi1;
-	Test::WStringV svi2;
+	Test::WStringS svi1;
+	Test::WStringS svi2;
 
 	svi1.push_back(L"abc");
 	svi1.push_back(L"de");
@@ -312,10 +312,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2.push_back(L"xyz");
 
-	Test::WStringV svo;
-	Test::WStringV rvo;
+	Test::WStringS svo;
+	Test::WStringS rvo;
 
-	rvo = p->opWStringV(svi1, svi2, svo);
+	rvo = p->opWStringS(svi1, svi2, svo);
 	test(svo.size() == 4);
 	test(svo[0] == L"abc");
 	test(svo[1] == L"de");
@@ -328,9 +328,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ByteVV bvi1;
+	Test::ByteSS bvi1;
 	bvi1.resize(2);
-	Test::ByteVV bvi2;
+	Test::ByteSS bvi2;
 	bvi2.resize(2);
 
 	bvi1[0].push_back(Ice::Byte(0x01));
@@ -342,10 +342,10 @@ twoways(Test::MyClassPrx p)
 	bvi2[1].push_back(Ice::Byte(0xf2));
 	bvi2[1].push_back(Ice::Byte(0xf1));
 
-	Test::ByteVV bvo;
-	Test::ByteVV rvo;
+	Test::ByteSS bvo;
+	Test::ByteSS rvo;
 
-	rvo = p->opByteVV(bvi1, bvi2, bvo);
+	rvo = p->opByteSS(bvi1, bvi2, bvo);
 	test(bvo.size() == 2);
 	test(bvo[0].size() == 1);
 	test(bvo[0][0] == Ice::Byte(0xff));
@@ -368,9 +368,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::FloatVV fvi;
+	Test::FloatSS fvi;
 	fvi.resize(3);
-	Test::DoubleVV dvi;
+	Test::DoubleSS dvi;
 	dvi.resize(1);
 
 	fvi[0].push_back(Ice::Float(3.14));
@@ -380,11 +380,11 @@ twoways(Test::MyClassPrx p)
 	dvi[0].push_back(Ice::Double(1.2E10));
 	dvi[0].push_back(Ice::Double(1.3E10));
 
-	Test::FloatVV fvo;
-	Test::DoubleVV dvo;
-	Test::DoubleVV rvo;
+	Test::FloatSS fvo;
+	Test::DoubleSS dvo;
+	Test::DoubleSS rvo;
 
-	rvo = p->opFloatDoubleVV(fvi, dvi, fvo, dvo);
+	rvo = p->opFloatDoubleSS(fvi, dvi, fvo, dvo);
 	test(fvo.size() == 3);
 	test(fvo[0].size() == 1);
 	test(fvo[0][0] == ::Ice::Float(3.14));
@@ -408,9 +408,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::StringVV svi1;
+	Test::StringSS svi1;
 	svi1.resize(2);
-	Test::StringVV svi2;
+	Test::StringSS svi2;
 	svi2.resize(3);
 
 	svi1[0].push_back("abc");
@@ -419,10 +419,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2[2].push_back("xyz");
 
-	Test::StringVV svo;
-	Test::StringVV rvo;
+	Test::StringSS svo;
+	Test::StringSS rvo;
 
-	rvo = p->opStringVV(svi1, svi2, svo);
+	rvo = p->opStringSS(svi1, svi2, svo);
 	test(svo.size() == 5);
 	test(svo[0].size() == 1);
 	test(svo[0][0] == "abc");
@@ -441,9 +441,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::WStringVV svi1;
+	Test::WStringSS svi1;
 	svi1.resize(2);
-	Test::WStringVV svi2;
+	Test::WStringSS svi2;
 	svi2.resize(3);
 
 	svi1[0].push_back(L"abc");
@@ -452,10 +452,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2[2].push_back(L"xyz");
 
-	Test::WStringVV svo;
-	Test::WStringVV rvo;
+	Test::WStringSS svo;
+	Test::WStringSS rvo;
 
-	rvo = p->opWStringVV(svi1, svi2, svo);
+	rvo = p->opWStringSS(svi1, svi2, svo);
 	test(svo.size() == 5);
 	test(svo[0].size() == 1);
 	test(svo[0][0] == L"abc");
diff --git a/cpp/test/Slice/errorDetection/DictionaryRedefinition.err b/cpp/test/Slice/errorDetection/DictionaryRedefinition.err
new file mode 100644
index 00000000000..b39dc9e34c9
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/DictionaryRedefinition.err
@@ -0,0 +1 @@
+DictionaryRedefinition.ice:12: redefinition of dictionary `Dictionary'
diff --git a/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice b/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice
new file mode 100644
index 00000000000..9ee39cb086b
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice
@@ -0,0 +1,12 @@
+// **********************************************************************
+//
+// Copyright (c) 2001
+// MutableRealms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+dictionary<int, long> Dictionary;
+dictionary<int, long> Dictionary;
diff --git a/cpp/test/Slice/errorDetection/MapRedefinition.err b/cpp/test/Slice/errorDetection/MapRedefinition.err
deleted file mode 100644
index ad9400fda64..00000000000
--- a/cpp/test/Slice/errorDetection/MapRedefinition.err
+++ /dev/null
@@ -1 +0,0 @@
-MapRedefinition.ice:12: redefinition of map `Map'
diff --git a/cpp/test/Slice/errorDetection/NotClassOrInterface.err b/cpp/test/Slice/errorDetection/NotClassOrInterface.err
index 922573aab1c..89adf22bc33 100644
--- a/cpp/test/Slice/errorDetection/NotClassOrInterface.err
+++ b/cpp/test/Slice/errorDetection/NotClassOrInterface.err
@@ -1,9 +1,9 @@
-NotClassOrInterface.ice:15: `Vector' is not an interface
-NotClassOrInterface.ice:16: `Vector' is not a class
-NotClassOrInterface.ice:17: `Vector3' is not an interface
-NotClassOrInterface.ice:17: `Vector2' is not an interface
-NotClassOrInterface.ice:17: `Vector1' is not an interface
-NotClassOrInterface.ice:18: `Vector' is not a class
-NotClassOrInterface.ice:18: `Vector3' is not an interface
-NotClassOrInterface.ice:18: `Vector2' is not an interface
-NotClassOrInterface.ice:18: `Vector1' is not an interface
+NotClassOrInterface.ice:15: `Sequence' is not an interface
+NotClassOrInterface.ice:16: `Sequence' is not a class
+NotClassOrInterface.ice:17: `Sequence3' is not an interface
+NotClassOrInterface.ice:17: `Sequence2' is not an interface
+NotClassOrInterface.ice:17: `Sequence1' is not an interface
+NotClassOrInterface.ice:18: `Sequence' is not a class
+NotClassOrInterface.ice:18: `Sequence3' is not an interface
+NotClassOrInterface.ice:18: `Sequence2' is not an interface
+NotClassOrInterface.ice:18: `Sequence1' is not an interface
diff --git a/cpp/test/Slice/errorDetection/NotClassOrInterface.ice b/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
index 61830eaf074..bbb30c6e37d 100644
--- a/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
+++ b/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
@@ -8,11 +8,11 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-vector<int> Vector1;
-vector<int> Vector2;
-vector<int> Vector3;
-interface BarIntf extends Vector { };
-class BarClass1 extends Vector { };
-class BarClass2 implements Vector1, Vector2, Vector3 { };
-class BarClass3 extends Vector implements Vector1, Vector2, Vector3 { };
+sequence<int> Sequence;
+sequence<int> Sequence1;
+sequence<int> Sequence2;
+sequence<int> Sequence3;
+interface BarIntf extends Sequence { };
+class BarClass1 extends Sequence { };
+class BarClass2 implements Sequence1, Sequence2, Sequence3 { };
+class BarClass3 extends Sequence implements Sequence1, Sequence2, Sequence3 { };
diff --git a/cpp/test/Slice/errorDetection/NotType.err b/cpp/test/Slice/errorDetection/NotType.err
index e69de29bb2d..b67886924c4 100644
--- a/cpp/test/Slice/errorDetection/NotType.err
+++ b/cpp/test/Slice/errorDetection/NotType.err
@@ -0,0 +1,11 @@
+NotType.ice:17: `Module' is not a type
+NotType.ice:18: `Module' is not a type
+NotType.ice:19: `Module' is not a type
+NotType.ice:20: `Module' is not a type
+NotType.ice:21: `Module3' is not a type
+NotType.ice:21: `Module2' is not a type
+NotType.ice:21: `Module1' is not a type
+NotType.ice:22: `Module' is not a type
+NotType.ice:22: `Module3' is not a type
+NotType.ice:22: `Module2' is not a type
+NotType.ice:22: `Module1' is not a type
diff --git a/cpp/test/Slice/errorDetection/NotType.ice b/cpp/test/Slice/errorDetection/NotType.ice
index 406bc214c46..92cacacff0f 100644
--- a/cpp/test/Slice/errorDetection/NotType.ice
+++ b/cpp/test/Slice/errorDetection/NotType.ice
@@ -14,8 +14,8 @@ module Module3 { };
 module Module
 {
 
-vector<Module> Vector;
-map<int, Module> Map;
+sequence<Module> Sequence;
+dictionary<int, Module> Dictionary;
 interface BarIntf extends Module { };
 class BarClass1 extends Module { };
 class BarClass2 implements Module1, Module2, Module3 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsClass.err b/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
index 29968e88b63..7db099191dc 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
@@ -1,2 +1,2 @@
-RedefinitionAsClass.ice:12: declaration of already defined `Vector1' as class
-RedefinitionAsClass.ice:15: redefinition of `Vector2' as class
+RedefinitionAsClass.ice:12: declaration of already defined `Sequence1' as class
+RedefinitionAsClass.ice:15: redefinition of `Sequence2' as class
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice b/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
index 5835e1ae3a9..18d1c411bf1 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<int> Vector1;
-class Vector1;
+sequence<int> Sequence1;
+class Sequence1;
 
-vector<int> Vector2;
-class Vector2 { };
+sequence<int> Sequence2;
+class Sequence2 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err
new file mode 100644
index 00000000000..97576b0c140
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err
@@ -0,0 +1 @@
+RedefinitionAsDictionary.ice:12: redefinition of `Class' as dictionary
diff --git a/cpp/test/Slice/errorDetection/VectorRedefinition.ice b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.ice
index 2248c565df3..a531d5248f2 100644
--- a/cpp/test/Slice/errorDetection/VectorRedefinition.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.ice
@@ -8,5 +8,5 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-vector<int> Vector;
+class Class { };
+dictionary<string, int> Class;
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
index 3f790dad41c..ee48a8f14a1 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
@@ -1,2 +1,2 @@
-RedefinitionAsEnumerator.ice:13: redefinition of `Vector' as enumerator
+RedefinitionAsEnumerator.ice:13: redefinition of `Sequence' as enumerator
 RedefinitionAsEnumerator.ice:13: redefinition of `Class' as enumerator
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
index 97f3ff85dbe..f360a2e4cd7 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
@@ -9,5 +9,5 @@
 // **********************************************************************
 
 class Class { };
-vector<int> Vector;
-enum Enum { Class, Vector };
+sequence<int> Sequence;
+enum Enum { Class, Sequence };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
index 0f7ef12d1b8..719e8703e0d 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
@@ -1,2 +1,2 @@
-RedefinitionAsInterface.ice:12: declaration of already defined `Vector1' as interface
-RedefinitionAsInterface.ice:15: redefinition of `Vector2' as interface
+RedefinitionAsInterface.ice:12: declaration of already defined `Sequence1' as interface
+RedefinitionAsInterface.ice:15: redefinition of `Sequence2' as interface
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
index b8041e946c1..a4664aa2030 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<int> Vector1;
-interface Vector1;
+sequence<int> Sequence1;
+interface Sequence1;
 
-vector<int> Vector2;
-interface Vector2 { };
+sequence<int> Sequence2;
+interface Sequence2 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsMap.err b/cpp/test/Slice/errorDetection/RedefinitionAsMap.err
deleted file mode 100644
index 9f710a9a95c..00000000000
--- a/cpp/test/Slice/errorDetection/RedefinitionAsMap.err
+++ /dev/null
@@ -1 +0,0 @@
-RedefinitionAsMap.ice:12: redefinition of `Class' as map
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsModule.err b/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
index 52bddb9bd0b..bb7e6816ce4 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
@@ -1 +1 @@
-RedefinitionAsModule.ice:12: redefinition of `Vector' as module
+RedefinitionAsModule.ice:12: redefinition of `Sequence' as module
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice b/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
index 9d9db1c412f..3a486e43666 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
@@ -8,7 +8,7 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-module Vector { };
+sequence<int> Sequence;
+module Sequence { };
 module Module { };
 module Module { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err
new file mode 100644
index 00000000000..050f79286ea
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err
@@ -0,0 +1 @@
+RedefinitionAsSequence.ice:12: redefinition of `Class' as sequence
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsMap.ice b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.ice
index 5c606ff86bc..fbe11516c06 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsMap.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.ice
@@ -9,4 +9,4 @@
 // **********************************************************************
 
 class Class { };
-map<string, int> Class;
+sequence<int> Class;
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsVector.err b/cpp/test/Slice/errorDetection/RedefinitionAsVector.err
deleted file mode 100644
index 7959fbf9476..00000000000
--- a/cpp/test/Slice/errorDetection/RedefinitionAsVector.err
+++ /dev/null
@@ -1 +0,0 @@
-RedefinitionAsVector.ice:12: redefinition of `Class' as vector
diff --git a/cpp/test/Slice/errorDetection/SequenceRedefinition.err b/cpp/test/Slice/errorDetection/SequenceRedefinition.err
new file mode 100644
index 00000000000..0b134378c73
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/SequenceRedefinition.err
@@ -0,0 +1 @@
+SequenceRedefinition.ice:12: redefinition of sequence `Sequence'
diff --git a/cpp/test/Slice/errorDetection/MapRedefinition.ice b/cpp/test/Slice/errorDetection/SequenceRedefinition.ice
index 0adc579e796..fb7f4b96a2b 100644
--- a/cpp/test/Slice/errorDetection/MapRedefinition.ice
+++ b/cpp/test/Slice/errorDetection/SequenceRedefinition.ice
@@ -8,5 +8,5 @@
 //
 // **********************************************************************
 
-map<int, long> Map;
-map<int, long> Map;
+sequence<int> Sequence;
+sequence<int> Sequence;
diff --git a/cpp/test/Slice/errorDetection/Undefined.ice b/cpp/test/Slice/errorDetection/Undefined.ice
index 0f5a586ea66..6360eae7f0a 100644
--- a/cpp/test/Slice/errorDetection/Undefined.ice
+++ b/cpp/test/Slice/errorDetection/Undefined.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<Foo> FooVector;
-map<Foo, Bar> FooBarMap;
+sequence<Foo> FooSequence;
+dictionary<Foo, Bar> FooBarDictionary;
 interface BarIntf extends Foo { };
 class BarClass1 extends Foo { };
 class BarClass2 implements Foo1, Foo2, Foo3 { };
diff --git a/cpp/test/Slice/errorDetection/VectorRedefinition.err b/cpp/test/Slice/errorDetection/VectorRedefinition.err
deleted file mode 100644
index d0d4f02327f..00000000000
--- a/cpp/test/Slice/errorDetection/VectorRedefinition.err
+++ /dev/null
@@ -1 +0,0 @@
-VectorRedefinition.ice:12: redefinition of vector `Vector'
diff --git a/cpp/test/Slice/errorDetection/WrongProxyType.err b/cpp/test/Slice/errorDetection/WrongProxyType.err
index 9fedb8c0acd..4bcbc3393ef 100644
--- a/cpp/test/Slice/errorDetection/WrongProxyType.err
+++ b/cpp/test/Slice/errorDetection/WrongProxyType.err
@@ -1,6 +1,6 @@
-WrongProxyType.ice:16: `Vector' must be class or interface
-WrongProxyType.ice:17: `Vector' must be class or interface
-WrongProxyType.ice:18: `Vector' must be class or interface
-WrongProxyType.ice:20: `Map' must be class or interface
-WrongProxyType.ice:21: `Map' must be class or interface
-WrongProxyType.ice:22: `Map' must be class or interface
+WrongProxyType.ice:16: `Sequence' must be class or interface
+WrongProxyType.ice:17: `Sequence' must be class or interface
+WrongProxyType.ice:18: `Sequence' must be class or interface
+WrongProxyType.ice:20: `Dictionary' must be class or interface
+WrongProxyType.ice:21: `Dictionary' must be class or interface
+WrongProxyType.ice:22: `Dictionary' must be class or interface
diff --git a/cpp/test/Slice/errorDetection/WrongProxyType.ice b/cpp/test/Slice/errorDetection/WrongProxyType.ice
index 54604a4d4c0..574601a5668 100644
--- a/cpp/test/Slice/errorDetection/WrongProxyType.ice
+++ b/cpp/test/Slice/errorDetection/WrongProxyType.ice
@@ -8,16 +8,16 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-map<Vector, int> Map;
+sequence<int> Sequence;
+dictionary<Sequence, int> Dictionary;
 
 interface I
 {
-    Vector* f1();
-    void f2(Vector*);
-    void f3(; Vector*);
+    Sequence* f1();
+    void f2(Sequence*);
+    void f3(; Sequence*);
 
-    Map* f1();
-    void f2(Map*);
-    void f3(; Map*);
+    Dictionary* f1();
+    void f2(Dictionary*);
+    void f3(; Dictionary*);
 };
diff --git a/cpp/test/Slice/errorDetection/run.py b/cpp/test/Slice/errorDetection/run.py
index 65d56b05688..47ef25143ab 100755
--- a/cpp/test/Slice/errorDetection/run.py
+++ b/cpp/test/Slice/errorDetection/run.py
@@ -26,6 +26,7 @@ for file in os.listdir(directory):
     if(regex1.search(file)):
         files.append(file)
 
+files.sort()
 for file in files:
 
     print file + "...",