Added support for --imple-tie to slice2cs.

3 files changed, 231 insertions, 79 deletions

diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index 1670cce9052..646e24b0cec 100755
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -720,7 +720,7 @@ Slice::CsVisitor::getArgsAsyncCB(const OperationPtr& op)
 }
 
 Slice::Gen::Gen(const string& name, const string& base, const vector<string>& includePaths, const string& dir,
-                bool impl)
+                bool impl, bool implTie)
     : _base(base),
       _includePaths(includePaths)
 {
@@ -780,7 +780,7 @@ Slice::Gen::Gen(const string& name, const string& base, const vector<string>& in
     _out << sp << nl << "using _System = System;";
     _out << nl << "using _Microsoft = Microsoft;";
 
-    if(impl)
+    if(impl || implTie)
     {
         struct stat st;
 	if(stat(fileImpl.c_str(), &st) == 0)
@@ -864,6 +864,13 @@ Slice::Gen::generateImpl(const UnitPtr& p)
 }
 
 void
+Slice::Gen::generateImplTie(const UnitPtr& p)
+{
+    ImplTieVisitor implTieVisitor(_impl);
+    p->visit(&implTieVisitor);
+}
+
+void
 Slice::Gen::printHeader()
 {
     static const char* header =
@@ -3725,11 +3732,6 @@ Slice::Gen::TieVisitor::visitModuleEnd(const ModulePtr&)
     _out << eb;
 }
 
-Slice::Gen::ImplVisitor::ImplVisitor(IceUtil::Output& out)
-    : CsVisitor(out)
-{
-}
-
 bool
 Slice::Gen::TieVisitor::visitClassDefStart(const ClassDefPtr& p)
 {
@@ -3944,71 +3946,13 @@ Slice::Gen::TieVisitor::writeInheritedOperations(const ClassDefPtr& p, NameSet&
     }
 }
 
-bool
-Slice::Gen::ImplVisitor::visitModuleStart(const ModulePtr& p)
-{
-    if(!p->hasClassDefs())
-    {
-        return false;
-    }
-
-    _out << sp << nl << "namespace " << fixId(p->name());
-    _out << sb;
-
-    return true;
-}
-
-void
-Slice::Gen::ImplVisitor::visitModuleEnd(const ModulePtr&)
-{
-    _out << eb;
-}
-
-bool
-Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
-{
-    if(!p->isAbstract())
-    {
-        return false;
-    }
-
-    string name = fixId(p->name());
-
-    _out << sp << nl << "public sealed class " << name << 'I';
-    if(p->isInterface())
-    {
-        if(p->isLocal())
-	{
-	    _out << " : Ice.LocalObjectImpl, " << name;
-	}
-	else
-	{
-	    _out << " : " << name << "_Disp";
-	}
-    }
-    else
-    {
-        _out << " : " << name;
-    }
-    _out << sb;
-
-    OperationList ops = p->allOperations();
-    for(OperationList::const_iterator r = ops.begin(); r != ops.end(); ++r)
-    {
-        writeOperation(*r, p->isLocal());
-    }
-
-    return true;
-}
-
-void
-Slice::Gen::ImplVisitor::visitClassDefEnd(const ClassDefPtr&)
+Slice::Gen::BaseImplVisitor::BaseImplVisitor(IceUtil::Output& out)
+    : CsVisitor(out)
 {
-    _out << eb;
 }
 
 void
-Slice::Gen::ImplVisitor::writeOperation(const OperationPtr& op, bool local)
+Slice::Gen::BaseImplVisitor::writeOperation(const OperationPtr& op, bool local, bool comment, bool forTie)
 {
     ClassDefPtr cl = ClassDefPtr::dynamicCast(op->container());
     string opName = fixId(op->name());
@@ -4017,12 +3961,32 @@ Slice::Gen::ImplVisitor::writeOperation(const OperationPtr& op, bool local)
     ParamDeclList params = op->parameters();
     ParamDeclList::const_iterator i;
 
+    if(comment)
+    {
+	_out << nl << "// ";
+    }
+    else
+    {
+	_out << sp << nl;
+    }
+
     if(!local && (cl->hasMetaData("amd") || op->hasMetaData("amd")))
     {
         vector<string> pDecl = getParamsAsync(op, true);
 
-	_out << sp << nl << "public override void " << opName << "_async"
-	     << spar << pDecl << "Ice.Current __current" << epar;
+	_out << "public ";
+	if(!forTie)
+	{
+	    _out << "override ";
+	}
+	_out << "void " << opName << "_async" << spar << pDecl << "Ice.Current __current" << epar;
+
+	if(comment)
+	{
+	    _out << ';';
+	    return;
+	}
+
 	_out << sb;
 	if(ret)
 	{
@@ -4062,12 +4026,22 @@ Slice::Gen::ImplVisitor::writeOperation(const OperationPtr& op, bool local)
     {
 	vector<string> pDecls = getParams(op);
 
-        _out << sp << nl << "public override " << retS << ' ' << opName << spar << pDecls;
+	_out << "public ";
+	if(!forTie)
+	{
+	    _out << "override ";
+	}
+	_out << retS << ' ' << opName << spar << pDecls;
 	if(!local)
 	{
 	    _out << "Ice.Current __current";
 	}
 	_out << epar;
+	if(comment)
+	{
+	    _out << ';';
+	    return;
+	}
 	_out << sb;
 	for(ParamDeclList::const_iterator i = params.begin(); i != params.end(); ++i)
 	{
@@ -4087,7 +4061,7 @@ Slice::Gen::ImplVisitor::writeOperation(const OperationPtr& op, bool local)
 }
 
 string
-Slice::Gen::ImplVisitor::writeValue(const TypePtr& type)
+Slice::Gen::BaseImplVisitor::writeValue(const TypePtr& type)
 {
     assert(type);
 
@@ -4141,3 +4115,160 @@ Slice::Gen::ImplVisitor::writeValue(const TypePtr& type)
 
     return "null";
 }
+
+Slice::Gen::ImplVisitor::ImplVisitor(IceUtil::Output& out)
+    : BaseImplVisitor(out)
+{
+}
+
+bool
+Slice::Gen::ImplVisitor::visitModuleStart(const ModulePtr& p)
+{
+    if(!p->hasClassDefs())
+    {
+        return false;
+    }
+
+    _out << sp << nl << "namespace " << fixId(p->name());
+    _out << sb;
+
+    return true;
+}
+
+void
+Slice::Gen::ImplVisitor::visitModuleEnd(const ModulePtr&)
+{
+    _out << eb;
+}
+
+bool
+Slice::Gen::ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    if(!p->isAbstract())
+    {
+        return false;
+    }
+
+    string name = fixId(p->name());
+
+    _out << sp << nl << "public sealed class " << name << 'I';
+    if(p->isInterface())
+    {
+        if(p->isLocal())
+	{
+	    _out << " : Ice.LocalObjectImpl, " << name;
+	}
+	else
+	{
+	    _out << " : " << name << "_Disp";
+	}
+    }
+    else
+    {
+        _out << " : " << name;
+    }
+    _out << sb;
+
+    OperationList ops = p->allOperations();
+    for(OperationList::const_iterator r = ops.begin(); r != ops.end(); ++r)
+    {
+        writeOperation(*r, p->isLocal(), false, false);
+    }
+
+    return true;
+}
+
+void
+Slice::Gen::ImplVisitor::visitClassDefEnd(const ClassDefPtr&)
+{
+    _out << eb;
+}
+
+Slice::Gen::ImplTieVisitor::ImplTieVisitor(IceUtil::Output& out)
+    : BaseImplVisitor(out)
+{
+}
+
+bool
+Slice::Gen::ImplTieVisitor::visitModuleStart(const ModulePtr& p)
+{
+    if(!p->hasClassDefs())
+    {
+        return false;
+    }
+
+    _out << sp << nl << "namespace " << fixId(p->name());
+    _out << sb;
+
+    return true;
+}
+
+void
+Slice::Gen::ImplTieVisitor::visitModuleEnd(const ModulePtr&)
+{
+    _out << eb;
+}
+
+bool
+Slice::Gen::ImplTieVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    if(!p->isAbstract())
+    {
+        return false;
+    }
+
+    string name = fixId(p->name());
+    ClassList bases = p->bases();
+
+    //
+    // Use implementation inheritance in the following situations:
+    //
+    // * if a class extends another class
+    // * if a class implements a single interface
+    // * if an interface extends only one interface
+    //
+    bool inheritImpl = (!p->isInterface() && !bases.empty() && !bases.front()->isInterface()) || (bases.size() == 1);
+
+    _out << sp << nl << "public class " << name << "I : ";
+    if(inheritImpl)
+    {
+        _out << fixId(bases.front()->name()) << "I, ";
+    }
+    _out << name << "_Operations";
+    _out << sb;
+
+    _out << nl << "public " << name << "I()";
+    _out << sb;
+    _out << eb;
+
+    OperationList ops = p->allOperations();
+    ops.sort();
+
+    OperationList baseOps;
+    if(inheritImpl)
+    {
+        baseOps = bases.front()->allOperations();
+        baseOps.sort();
+    }
+
+    OperationList::const_iterator r;
+    for(r = ops.begin(); r != ops.end(); ++r)
+    {
+        if(inheritImpl && binary_search(baseOps.begin(), baseOps.end(), *r))
+        {
+            _out << sp;
+            _out << nl << "// ";
+            _out << nl << "// Implemented by " << fixId(bases.front()->name()) << 'I';
+            _out << nl << "//";
+            writeOperation(*r, p->isLocal(), true, true);
+        }
+        else
+        {
+            writeOperation(*r, p->isLocal(), false, true);
+        }
+    }
+
+    _out << eb;
+
+    return true;
+}
diff --git a/cpp/src/slice2cs/Gen.h b/cpp/src/slice2cs/Gen.h
index 756ea88f83c..b41c83c3e7d 100644
--- a/cpp/src/slice2cs/Gen.h
+++ b/cpp/src/slice2cs/Gen.h
@@ -44,6 +44,7 @@ public:
         const std::string&,
         const std::vector<std::string>&,
 	const std::string&,
+	bool,
 	bool);
     ~Gen();
 
@@ -52,6 +53,7 @@ public:
     void generate(const UnitPtr&);
     void generateTie(const UnitPtr&);
     void generateImpl(const UnitPtr&);
+    void generateImplTie(const UnitPtr&);
 
 private:
 
@@ -203,7 +205,22 @@ private:
 	void writeInheritedOperations(const ClassDefPtr&, NameSet&);
     };
 
-    class ImplVisitor : public CsVisitor
+    class BaseImplVisitor : public CsVisitor
+    {
+    public:
+
+        BaseImplVisitor(::IceUtil::Output&);
+
+    protected:
+
+	void writeOperation(const OperationPtr&, bool, bool, bool);
+
+    private:
+
+	::std::string writeValue(const TypePtr&);
+    };
+
+    class ImplVisitor : public BaseImplVisitor
     {
     public:
 
@@ -213,11 +230,17 @@ private:
 	virtual void visitModuleEnd(const ModulePtr&);
 	virtual bool visitClassDefStart(const ClassDefPtr&);
 	virtual void visitClassDefEnd(const ClassDefPtr&);
+    };
 
-    private:
+    class ImplTieVisitor : public BaseImplVisitor
+    {
+    public:
 
-	void writeOperation(const OperationPtr&, bool);
-	::std::string writeValue(const TypePtr&);
+        ImplTieVisitor(::IceUtil::Output&);
+
+	virtual bool visitModuleStart(const ModulePtr&);
+	virtual void visitModuleEnd(const ModulePtr&);
+	virtual bool visitClassDefStart(const ClassDefPtr&);
     };
 };
 
diff --git a/cpp/src/slice2cs/Main.cpp b/cpp/src/slice2cs/Main.cpp
index b101e76b700..ed4c7938750 100644
--- a/cpp/src/slice2cs/Main.cpp
+++ b/cpp/src/slice2cs/Main.cpp
@@ -235,7 +235,7 @@ main(int argc, char* argv[])
 	    }
 	    else
 	    {
-		Gen gen(argv[0], icecpp.getBaseName(), includePaths, output, impl);
+		Gen gen(argv[0], icecpp.getBaseName(), includePaths, output, impl, implTie);
 		if(!gen)
 		{
 		    p->destroy();
@@ -250,12 +250,10 @@ main(int argc, char* argv[])
 		{
 		    gen.generateImpl(p);
 		}
-#if 0
 		if(implTie)
 		{
 		    gen.generateImplTie(p);
 		}
-#endif
 	    }
 
 	    p->destroy();