started with splice2html

6 files changed, 123 insertions, 72 deletions

diff --git a/cpp/src/Slice/Grammer.y b/cpp/src/Slice/Grammer.y
index 630df653ba7..dea4d9bbffd 100644
--- a/cpp/src/Slice/Grammer.y
+++ b/cpp/src/Slice/Grammer.y
@@ -40,6 +40,7 @@ yyerror(const char* s)
 %token ICE_STRING
 %token ICE_WSTRING
 %token ICE_OBJECT
+%token ICE_LOCAL_OBJECT
 %token ICE_NATIVE
 %token ICE_VECTOR
 %token ICE_IDENTIFIER
@@ -192,10 +193,10 @@ extends
 {
     String_ptr scoped = String_ptr::dynamicCast($2);
     Container_ptr cont = parser -> currentContainer();
-    vector<Type_ptr> types = cont -> lookupType(scoped -> v);
+    list<Type_ptr> types = cont -> lookupType(scoped -> v);
     if(types.empty())
 	YYERROR; // Can't continue, jump to next yyerrok
-    ClassDecl_ptr cl = ClassDecl_ptr::dynamicCast(types[0]);
+    ClassDecl_ptr cl = ClassDecl_ptr::dynamicCast(types.front());
     if(!cl)
     {
 	string msg = "`";
@@ -370,7 +371,7 @@ type
 {
     $$ = parser -> builtin(Builtin::KindObjectProxy);
 }
-| ICE_LOCAL ICE_OBJECT
+| ICE_LOCAL_OBJECT
 {
     $$ = parser -> builtin(Builtin::KindLocalObject);
 }
@@ -378,19 +379,19 @@ type
 {
     String_ptr scoped = String_ptr::dynamicCast($1);
     Container_ptr cont = parser -> currentContainer();
-    vector<Type_ptr> types = cont -> lookupType(scoped -> v);
+    list<Type_ptr> types = cont -> lookupType(scoped -> v);
     if(types.empty())
 	YYERROR; // Can't continue, jump to next yyerrok
-    $$ = types[0];
+    $$ = types.front();
 }
 | scoped_name '*'
 {
     String_ptr scoped = String_ptr::dynamicCast($1);
     Container_ptr cont = parser -> currentContainer();
-    vector<Type_ptr> types = cont -> lookupType(scoped -> v);
+    list<Type_ptr> types = cont -> lookupType(scoped -> v);
     if(types.empty())
 	YYERROR; // Can't continue, jump to next yyerrok
-    for(vector<Type_ptr>::iterator p = types.begin();
+    for(list<Type_ptr>::iterator p = types.begin();
 	p != types.end();
 	++p)
     {
@@ -398,7 +399,7 @@ type
 	assert(cl); // TODO: Only classes can be passed as proxy
 	*p = new Proxy(cl);
     }
-    $$ = types[0];
+    $$ = types.front();
 }
 ;
 
diff --git a/cpp/src/Slice/OutputUtil.cpp b/cpp/src/Slice/OutputUtil.cpp
index ff17abd6e0b..1d94d0c3713 100644
--- a/cpp/src/Slice/OutputUtil.cpp
+++ b/cpp/src/Slice/OutputUtil.cpp
@@ -36,6 +36,15 @@ Slice::Output::Output()
 {
 }
 
+Slice::Output::Output(const char* s)
+    : pos_(0),
+      indent_(0),
+      indentSave_(-1),
+      separator_(true)
+{
+    open(s);
+}
+
 void
 Slice::Output::open(const char* s)
 {
diff --git a/cpp/src/Slice/OutputUtil.h b/cpp/src/Slice/OutputUtil.h
index bd2dfae6119..f28412b8f02 100644
--- a/cpp/src/Slice/OutputUtil.h
+++ b/cpp/src/Slice/OutputUtil.h
@@ -31,11 +31,12 @@ extern ICE_API Separator sp;
 // Indent
 // ----------------------------------------------------------------------
 
-class ICE_API Output
+class ICE_API Output : ::__Ice::noncopyable
 {
 public:
 
     Output();
+    Output(const char*);
 
     void open(const char*); // Open output stream
 
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index a5cbb1c13c7..164edcac846 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -175,13 +175,8 @@ Slice::operator==(Contained& l, Contained& r)
 void
 Slice::Container::destroy()
 {
-    for(vector<Contained_ptr>::iterator p = contents_.begin();
-	p != contents_.end();
-	++p)
-    {
-	(*p) -> destroy();
-    }
-
+    for_each(contents_.begin(), contents_.end(),
+	     ::Ice::voidMemFun(&Contained::destroy));
     contents_.clear();
     SyntaxTreeBase::destroy();
 }
@@ -189,9 +184,8 @@ Slice::Container::destroy()
 Module_ptr
 Slice::Container::createModule(const string& name)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
-    for(vector<Contained_ptr>::iterator p = matches.begin();
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
+    for(list<Contained_ptr>::iterator p = matches.begin();
 	p != matches.end();
 	++p)
     {
@@ -212,9 +206,8 @@ Slice::Container::createClassDef(const string& name,
 				   const ClassDef_ptr& base,
 				   bool local)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
-    for(vector<Contained_ptr>::iterator p = matches.begin();
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
+    for(list<Contained_ptr>::iterator p = matches.begin();
 	p != matches.end();
 	++p)
     {
@@ -227,7 +220,7 @@ Slice::Container::createClassDef(const string& name,
     ClassDef_ptr def = new ClassDef(this, name, base, local);
     contents_.push_back(def);
     
-    for(vector<Contained_ptr>::iterator q = matches.begin();
+    for(list<Contained_ptr>::iterator q = matches.begin();
 	q != matches.end();
 	++q)
     {
@@ -250,9 +243,8 @@ Slice::Container::createClassDecl(const string& name, bool local)
 {
     ClassDef_ptr def;
 
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
-    for(vector<Contained_ptr>::iterator p = matches.begin();
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
+    for(list<Contained_ptr>::iterator p = matches.begin();
 	p != matches.end();
 	++p)
     {
@@ -276,7 +268,7 @@ Slice::Container::createClassDecl(const string& name, bool local)
     // have a declaration for the class in this container, we don't
     // create another one.
     //
-    for(vector<Contained_ptr>::iterator q = contents_.begin();
+    for(list<Contained_ptr>::iterator q = contents_.begin();
 	q != contents_.end();
 	++q)
     {
@@ -302,8 +294,7 @@ Slice::Container::createClassDecl(const string& name, bool local)
 Native_ptr
 Slice::Container::createNative(const string& name)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
     assert(matches.empty()); // TODO: Already exits
 
     Native_ptr p = new Native(this, name);
@@ -314,8 +305,7 @@ Slice::Container::createNative(const string& name)
 Vector_ptr
 Slice::Container::createVector(const string& name, const Type_ptr& type)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
     assert(matches.empty()); // TODO: Already exits
 
     Vector_ptr p = new Vector(this, name, type);
@@ -323,7 +313,7 @@ Slice::Container::createVector(const string& name, const Type_ptr& type)
     return p;
 }
 
-vector<Type_ptr>
+list<Type_ptr>
 Slice::Container::lookupType(const string& scoped)
 {
     assert(!scoped.empty());
@@ -331,7 +321,7 @@ Slice::Container::lookupType(const string& scoped)
     if(scoped[0] == ':')
 	return parser_ -> lookupType(scoped.substr(2));
     
-    vector<Contained_ptr> matches =
+    list<Contained_ptr> matches =
 	parser_ -> findContents(thisScope() + scoped);
     if(matches.empty())
     {
@@ -341,9 +331,8 @@ Slice::Container::lookupType(const string& scoped)
     }
     else
     {
-	vector<Type_ptr> results;
-	results.reserve(matches.size());
-	for(vector<Contained_ptr>::iterator p = matches.begin();
+	list<Type_ptr> results;
+	for(list<Contained_ptr>::iterator p = matches.begin();
 	    p != matches.end();
 	    ++p)
 	{
@@ -368,7 +357,7 @@ Slice::Container::includeLevel()
 bool
 Slice::Container::hasProxies()
 {
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -387,7 +376,7 @@ Slice::Container::hasProxies()
 bool
 Slice::Container::hasClassDecls()
 {
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -405,7 +394,7 @@ Slice::Container::hasClassDecls()
 bool
 Slice::Container::hasClassDefs()
 {
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -423,7 +412,7 @@ Slice::Container::hasClassDefs()
 bool
 Slice::Container::hasOtherConstructedTypes()
 {
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -452,9 +441,48 @@ Slice::Container::thisScope()
 }
 
 void
+Slice::Container::mergeModules()
+{
+    for(list<Contained_ptr>::iterator p = contents_.begin();
+	p != contents_.end();
+	++p)
+   {
+       Module_ptr mod1 = Module_ptr::dynamicCast(*p);
+       if(!mod1)
+	   continue;
+
+       list<Contained_ptr>::iterator q = p;
+       ++q;
+       while(q != contents_.end())
+       {
+	   Module_ptr mod2 = Module_ptr::dynamicCast(*q);
+	   if(!mod2)
+	   {
+	       ++q;
+	       continue;
+	   }
+
+	   if(mod1 -> name() != mod2 -> name())
+	   {
+	       ++q;
+	       continue;
+	   }
+
+	   copy(mod2 -> contents_.begin(), mod2 -> contents_.end(),
+		back_inserter(mod1 -> contents_));
+	   mod2 -> contents_.empty();
+	   parser_ -> removeContent(*q);
+	   q = contents_.erase(q);
+       }
+
+       mod1 -> mergeModules();
+   }
+}
+
+void
 Slice::Container::visit(ParserVisitor* visitor)
 {
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -557,8 +585,7 @@ Slice::ClassDef::createOperation(const string& name,
 				   const TypeNameList& outParams,
 				   const TypeList& throws)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
     assert(matches.empty()); // TODO: Already exits
 
     Operation_ptr p = new Operation(this, name, returnType,
@@ -570,8 +597,7 @@ Slice::ClassDef::createOperation(const string& name,
 DataMember_ptr
 Slice::ClassDef::createDataMember(const string& name, const Type_ptr& type)
 {
-    vector<Contained_ptr> matches =
-	parser_ -> findContents(thisScope() + name);
+    list<Contained_ptr> matches = parser_ -> findContents(thisScope() + name);
     assert(matches.empty()); // TODO: Already exits
 
     DataMember_ptr p = new DataMember(this, name, type);
@@ -585,17 +611,11 @@ Slice::ClassDef::base()
     return base_;
 }
 
-void
-Slice::ClassDef::base(const ClassDef_ptr& cl)
-{
-    base_ = cl;
-}
-
-vector<Operation_ptr>
+list<Operation_ptr>
 Slice::ClassDef::operations()
 {
-    vector<Operation_ptr> result;
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    list<Operation_ptr> result;
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -606,11 +626,11 @@ Slice::ClassDef::operations()
     return result;
 }
 
-vector<DataMember_ptr>
+list<DataMember_ptr>
 Slice::ClassDef::dataMembers()
 {
-    vector<DataMember_ptr> result;
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    list<DataMember_ptr> result;
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -627,7 +647,7 @@ Slice::ClassDef::abstract()
     if(base_ && base_ -> abstract())
 	return true;
 
-    for(vector<Contained_ptr>::const_iterator p = contents_.begin();
+    for(list<Contained_ptr>::const_iterator p = contents_.begin();
 	p != contents_.end();
 	++p)
     {
@@ -927,22 +947,37 @@ Slice::Parser::addContent(const Contained_ptr& contained)
     contentMap_[contained -> scoped()].push_back(contained);
 }
 
-vector<Contained_ptr>
+void
+Slice::Parser::removeContent(const Contained_ptr& contained)
+{
+    string scoped = contained -> scoped();
+    map<string, list<Contained_ptr> >::iterator p = contentMap_.find(scoped);
+    assert(p != contentMap_.end());
+    list<Contained_ptr>::iterator q;
+    for(q = p -> second.begin(); q != p -> second.end(); ++q)
+	if(q -> get() == contained.get())
+	{
+	    p -> second.erase(q);
+	    return;
+	}
+    assert(false);
+}
+
+list<Contained_ptr>
 Slice::Parser::findContents(const string& scoped)
 {
     assert(!scoped.empty());
     assert(scoped[0] == ':');
 
-    map<string, vector<Contained_ptr> >::iterator p =
-	contentMap_.find(scoped);
+    map<string, list<Contained_ptr> >::iterator p = contentMap_.find(scoped);
 
     if(p != contentMap_.end())
 	return p -> second;
     else
-	return vector<Contained_ptr>();
+	return list<Contained_ptr>();
 }
 
-vector<string>
+list<string>
 Slice::Parser::includeFiles()
 {
     return includeFiles_;
diff --git a/cpp/src/Slice/Parser.h b/cpp/src/Slice/Parser.h
index c5c0a5d57c7..096a3cab578 100644
--- a/cpp/src/Slice/Parser.h
+++ b/cpp/src/Slice/Parser.h
@@ -302,13 +302,14 @@ public:
     ClassDecl_ptr createClassDecl(const std::string&, bool);
     Vector_ptr createVector(const std::string&, const Type_ptr&);
     Native_ptr createNative(const std::string&);
-    std::vector<Type_ptr> lookupType(const std::string&);
+    std::list<Type_ptr> lookupType(const std::string&);
     int includeLevel();
     bool hasProxies();
     bool hasClassDecls();
     bool hasClassDefs();
     bool hasOtherConstructedTypes(); // Other than classes
     std::string thisScope();
+    void mergeModules();
     virtual void visit(ParserVisitor*);
 
 protected:
@@ -316,7 +317,7 @@ protected:
     Container(const Parser_ptr&);
 
     int includeLevel_;
-    std::vector<Contained_ptr> contents_;
+    std::list<Contained_ptr> contents_;
 };
 
 // ----------------------------------------------------------------------
@@ -389,9 +390,8 @@ public:
 				  const TypeList&);
     DataMember_ptr createDataMember(const std::string&, const Type_ptr&);
     ClassDef_ptr base();
-    void base(const ClassDef_ptr&);
-    std::vector<Operation_ptr> operations();
-    std::vector<DataMember_ptr> dataMembers();
+    std::list<Operation_ptr> operations();
+    std::list<DataMember_ptr> dataMembers();
     bool abstract();
     bool local();
     virtual void visit(ParserVisitor*);
@@ -536,9 +536,10 @@ public:
     void popContainer();
 
     void addContent(const Contained_ptr&);
-    std::vector<Contained_ptr> findContents(const std::string&);
+    void removeContent(const Contained_ptr&);
+    std::list<Contained_ptr> findContents(const std::string&);
 
-    std::vector<std::string> includeFiles();
+    std::list<std::string> includeFiles();
 
     int parse(FILE*, bool);
 
@@ -555,10 +556,10 @@ private:
     int currentIncludeLevel_;
     std::string currentFile_;
     std::string topLevelFile_;
-    std::vector<std::string> includeFiles_;
+    std::list<std::string> includeFiles_;
     std::stack<Container_ptr> containerStack_;
     std::map<Builtin::Kind, Builtin_ptr> builtins_;
-    std::map<std::string, std::vector<Contained_ptr> > contentMap_;
+    std::map<std::string, std::list<Contained_ptr> > contentMap_;
 };
 
 extern Parser* parser; // The current parser for bison/flex
diff --git a/cpp/src/Slice/Scanner.l b/cpp/src/Slice/Scanner.l
index 05736dcbfbb..c94b0d5ca94 100644
--- a/cpp/src/Slice/Scanner.l
+++ b/cpp/src/Slice/Scanner.l
@@ -154,6 +154,10 @@ L			[a-zA-Z_]
     return ICE_OBJECT;
 }
 
+"LocalObject" {
+    return ICE_LOCAL_OBJECT;
+}
+
 "native" {
     return ICE_NATIVE;
 }