*** empty log message ***

13 files changed, 2502 insertions, 0 deletions

diff --git a/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp
new file mode 100644
index 00000000000..1c699cec8a5
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp
@@ -0,0 +1,74 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    any_op_ch.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Any operators for an Interface in the client
+//    header.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ***************************************************************************
+// Interface visitor for generating Any operator declarations in the client header
+// ***************************************************************************
+
+be_visitor_interface_any_op_ch::be_visitor_interface_any_op_ch
+(be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_any_op_ch::~be_visitor_interface_any_op_ch (void)
+{
+}
+
+int
+be_visitor_interface_any_op_ch::visit_interface (be_interface *node)
+{
+  if (node->cli_hdr_any_op_gen () || node->imported ())
+    return 0;
+
+  TAO_OutStream *os = tao_cg->client_header ();
+
+  // generate the Any <<= and >>= operator declarations
+  os->indent ();
+  *os << "// Any operators for interface " << node->name () << be_nl;
+  *os << "void " << idl_global->export_macro ()
+      << " operator<<= (CORBA::Any &, const " << node->name ()
+      << " &); // copying version" << be_nl;
+  *os << "void " << idl_global->export_macro ()
+      << " operator<<= (CORBA::Any &, " << node->name ()
+      << "*); // noncopying version" << be_nl;
+  *os << "CORBA::Boolean " << idl_global->export_macro ()
+      << " operator>>= (const CORBA::Any &, "
+      << node->name () << " *&);\n";
+
+  // all we have to do is to visit the scope and generate code
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::visit_interface - "
+                         "codegen for scope failed\n"), -1);
+    }
+
+  node->cli_hdr_any_op_gen (1);
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp
new file mode 100644
index 00000000000..0fd468600e8
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp
@@ -0,0 +1,115 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    any_op_cs.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Any operators for Interface in the stubs
+//    file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ***************************************************************************
+// Interface visitor for generating Any operator declarations in the client
+// stubs file
+// ***************************************************************************
+
+be_visitor_interface_any_op_cs::be_visitor_interface_any_op_cs
+(be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_any_op_cs::~be_visitor_interface_any_op_cs (void)
+{
+}
+
+int
+be_visitor_interface_any_op_cs::visit_interface (be_interface *node)
+{
+  if (node->cli_stub_any_op_gen () || node->imported ())
+    return 0;
+
+  TAO_OutStream *os = tao_cg->client_stubs ();
+
+  // generate the Any <<= and >>= operator declarations
+  // Any <<= and >>= operators
+  os->indent ();
+  *os << "void operator<<= (CORBA::Any &_tao_any, "
+      << node->name () << "_ptr _tao_elem) // copying" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::Environment _tao_env;" << be_nl
+      << "CORBA::Object_ptr *_tao_obj_ptr;" << be_nl
+      << "ACE_NEW (_tao_obj_ptr, CORBA::Object_ptr);" << be_nl
+      << "*_tao_obj_ptr = " << node->name ()
+      << "::_duplicate (_tao_elem);" << be_nl
+      << "_tao_any.replace (" << node->tc_name () << ", "
+      << "_tao_obj_ptr, 1, _tao_env);" << be_uidt_nl
+      << "}" << be_nl;
+
+  *os << "void operator<<= (CORBA::Any &_tao_any, "
+      << node->name () << "_ptr *_tao_elem) // non copying" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::Environment _tao_env;" << be_nl
+      << "_tao_any.replace (" << node->tc_name () << ", "
+      << "_tao_elem, 1, _tao_env); // consume it" << be_uidt_nl
+      << "}" << be_nl;
+
+  *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
+      << node->name () << "_ptr &_tao_elem)" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::Environment _tao_env;" << be_nl
+      << "_tao_elem = " << node->name () << "::_nil ();" << be_nl
+      << "if (!_tao_any.type ()->equal (" << node->tc_name ()
+      << ", _tao_env)) return 0; // not equal" << be_nl
+      << "TAO_InputCDR stream ((ACE_Message_Block *)_tao_any.value ());"
+      << be_nl
+      << "CORBA::Object_ptr *_tao_obj_ptr;" << be_nl
+      << "ACE_NEW_RETURN (_tao_obj_ptr, CORBA::Object_ptr, 0);" << be_nl
+      << "if (stream.decode (" << node->tc_name ()
+      << ", _tao_obj_ptr, 0, _tao_env)" << be_nl
+      << "  == CORBA::TypeCode::TRAVERSE_CONTINUE)" << be_nl
+      << "{" << be_idt_nl
+      << "_tao_elem = " << node->name ()
+      << "::_narrow (*_tao_obj_ptr, _tao_env);" << be_nl
+      << "if (_tao_env.exception ()) return 0; // narrow failed" << be_nl
+      << "CORBA::release (*_tao_obj_ptr);" << be_nl
+      << "*_tao_obj_ptr = _tao_elem;" << be_nl
+      << "((CORBA::Any *)&_tao_any)->replace (_tao_any.type (), "
+      << "_tao_obj_ptr, 1, _tao_env);"
+      << be_nl
+      << "if (_tao_env.exception ()) return 0; // narrow failed" << be_nl
+      << "return 1;" << be_uidt_nl
+      << "}" << be_nl
+      << "return 0; // failure" << be_uidt_nl
+      << "}\n\n";
+
+
+  // all we have to do is to visit the scope and generate code
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::visit_interface - "
+                         "codegen for scope failed\n"), -1);
+    }
+
+  node->cli_stub_any_op_gen (1);
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/collocated_sh.cpp b/TAO/TAO_IDL/be/be_visitor_interface/collocated_sh.cpp
new file mode 100644
index 00000000000..dbc6721bbe8
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/collocated_sh.cpp
@@ -0,0 +1,136 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    collocated_sh.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for collocated classes for the Interface node
+//    inside the server header.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+//  collocated class in header
+// ************************************************************
+
+be_visitor_interface_collocated_sh::be_visitor_interface_collocated_sh
+(be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_collocated_sh::~be_visitor_interface_collocated_sh (void)
+{
+}
+
+int be_visitor_interface_collocated_sh::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os = this->ctx_->stream ();
+
+  os->gen_ifdef_macro (node->flatname (), "_collocated");
+
+  // output the class defn
+  os->indent ();
+  *os << "class " << idl_global->export_macro ()
+      << " " << node->local_coll_name ();
+  os->incr_indent ();
+  *os << " : public virtual " << node->name ();
+
+  // generate base classes if any
+  if (node->n_inherits () > 0)
+    {
+      for (int i = 0; i < node->n_inherits (); ++i)
+        {
+          *os << "," << be_nl;
+          be_interface* parent =
+            be_interface::narrow_from_decl (node->inherits()[i]);
+          *os << "  public virtual "
+              << parent->relative_coll_name (node->full_coll_name ());
+        }
+    }
+  *os << "\n";
+  os->decr_indent ();
+  *os << "{" << be_nl;
+  *os << "public:\n";
+  os->incr_indent ();
+
+  *os << node->local_coll_name () << " (\n";
+
+  os->incr_indent (0);
+  os->incr_indent ();
+
+  // XXXASG - can we make this a method to return the right name ??
+  if (!node->is_nested ())
+    {
+      // The skeleton name is the outermost, we need to printout the
+      // POA_ prefix that goes with it.
+      *os << "POA_";
+    }
+
+  *os << node->local_name () << "_ptr "
+      << " servant," << be_nl;
+
+  *os << "STUB_Object *stub\n";
+  os->decr_indent ();
+  *os << ");\n";
+  os->decr_indent (0);
+
+  os->indent ();
+  if (!node->is_nested ())
+    {
+      // The skeleton name is the outermost, we need to printout the
+      // POA_ prefix that goes with it.
+      *os << "POA_";
+    }
+  *os << node->local_name ()
+      << "_ptr _get_servant (void) const;" << be_nl;
+
+  *os << "virtual CORBA::Boolean _is_a (" << be_idt << be_idt_nl
+      << "const char *logical_type_id," << be_nl
+      << "CORBA::Environment &_tao_environment" << be_uidt_nl
+      << ");\n" << be_uidt;
+
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_collocated_sh::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+
+  os->decr_indent ();
+
+  *os << be_nl << "private:\n";
+  os->incr_indent ();
+  if (!node->is_nested ())
+    {
+      // The skeleton name is the outermost, we need to printout the
+      // POA_ prefix that goes with it.
+      *os << "POA_";
+    }
+  *os << node->local_name () << "_ptr servant_;\n";
+  os->decr_indent ();
+  *os << "};\n\n";
+
+  os->gen_endif ();
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/collocated_ss.cpp b/TAO/TAO_IDL/be/be_visitor_interface/collocated_ss.cpp
new file mode 100644
index 00000000000..46981deb762
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/collocated_ss.cpp
@@ -0,0 +1,161 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    collocated_ss.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for collocated classes for an Interface in the
+//    server skeleton file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+//  be_visitor_interface_collacted_ss
+// ************************************************************
+
+be_visitor_interface_collocated_ss::be_visitor_interface_collocated_ss
+(be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_collocated_ss::~be_visitor_interface_collocated_ss (void)
+{
+}
+
+int be_visitor_interface_collocated_ss::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os = tao_cg->server_skeletons ();
+  long i;
+
+  this->ctx_->node (node);
+
+  *os << node->full_coll_name () << "::"
+      << node->local_coll_name () << " (\n";
+
+  os->incr_indent (0);
+  os->incr_indent ();
+  *os << node->full_skel_name () << "_ptr "
+      << " servant," << be_nl;
+
+  *os << "STUB_Object *stub\n";
+  os->decr_indent ();
+  *os << ")\n";
+  os->decr_indent (0);
+
+  os->incr_indent ();
+
+  if (node->is_nested ())
+    {
+      be_decl* scope =
+	be_scope::narrow_from_scope (node->defined_in ())->decl ();
+
+      *os << ": ACE_NESTED_CLASS ("
+	  << scope->name () << ","
+	  << node->local_name ()
+	  << ") ()," << be_nl;
+    }
+  else
+    {
+      *os << ": " << node->name ()
+	  << " ()," << be_nl;
+    }
+
+  // @@ We should call the constructor for all base classes, since we
+  // are using multiple inheritance.
+
+  if (node->traverse_inheritance_graph (be_interface::collocated_ctor_helper, os)
+      == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_collocated_ss::"
+                         "visit_interface - "
+                         "codegen for base class ctor init failed\n"),
+                        -1);
+    }
+
+#if 0
+  if (node->n_inherits () > 0)
+    {
+      for (i = 0; i < node->n_inherits (); ++i)
+        {
+          be_interface* parent =
+            be_interface::narrow_from_decl (node->inherits()[i]);
+	  if (parent->is_nested ())
+	    {
+	      be_decl* scope =
+		be_scope::narrow_from_scope (parent->defined_in())->decl ();
+
+	      *os << "  ACE_NESTED_CLASS ("
+		  << "POA_" << scope->name () << ","
+		  << parent->local_coll_name ()
+		  << ") (servant, stub)," << be_nl;
+	    }
+	  else
+	    {
+	      *os << "  " << parent->full_coll_name ()
+		  << " (servant, stub)," << be_nl;
+	    }
+        }
+    }
+#endif
+
+  *os << "  CORBA_Object (stub, servant, CORBA::B_TRUE)," << be_nl
+      << "  servant_ (servant)";
+
+  *os << "\n";
+  os->decr_indent ();
+  *os << "{\n";
+  *os << "}\n\n";
+
+  os->indent ();
+  *os << node->full_skel_name () << "_ptr "
+      << node->full_coll_name () << "::"
+      << "_get_servant (void) const\n"
+      << "{\n";
+  os->incr_indent ();
+  *os << "return this->servant_;\n";
+  os->decr_indent ();
+  *os << "}\n\n";
+
+  os->indent ();
+  *os << "CORBA::Boolean " << node->full_coll_name ()
+      << "::_is_a (" << be_idt << be_idt_nl
+      << "const char* logical_type_id," << be_nl
+      << "CORBA::Environment &_tao_environment" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << "return this->servant_->_is_a (" << be_idt << be_idt_nl
+      << "logical_type_id," << be_nl
+      << "_tao_environment" << be_uidt_nl
+      << ");" << be_uidt << be_uidt_nl
+      << "}\n\n";
+
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_collocated_ss::"
+                         "visit_scope - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface.cpp
new file mode 100644
index 00000000000..a8d0f2cac6e
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface.cpp
@@ -0,0 +1,632 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces. This is a generic visitor.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+// ******************************************************
+// Generic Interface visitor
+// ******************************************************
+
+be_visitor_interface::be_visitor_interface (be_visitor_context *ctx)
+  : be_visitor_scope (ctx)
+{
+}
+
+be_visitor_interface::~be_visitor_interface (void)
+{
+}
+
+// this method must be overridden by the derived interface visitors
+int
+be_visitor_interface::visit_interface (be_interface *node)
+{
+  return -1;
+}
+
+// =all common visit methods for interface visitor
+
+// visit an attribute
+int
+be_visitor_interface::visit_attribute (be_attribute *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_SH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_SS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_COLLOCATED_SH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_COLLOCATED_SS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_TIE_SH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      ctx.state (TAO_CodeGen::TAO_ATTRIBUTE_TIE_SI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_attribute - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_attribute - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_attribute - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit a constant
+int
+be_visitor_interface::visit_constant (be_constant *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_CONSTANT_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_CONSTANT_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_constant - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_constant - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_constant - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+//visit an enum
+int
+be_visitor_interface::visit_enum (be_enum *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_ENUM_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_ENUM_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+      ctx.state (TAO_CodeGen::TAO_ENUM_ANY_OP_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+      ctx.state (TAO_CodeGen::TAO_ENUM_ANY_OP_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_enum - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_enum - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_enum - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit an exception
+int
+be_visitor_interface::visit_exception (be_exception *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_EXCEPTION_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+      ctx.state (TAO_CodeGen::TAO_EXCEPTION_CI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_EXCEPTION_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+      ctx.state (TAO_CodeGen::TAO_EXCEPTION_ANY_OP_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+      ctx.state (TAO_CodeGen::TAO_EXCEPTION_ANY_OP_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_exception - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_exception - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_exception - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit an operation
+int
+be_visitor_interface::visit_operation (be_operation *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_CH);
+      //      return node->gen_client_header ();
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_CS);
+      //      return node->gen_client_stubs ();
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_SH);
+      //      return node->gen_server_header ();
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_SS);
+      //      return node->gen_server_skeletons ();
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_COLLOCATED_SH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_COLLOCATED_SS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_TIE_SH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      ctx.state (TAO_CodeGen::TAO_OPERATION_TIE_SI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_operation - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  // grab the appropriate visitor
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_operation - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // visit the node using this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_operation - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit an structure
+int
+be_visitor_interface::visit_structure (be_structure *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_STRUCT_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+      ctx.state (TAO_CodeGen::TAO_STRUCT_CI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_STRUCT_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+      ctx.state (TAO_CodeGen::TAO_STRUCT_ANY_OP_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+      ctx.state (TAO_CodeGen::TAO_STRUCT_ANY_OP_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_structure - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_structure - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_structure - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit a union
+int
+be_visitor_interface::visit_union (be_union *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_UNION_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+      ctx.state (TAO_CodeGen::TAO_UNION_CI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_UNION_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+      ctx.state (TAO_CodeGen::TAO_UNION_ANY_OP_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+      ctx.state (TAO_CodeGen::TAO_UNION_ANY_OP_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_union - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_union - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_union - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
+
+// visit a typedef
+int
+be_visitor_interface::visit_typedef (be_typedef *node)
+{
+  // instantiate a visitor context with a copy of our context. This info
+  // will be modified based on what type of node we are visiting
+  be_visitor_context ctx (*this->ctx_);
+  ctx.node (node); // set the node to be the node being visited. The scope is
+                   // still the same
+
+  // this switch is acceptable rather than having derived visitors overriding
+  // this method and differing only in what state they set
+
+  switch (this->ctx_->state ())
+    {
+    case TAO_CodeGen::TAO_INTERFACE_CH:
+      ctx.state (TAO_CodeGen::TAO_TYPEDEF_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CI:
+      ctx.state (TAO_CodeGen::TAO_TYPEDEF_CI);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_CS:
+      ctx.state (TAO_CodeGen::TAO_TYPEDEF_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CH:
+      ctx.state (TAO_CodeGen::TAO_TYPEDEF_ANY_OP_CH);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_ANY_OP_CS:
+      ctx.state (TAO_CodeGen::TAO_TYPEDEF_ANY_OP_CS);
+      break;
+    case TAO_CodeGen::TAO_INTERFACE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_SI:
+    case TAO_CodeGen::TAO_INTERFACE_SS:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH:
+    case TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SH:
+    case TAO_CodeGen::TAO_INTERFACE_TIE_SI:
+      return 0; // nothing to be done
+    default:
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "(%N:%l) be_visitor_interface::"
+                           "visit_typedef - "
+                           "Bad context state\n"
+                           ), -1);
+      }
+      break;
+    }
+
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_typedef - "
+                         "NUL visitor\n"
+                         ),  -1);
+    }
+
+  // let the node accept this visitor
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface::"
+                         "visit_typedef - "
+                         "failed to accept visitor\n"
+                         ),  -1);
+    }
+  delete visitor;
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_ch.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_ch.cpp
new file mode 100644
index 00000000000..c45fb65d730
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_ch.cpp
@@ -0,0 +1,214 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_ch.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the client header
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ******************************************************
+// Interface visitor for client header
+// ******************************************************
+
+be_visitor_interface_ch::be_visitor_interface_ch (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_ch::~be_visitor_interface_ch (void)
+{
+}
+
+int
+be_visitor_interface_ch::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+  long i;            // loop index
+
+  if (!node->cli_hdr_gen () && !node->imported ()) // not already generated and
+                                                   // not imported
+    {
+
+      os = this->ctx_->stream ();
+
+      // == STEP 1:  generate the class name and class names we inherit ==
+
+      // generate the ifdefined macro for  the _ptr type
+      os->gen_ifdef_macro (node->flatname (), "_ptr");
+
+      // the following two are required to be under the ifdef macro to avoid
+      // multiple declarations
+
+      os->indent (); // start with whatever indentation level we are at
+      // forward declaration
+      *os << "class " << node->local_name () << ";" << be_nl;
+      // generate the _ptr declaration
+      *os << "typedef " << node->local_name () << " *" << node->local_name ()
+          << "_ptr;" << be_nl;
+
+      os->gen_endif ();
+
+      // generate the ifdefined macro for the var type
+      os->gen_ifdef_macro (node->flatname (), "_var");
+
+      // generate the _var declaration
+      if (node->gen_var_defn () == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_interface_ch::"
+                             "visit_interface - "
+                             "codegen for _var failed\n"), -1);
+        }
+      os->gen_endif ();
+
+      // generate the ifdef macro for the _out class
+      os->gen_ifdef_macro (node->flatname (), "_out");
+
+      // generate the _out declaration - ORBOS/97-05-15 pg 16-20 spec
+      if (node->gen_out_defn () == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_interface_ch::"
+                             "visit_interface - "
+                             "codegen for _out failed\n"), -1);
+        }
+      // generate the endif macro
+      os->gen_endif ();
+
+      // now the interface definition itself
+      os->gen_ifdef_macro (node->flatname ());
+
+      // now generate the class definition
+      os->indent ();
+      *os << "class " << idl_global->export_macro ()
+	  << " " << node->local_name ();
+
+      if (node->n_inherits () > 0)  // node interface inherits from other
+                                    // interfaces
+        {
+          *os << ": ";
+          for (i = 0; i < node->n_inherits (); i++)
+            {
+              be_interface *inherited =
+                be_interface::narrow_from_decl (node->inherits ()[i]);
+              be_decl *scope = 0;
+              if (inherited->is_nested ())
+                {
+                  // inherited node is used in the scope of "node" node
+                  scope = be_scope::narrow_from_scope (node->defined_in ())
+                    ->decl ();
+                }
+
+              *os << "public virtual ";
+              *os << inherited->nested_type_name (scope);  // dump the scoped name
+              if (i < node->n_inherits () - 1) // node is the case of multiple
+                                               // inheritance, so put a comma
+                {
+                  *os << ", ";
+                }
+            }  // end of for loop
+          *os << be_nl;
+        }
+      else
+        {
+          // we do not inherit from anybody, hence we do so from the base
+          // CORBA::Object class
+          // Generate code that uses the macro. This is required to deal with
+          // the MSVC++ insanity
+          *os << " : public virtual ACE_CORBA_1 (Object)" << be_nl;
+        }
+
+      // generate the body
+
+      *os << "{" << be_nl
+          << "public:" << be_idt_nl
+        // generate the static _duplicate, _narrow, and _nil operations
+          << "// the static operations" << be_nl
+          << "static " << node->local_name () << "_ptr " << "_duplicate ("
+          << node->local_name () << "_ptr obj);" << be_nl
+          << "static " << node->local_name () << "_ptr " << "_narrow ("
+          << "CORBA::Object_ptr obj, CORBA::Environment &env);" << be_nl
+          << "static " << node->local_name () << "_ptr " << "_nil (void);\n\n";
+
+      // generate code for the interface definition by traversing thru the
+      // elements of its scope. We depend on the front-end to have made sure
+      // that only legal syntactic elements appear in our scope.
+      if (this->visit_scope (node) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_interface_ch::"
+                             "visit_interface - "
+                             "codegen for scope failed\n"), -1);
+        }
+      // the _is_a method
+      os->indent ();
+      *os << "virtual CORBA::Boolean _is_a ("
+	  << "const CORBA::Char *type_id, " << be_idt << be_idt_nl
+          << "CORBA::Environment &env" << be_uidt_nl
+	  << ");" << be_uidt_nl
+	  << "virtual const char* "
+	  << "_interface_repository_id (void) const;" << be_uidt_nl;
+
+      // generate the "protected" constructor so that users cannot instantiate
+      // us
+      *os << "protected:" << be_idt_nl
+	  << node->local_name () << " (void); // default constructor" << be_nl
+          << node->local_name ()
+	  << " (STUB_Object *objref, " << be_idt << be_idt_nl
+          << "TAO_ServantBase *_tao_servant = 0, " << be_nl
+          << "CORBA::Boolean _tao_collocated = 0" << be_uidt_nl
+	  << ");" << be_uidt_nl
+          << "virtual ~" << node->local_name () << " (void);" << be_uidt_nl;
+
+      // private copy constructor and assignment operator. These are not
+      // allowed, hence they are private.
+      *os << "private:\n";
+      os->incr_indent ();
+      *os << node->local_name () << " (const " << node->local_name () << " &);"
+          << be_nl
+          << "void operator= (const " << node->local_name () << " &);\n";
+
+      os->decr_indent ();
+      *os << "};\n\n";
+      os->gen_endif ();
+
+      // by using a visitor to declare and define the TypeCode, we have the
+      // added advantage to conditionally not generate any code. This will be
+      // based on the command line options. This is still TO-DO
+      be_visitor *visitor;
+      be_visitor_context ctx (*this->ctx_);
+      ctx.state (TAO_CodeGen::TAO_TYPECODE_DECL);
+      visitor = tao_cg->make_visitor (&ctx);
+      if (!visitor || (node->accept (visitor) == -1))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_interface_ch::"
+                             "visit_interface - "
+                             "TypeCode declaration failed\n"
+                             ), -1);
+        }
+
+
+      node->cli_hdr_gen (I_TRUE);
+    } // if !cli_hdr_gen
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_ci.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_ci.cpp
new file mode 100644
index 00000000000..b3fd272704d
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_ci.cpp
@@ -0,0 +1,102 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_ci.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the client inline file
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// **************************************************
+// Interface visitor for client inline
+// **************************************************
+be_visitor_interface_ci::be_visitor_interface_ci (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_ci::~be_visitor_interface_ci (void)
+{
+}
+
+int
+be_visitor_interface_ci::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+
+  if (node->cli_inline_gen () || node->imported ())
+    return 0;
+
+  os = this->ctx_->stream ();
+
+  os->indent (); // start from the current indentation level
+
+  // generate the constructors and destructor
+  *os << "ACE_INLINE" << be_nl;
+  *os << node->name () << "::" << node->local_name () <<
+    " (void) // default constructor" << be_nl;
+  *os << "{}" << be_nl << be_nl;
+
+  *os << "ACE_INLINE" << be_nl;
+  *os << node->name () << "::" << node->local_name () <<
+    " (STUB_Object *objref, TAO_ServantBase *_tao_servant, "
+      << "CORBA::Boolean _tao_collocated) // constructor" << be_nl;
+  *os << "  : CORBA_Object (objref, _tao_servant, _tao_collocated)" << be_nl;
+  *os << "{}" << be_nl << be_nl;
+
+  *os << "ACE_INLINE" << be_nl;
+  *os << node->name () << "::~" << node->local_name () <<
+    " (void) // destructor" << be_nl;
+  *os << "{}\n\n";
+
+  // generate the ifdefined macro for  the _var type
+  os->gen_ifdef_macro (node->flatname (), "_var");
+  if (node->gen_var_impl () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_ci::"
+                         "visit_interface - "
+                         "codegen for _var failed\n"), -1);
+    }
+  os->gen_endif ();
+
+  // generate the ifdefined macro for  the _out type
+  os->gen_ifdef_macro (node->flatname (), "_out");
+  if (node->gen_out_impl () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_ci::"
+                         "visit_interface - "
+                         "codegen for _out failed\n"), -1);
+    }
+  os->gen_endif ();
+
+  // generate inline methods for elements of our scope
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_ci::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"), -1);
+    }
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_cs.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_cs.cpp
new file mode 100644
index 00000000000..32e09f04cea
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_cs.cpp
@@ -0,0 +1,181 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_cs.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the client stubs file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+// Interface visitor for client stubs
+// ************************************************************
+
+be_visitor_interface_cs::be_visitor_interface_cs (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_cs::~be_visitor_interface_cs (void)
+{
+}
+
+int
+be_visitor_interface_cs::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+
+  if (node->cli_stub_gen () || node->imported ())
+    return 0;
+
+  os = this->ctx_->stream ();
+
+  os->indent (); // start with whatever indentation level we are at
+
+  // first generate the code for the static methods
+
+  // The _duplicate method
+  *os << node->name () << "_ptr " << node->name () << "::_duplicate ("
+      << node->name () << "_ptr obj)" << be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "if (!CORBA::is_nil (obj))\n";
+  os->incr_indent ();
+  *os << "obj->AddRef ();\n";
+  os->decr_indent ();
+  *os << be_nl;
+  *os << "return obj;\n";
+  os->decr_indent ();
+  *os << "} // end of _duplicate" << be_nl << be_nl;
+
+  // The _narrow method
+  *os << node->name () << "_ptr " << node->name ()
+      << "::_narrow (" << be_idt << be_idt_nl
+      << "CORBA::Object_ptr obj," << be_nl
+      << "CORBA::Environment &env" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << "if (CORBA::is_nil (obj))" << be_idt_nl
+      << "return " << node->name () << "::_nil ();" << be_uidt_nl
+      << "if (!obj->_is_a (\"" << node->repoID () << "\", env))"
+      << be_idt_nl
+      << "return " << node->name () << "::_nil ();" << be_uidt_nl;
+
+  *os << "if (!obj->_is_collocated ()" << be_idt << be_idt << be_idt_nl
+      << " || !obj->_servant()" << be_nl
+      << " || obj->_servant()->_downcast (\""
+      << node->repoID () << "\") == 0" << be_uidt_nl
+      << ")" << be_uidt << be_uidt_nl
+      << "{" << be_idt_nl;
+  *os << node->name () << "_ptr new_obj = new "
+      << node->name () << "(obj->_get_parent ());" << be_nl
+      << "return new_obj;" << be_uidt_nl
+      << "} // end of if" << be_nl;
+
+  *os << "STUB_Object *stub = obj->_servant ()->_create_stub (env);" << be_nl
+      << "if (env.exception () != 0)" << be_idt_nl
+      << "return " << node->name () << "::_nil ();" << be_uidt_nl
+      << "void* servant = obj->_servant ()->_downcast (\""
+      << node->repoID () << "\");" << be_nl
+      << "return new ";
+
+  // This may be necessary to work around a GCC compiler bug!
+  const char *skel_name = node->full_skel_name ();
+  const char *coll_name = node->full_coll_name ();
+  assert (coll_name != 0);
+
+  *os << coll_name << "(" << be_idt << be_idt_nl
+      << "ACE_reinterpret_cast(" << skel_name
+      << "_ptr, servant)," << be_nl
+      << "stub" << be_uidt_nl
+      << ");" << be_uidt << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  // _nil method
+  *os << node->name () << "_ptr " << node->name () << "::_nil (void)" <<
+    be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "return (" << node->name () << "_ptr)NULL;\n";
+  os->decr_indent ();
+  *os << "} // end of _nil" << be_nl << be_nl;
+
+  // generate code for the elements of the interface
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_cs::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"), -1);
+    }
+
+  // generate the is_a method
+  os->indent ();
+  *os << "CORBA::Boolean " << node->name () << "::_is_a (" <<
+    "const CORBA::Char *value, CORBA::Environment &env)" << be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "if (\n";
+  os->incr_indent (0);
+  if (node->traverse_inheritance_graph (be_interface::is_a_helper, os) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_cs::"
+                         "visit_interface - "
+                         "_is_a method codegen failed\n"), -1);
+    }
+
+  os->indent ();
+  *os << "(!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (env))))\n";
+  *os << "  return 1; // success using local knowledge\n";
+  os->decr_indent ();
+  *os << "else" << be_nl;
+  *os << "  return this->CORBA_Object::_is_a (value, env); // remote call\n";
+  os->decr_indent ();
+  *os << "}\n\n";
+
+  os->indent ();
+  *os << "const char* " << node->name ()
+      << "::_interface_repository_id (void) const"
+      << be_nl
+      << "{" << be_idt_nl
+      << "return \"" << node->repoID () << "\";" << be_uidt_nl
+      << "}\n\n";
+
+  // by using a visitor to declare and define the TypeCode, we have the
+  // added advantage to conditionally not generate any code. This will be
+  // based on the command line options. This is still TO-DO
+  be_visitor *visitor;
+  be_visitor_context ctx (*this->ctx_);
+  ctx.state (TAO_CodeGen::TAO_TYPECODE_DEFN);
+  visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor || (node->accept (visitor) == -1))
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_cs::"
+                         "visit_interface - "
+                         "TypeCode definition failed\n"
+                         ), -1);
+    }
+
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_sh.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_sh.cpp
new file mode 100644
index 00000000000..e0fbd194310
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_sh.cpp
@@ -0,0 +1,191 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_sh.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the server header
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+// Interface visitor for server header
+// ************************************************************
+
+be_visitor_interface_sh::be_visitor_interface_sh (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_sh::~be_visitor_interface_sh (void)
+{
+}
+
+int
+be_visitor_interface_sh::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+  long i; // loop index
+  static char namebuf [NAMEBUFSIZE]; // holds the class name
+
+  if (node->srv_hdr_gen () || node->imported ())
+    return 0;
+
+  ACE_OS::memset (namebuf, '\0', NAMEBUFSIZE);
+
+  os = this->ctx_->stream ();
+
+  // generate the skeleton class name
+
+  os->indent (); // start with whatever indentation level we are at
+
+  // we shall have a POA_ prefix only if we are at the topmost level
+  if (!node->is_nested ())
+    {
+      // we are outermost
+      ACE_OS::sprintf (namebuf, "POA_%s", node->local_name ()->get_string ());
+    }
+  else
+    {
+      ACE_OS::sprintf (namebuf, "%s", node->local_name ()->get_string ());
+    }
+
+  *os << "class " << namebuf << ";" << be_nl;
+
+  // generate the _ptr declaration
+  *os << "typedef " << namebuf << " *" << namebuf
+      << "_ptr;" << be_nl;
+
+  // now generate the class definition
+  *os << "class " << idl_global->export_macro ()
+      << " " << namebuf << " : ";
+  if (node->n_inherits () > 0)
+    {
+      // this interface inherits from other interfaces
+      be_interface *intf; // inherited interface
+
+      *os << "public virtual ";
+      intf = be_interface::narrow_from_decl (node->inherits ()[0]);
+      *os << intf->relative_skel_name (node->full_skel_name ());
+      for (i = 1; i < node->n_inherits (); i++)
+        {
+          *os << ", public virtual ";
+          intf = be_interface::narrow_from_decl (node->inherits ()[i]);
+          *os << intf->relative_skel_name (node->full_skel_name ());
+        }  // end of for loop
+    }
+  else
+    {
+      // We don't inherit from another user defined object, hence our
+      // base class is the ServantBase class.
+      *os << " public virtual PortableServer::ServantBase";
+    }
+  *os << be_nl
+      << "{" << be_nl
+      << "protected:" << be_idt_nl
+      << namebuf << " (void);" << be_uidt_nl
+      << "public:" << be_idt_nl
+      << "virtual ~" << namebuf << " (void);" << be_nl;
+
+  *os << "virtual CORBA::Boolean _is_a (" << be_idt << be_idt_nl
+      << "const char* logical_type_id," << be_nl
+      << "CORBA::Environment &_tao_environment" << be_uidt
+      << ");\n" << be_uidt;
+
+  os->indent ();
+  *os << "virtual void* _downcast (" << be_idt << be_idt_nl
+      << "const char* logical_type_id" << be_uidt_nl
+      << ");\n" << be_uidt;
+
+  // generate code for elements in the scope (e.g., operations)
+  if (this->visit_scope (node) ==  -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_sh::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+  // add a skeleton for our _is_a method
+  os->indent ();
+  *os << "static void _is_a_skel (CORBA::ServerRequest &req, " <<
+    "void *obj, void *context, CORBA::Environment &_tao_enviroment);\n\n";
+
+  // generate skeletons for operations of our base classes. These skeletons
+  // just cast the pointer to the appropriate type before invoking the call
+  if (node->traverse_inheritance_graph (be_interface::gen_skel_helper, os) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_sh::"
+                         "visit_interface - "
+                         "inheritance graph traversal failed\n"),
+                        -1);
+    }
+
+  // add the dispatch method
+  os->indent ();
+  *os << "virtual void _dispatch (CORBA::ServerRequest &_tao_req, "
+      << "void *_tao_context, CORBA::Environment &_tao_env);\n\n";
+
+  // Print out the _this() method.
+  os->indent ();
+  *os << node->name () << " *_this (CORBA::Environment &_tao_environment);\n";
+  // the _interface_repository_id method
+  os->indent ();
+  *os << "virtual const char* _interface_repository_id"
+      << " (void) const;\n";
+
+  os->decr_indent ();
+
+  *os << "};\n\n";
+
+  // generate the collocated class
+  be_visitor_context ctx (*this->ctx_);
+  ctx.state (TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SH);
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor || (node->accept (visitor) == -1))
+    {
+      delete visitor;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_sh::"
+                         "visit_interface - "
+                         "codegen for collocated class failed\n"),
+                        -1);
+    }
+
+  // generate the TIE class
+  ctx = *this->ctx_;
+  ctx.state (TAO_CodeGen::TAO_INTERFACE_TIE_SH);
+  visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor || (node->accept (visitor) == -1))
+    {
+      delete visitor;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_sh::"
+                         "visit_interface - "
+                         "codegen for TIE class failed\n"),
+                        -1);
+    }
+
+  *os << "\n";
+  ctx.stream (tao_cg->server_template_header ());
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_si.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_si.cpp
new file mode 100644
index 00000000000..64fe692d2ba
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_si.cpp
@@ -0,0 +1,81 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_si.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the server inline file
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************************
+// Interface visitor for server inline
+// ************************************************************************
+
+be_visitor_interface_si::be_visitor_interface_si (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_si::~be_visitor_interface_si (void)
+{
+}
+
+int
+be_visitor_interface_si::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+
+  if (node->srv_inline_gen () || node->imported ())
+    return 0;
+
+  os = this->ctx_->stream ();
+
+  os->indent (); // start with whatever indentation level we are at
+
+  // Generate skeletons for operations of our base classes. These skeletons
+  // just cast the pointer to the appropriate type before invoking the
+  // call. Hence we generate these in the inline file
+  if (node->traverse_inheritance_graph (be_interface::gen_skel_helper, os)
+      == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_interface_si::"
+                         "visit_interface - "
+                         "codegen for base class skeletons failed\n"), -1);
+    }
+
+  // generate the TIE class
+  be_visitor_context ctx (*this->ctx_);
+  ctx.state (TAO_CodeGen::TAO_INTERFACE_TIE_SI);
+  ctx.stream (tao_cg->server_template_inline ());
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor || (node->accept (visitor) == -1))
+    {
+      delete visitor;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_sh::"
+                         "visit_interface - "
+                         "codegen for TIE class failed\n"),
+                        -1);
+    }
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/interface_ss.cpp b/TAO/TAO_IDL/be/be_visitor_interface/interface_ss.cpp
new file mode 100644
index 00000000000..021de9daeed
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/interface_ss.cpp
@@ -0,0 +1,285 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    interface_ss.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for Interfaces in the server skeletons file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+// Interface visitor for server skeletons
+// ************************************************************
+
+be_visitor_interface_ss::be_visitor_interface_ss (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_ss::~be_visitor_interface_ss (void)
+{
+}
+
+int
+be_visitor_interface_ss::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+
+  if (node->srv_skel_gen () || node->imported ())
+    return 0;
+
+  os = this->ctx_->stream ();
+
+  // generate the skeleton class name
+
+  os->indent (); // start with whatever indentation level we are at
+
+  if (node->gen_operation_table () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "codegen for operation table failed\n"),
+                        -1);
+    }
+
+  // constructor
+  *os << "// skeleton constructor" << be_nl;
+  // find if we are at the top scope or inside some module
+  if (!node->is_nested ())
+    {
+      // we are outermost. So the POA_ prefix is prepended to our name
+      *os << node->full_skel_name () << "::POA_" << node->local_name () <<
+        " (void)" << be_nl;
+    }
+  else
+    {
+      // the POA_ prefix is prepended to our outermost module name
+      *os << node->full_skel_name () << "::" << node->local_name () <<
+        " (void)" << be_nl;
+    }
+
+  *os << "{" << be_idt_nl
+      << "this->optable_ = &tao_" << node->flatname ()
+      << "_optable;" << be_uidt_nl
+      << "}\n\n";
+
+  // destructor
+  os->indent ();
+  *os << "// skeleton destructor" << be_nl;
+
+  if (!node->is_nested ())
+    {
+      // we are outermost. So the POA_ prefix is prepended to our name
+      *os << node->full_skel_name () << "::~POA_" << node->local_name () <<
+        " (void)" << be_nl;
+    }
+  else
+    {
+      // the POA_ prefix is prepended to our outermost module name
+      *os << node->full_skel_name () << "::~" << node->local_name () <<
+        " (void)" << be_nl;
+    }
+  *os << "{\n";
+  *os << "}\n";
+
+
+  // generate code for elements in the scope (e.g., operations)
+  if (this->visit_scope (node) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+
+  // generate code for the _is_a skeleton
+  os->indent ();
+  *os << "void " << node->full_skel_name ()
+      << "::_is_a_skel (" << be_idt << be_idt_nl
+      << "CORBA::ServerRequest &_tao_server_request, " << be_nl
+      << "void * _tao_object_reference," << be_nl
+      << "void * /*context*/," << be_nl
+      << "CORBA::Environment &_tao_environment" << be_uidt_nl
+      << ")" << be_uidt_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "static const TAO_Param_Data_Skel " << node->flatname ()
+      << "_is_a_paramdata [] = " << be_nl;
+  *os << "{" << be_idt_nl;
+  *os << "{CORBA::_tc_boolean, 0, 0}," << be_nl;
+  *os << "{CORBA::_tc_string, CORBA::ARG_IN, 0}" << be_uidt_nl;
+  *os << "};" << be_nl;
+  *os << "static const TAO_Call_Data_Skel " << node->flatname ()
+      << "_is_a_calldata = " << be_nl;
+  *os << "{\"_is_a\", 1, 2, " << node->flatname () << "_is_a_paramdata};"
+      << be_nl;
+  *os << "CORBA::Environment _tao_skel_environment;" << be_nl;
+  *os << node->full_skel_name () << "_ptr  _tao_impl = ("
+      << node->full_skel_name () << "_ptr) _tao_object_reference;"
+      << be_nl;
+  *os << "CORBA::Boolean _tao_retval;" << be_nl;
+  *os << "char *_tao_value = 0;" << be_nl;
+  *os << "_tao_server_request.demarshal (" << be_idt_nl
+      << "_tao_environment, " << be_nl
+      << "&" << node->flatname () << "_is_a_calldata, " << be_nl
+      << "&_tao_retval, " << be_nl
+      << "&_tao_value" << be_uidt_nl
+      << ");" << be_nl;
+  *os << "if (_tao_environment.exception () != 0) return;" << be_nl;
+  *os << "_tao_retval = _tao_impl->_is_a (_tao_value, "
+      << "_tao_skel_environment);" << be_nl;
+  *os << "_tao_server_request.marshal (" << be_idt_nl
+      << "_tao_environment, " << be_nl
+      << "_tao_skel_environment," << be_nl
+      << "&" << node->flatname () << "_is_a_calldata, " << be_nl
+      << "&_tao_retval, " << be_nl
+      << "&_tao_value" << be_uidt_nl
+      << ");" << be_nl;
+  *os << "CORBA::string_free (_tao_value);" << be_uidt_nl;
+  *os << "}\n\n";
+
+
+  os->indent ();
+  *os << "CORBA::Boolean " << node->full_skel_name ()
+      << "::_is_a (" << be_idt << be_idt_nl
+      << "const char* value," << be_nl
+      << "CORBA::Environment &_tao_environment" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << "if (\n" << be_idt;
+  if (node->traverse_inheritance_graph (be_interface::is_a_helper, os) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "traversal of inhertance graph failed\n"),
+                        -1);
+    }
+
+  os->indent ();
+  *os << "(!ACE_OS::strcmp ((char *)value, "
+      << "CORBA::_tc_Object->id (_tao_environment))))"
+      << be_idt_nl << "return CORBA::B_TRUE;" << be_uidt_nl
+      << "else" << be_idt_nl
+      << "return CORBA::B_FALSE;" << be_uidt << be_uidt << be_uidt_nl
+      << "}\n\n";
+
+  os->indent ();
+  *os << "void* " << node->full_skel_name ()
+      << "::_downcast (" << be_idt << be_idt_nl
+      << "const char* logical_type_id" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl;
+
+  if (node->traverse_inheritance_graph (be_interface::downcast_helper, os) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "traversal of inhertance graph failed\n"),
+                        -1);
+    }
+
+  *os << "if (ACE_OS::strcmp (logical_type_id, "
+      << "\"IDL:omg.org/CORBA/Object:1.0\") == 0)" << be_idt_nl
+      << "return ACE_static_cast(PortableServer::Servant, this);"
+      << be_uidt_nl;
+
+  *os << "return 0;" << be_uidt_nl
+      << "}\n\n";
+
+
+  // now the dispatch method
+  os->indent ();
+  *os << "void " << node->full_skel_name () <<
+    "::_dispatch (CORBA::ServerRequest &req, " <<
+    "void *context, CORBA::Environment &env)" << be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "TAO_Skeleton skel; // pointer to skeleton for operation" << be_nl;
+  *os << "const char *opname = req.operation (); // retrieve operation name"
+      << be_nl;
+  *os << "// find the skeleton corresponding to this opname" << be_nl;
+  *os << "if (this->_find (opname, skel) == -1)" << be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "env.exception (new CORBA_BAD_OPERATION (CORBA::COMPLETED_NO));"
+      << be_nl;
+  *os << "ACE_ERROR ((LM_ERROR, \"Bad operation <%s>\\n\", opname));\n";
+  os->decr_indent ();
+  *os << "}\n";
+  *os << "else" << be_nl;
+  *os << "  skel (req, this, context, env);\n";
+  os->decr_indent ();
+  *os << "}\n\n";
+
+  os->indent ();
+  *os << "const char* " << node->full_skel_name ()
+      << "::_interface_repository_id (void) const"
+      << be_nl;
+  *os << "{\n";
+  os->incr_indent ();
+  *os << "return \"" << node->repoID () << "\";\n";
+  os->decr_indent ();
+  *os << "}\n\n";
+
+  // generate the collocated class impl
+  be_visitor_context ctx (*this->ctx_);
+  ctx.state (TAO_CodeGen::TAO_INTERFACE_COLLOCATED_SS);
+  be_visitor *visitor = tao_cg->make_visitor (&ctx);
+  if (!visitor)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "Bad visitor for collocated class\n"),
+                        -1);
+    }
+
+  if (node->accept (visitor) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_ss::"
+                         "visit_interface - "
+                         "codegen for collocated class failed\n"),
+                        -1);
+    }
+  delete visitor;
+
+  *os << "\n";
+
+  // the _this () operation
+  *os << node->name () << "*" << be_nl
+      << node->full_skel_name ()
+      << "::_this (CORBA_Environment &_env)" << be_nl
+      << "{" << be_idt_nl
+      << "STUB_Object *stub = this->_create_stub (_env);" << be_nl
+      << "if (_env.exception () != 0)" << be_idt_nl
+      << "return 0;" << be_uidt_nl
+      << "return new " << node->full_coll_name ()
+      << " (this, stub);" << be_uidt << be_nl;
+
+  *os << "}\n\n";
+
+   return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/tie_sh.cpp b/TAO/TAO_IDL/be/be_visitor_interface/tie_sh.cpp
new file mode 100644
index 00000000000..021309aee09
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/tie_sh.cpp
@@ -0,0 +1,142 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    tie_sh.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for TIE class for an Interface in the header
+//    file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************
+// Interface visitor for server header
+// ************************************************************
+
+be_visitor_interface_tie_sh::be_visitor_interface_tie_sh (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_tie_sh::~be_visitor_interface_tie_sh (void)
+{
+}
+
+int
+be_visitor_interface_tie_sh::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+  static char namebuf [NAMEBUFSIZE]; // holds the class name
+  static char tiename [NAMEBUFSIZE]; // holds the tie name
+
+  if (node->srv_hdr_gen () || node->imported ())
+    return 0;
+
+  ACE_OS::memset (namebuf, '\0', NAMEBUFSIZE);
+  ACE_OS::memset (tiename, '\0', NAMEBUFSIZE);
+
+  os = this->ctx_->stream ();
+
+  // generate the skeleton class name which will be used to determine the TIE
+  // class name
+
+  // we shall have a POA_ prefix only if we are at the topmost level
+  if (!node->is_nested ())
+    {
+      // we are outermost
+      ACE_OS::sprintf (namebuf, "POA_%s", node->local_name ()->get_string ());
+      ACE_OS::sprintf (tiename, "POA_%s_tie",
+                       node->local_name ()->get_string ());
+    }
+  else
+    {
+      ACE_OS::sprintf (namebuf, "%s", node->local_name ()->get_string ());
+      ACE_OS::sprintf (tiename, "%s_tie",
+                       node->local_name ()->get_string ());
+    }
+
+  // now generate the class definition
+  os->indent (); // start with whatever indentation level we are at
+
+  // Since templates nested inside of classes are broken on most C++ compilers,
+  // we generate code for this inside a conditional macro. The code is
+  // activated only if "namespaces" are supported on the platform
+  if (node->is_nested ())
+    {
+      *os << "\n#if defined (ACE_HAS_USING_KEYWORD)" << be_nl;
+    }
+
+  *os << "// TIE class: Refer to CORBA v2.2, Section 20.34.4" << be_nl;
+  *os << "template <class T>" << be_nl;
+  *os << "class " << idl_global->export_macro ()
+      << " " << tiename << " : public " << namebuf << be_nl;
+  *os << "{" << be_nl
+      << "public:" << be_idt_nl
+      << tiename << " (T &t);" << be_nl
+      << "// the T& ctor" << be_nl
+      << tiename << " (T &t, PortableServer::POA_ptr poa);" << be_nl
+      << "// ctor taking a POA" << be_nl
+      << tiename << " (T *tp, CORBA::Boolean release=1);" << be_nl
+      << "// ctor taking pointer and an ownership flag" << be_nl
+      << tiename << " (T *tp, PortableServer::POA_ptr poa, "
+      << "CORBA::Boolean release=1);" << be_nl
+      << "// ctor with T*, ownership flag and a POA" << be_nl
+      << "~" << tiename << " (void);" << be_nl
+      << "// dtor" << be_nl << be_nl
+      << "// TIE specific functions" << be_nl
+      << "T *_tied_object (void);" << be_nl
+      << "// return the underlying object" << be_nl
+      << "void _tied_object (T &obj);" << be_nl
+      << "// set the underlying object" << be_nl
+      << "void _tied_object (T *obj, CORBA::Boolean release=1);" << be_nl
+      << "// set the underlying object and the ownership flag" << be_nl
+      << "CORBA::Boolean _is_owner (void);" << be_nl
+      << "// do we own it" << be_nl
+      << "void _is_owner (CORBA::Boolean b);" << be_nl
+      << "// set the ownership" << be_nl << be_nl
+      << "// overridden ServantBase operations" << be_nl
+      << "PortableServer::POA_ptr _default_POA (CORBA::Environment &env);\n";
+
+  // generate code for the operations in the scope
+  if (this->visit_scope (node) ==  -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_tie_sh::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+
+  *os << be_uidt << "private:" << be_idt_nl
+      << "T *ptr_;" << be_nl
+      << "PortableServer::POA_var poa_;" << be_nl
+      << "CORBA::Boolean rel_;" << be_nl << be_nl
+      << "// copy and assignment are not allowed" << be_nl
+      << tiename << " (const " << tiename << " &);" << be_nl
+      << "void operator= (const " << tiename << " &);" << be_uidt_nl
+      << "};\n\n";
+
+  if (node->is_nested ())
+    {
+      *os << "#endif /* ACE_HAS_USING_KEYWORD */\n";
+    }
+
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/tie_si.cpp b/TAO/TAO_IDL/be/be_visitor_interface/tie_si.cpp
new file mode 100644
index 00000000000..15d17f4aba9
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_interface/tie_si.cpp
@@ -0,0 +1,188 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    tie_si.cpp
+//
+// = DESCRIPTION
+//    Visitor generating code for TIE classes for the Interface node in the
+//    inline file.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_interface.h"
+
+
+// ************************************************************************
+// Interface visitor for server inline
+// ************************************************************************
+
+be_visitor_interface_tie_si::be_visitor_interface_tie_si (be_visitor_context *ctx)
+  : be_visitor_interface (ctx)
+{
+}
+
+be_visitor_interface_tie_si::~be_visitor_interface_tie_si (void)
+{
+}
+
+int
+be_visitor_interface_tie_si::visit_interface (be_interface *node)
+{
+  TAO_OutStream *os; // output stream
+  static char fulltiename [NAMEBUFSIZE]; // holds the class name
+  static char localtiename [NAMEBUFSIZE]; // holds the tie name
+
+  if (node->srv_inline_gen () || node->imported ())
+    return 0;
+
+  ACE_OS::memset (fulltiename, '\0', NAMEBUFSIZE);
+  ACE_OS::memset (localtiename, '\0', NAMEBUFSIZE);
+
+  os = this->ctx_->stream ();
+
+  // generate the skeleton class name which will be used to determine the TIE
+  // class name
+
+  // we are outermost
+  ACE_OS::sprintf (fulltiename, "%s_tie", node->full_skel_name ());
+  if (!node->is_nested ())
+    {
+      ACE_OS::sprintf (localtiename, "POA_%s_tie",
+                       node->local_name ()->get_string ());
+    }
+  else
+    {
+      ACE_OS::sprintf (localtiename, "%s_tie",
+                       node->local_name ()->get_string ());
+    }
+
+  if (node->is_nested ())
+    {
+      *os << "\n#if defined (ACE_HAS_USING_KEYWORD)\n";
+    }
+
+  os->indent (); // start with whatever indentation level we are at
+
+  *os << "template <class T> ACE_INLINE" << be_nl
+      << fulltiename << "<T>::" << localtiename << " (T &t)" << be_nl
+      << "\t: ptr_ (&t)," << be_nl
+      << "\t  poa_ (PortableServer::POA::_nil ())," << be_nl
+      << "\t  rel_ (0)" << be_nl
+      << "{}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE" << be_nl
+      << fulltiename << "<T>::" << localtiename
+      << " (T &t, PortableServer::POA_ptr poa)" << be_nl
+      << "\t: ptr_ (&t)," << be_nl
+      << "\t  poa_ (PortableServer::POA::_duplicate (poa))," << be_nl
+      << "\t  rel_ (0)" << be_nl
+      << "{}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE" << be_nl
+      << fulltiename << "<T>::" << localtiename
+      << " (T *tp, CORBA::Boolean release)" << be_nl
+      << "\t: ptr_ (tp)," << be_nl
+      << "\t  poa_ (PortableServer::POA::_nil ())," << be_nl
+      << "\t  rel_ (release)" << be_nl
+      << "{}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE" << be_nl
+      << fulltiename << "<T>::" << localtiename
+      << " (T *tp, PortableServer::POA_ptr poa, CORBA::Boolean release)"
+      << be_nl
+      << "\t: ptr_ (tp)," << be_nl
+      << "\t  poa_ (PortableServer::POA::_duplicate (poa))," << be_nl
+      << "\t  rel_ (release)" << be_nl
+      << "{}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE" << be_nl
+      << fulltiename << "<T>::~" << localtiename << " (void)" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::release (this->poa_);" << be_nl
+      << "if (this->rel_) delete this->ptr_;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE T *" << be_nl
+      << fulltiename << "<T>::_tied_object (void)" << be_nl
+      << "{" << be_idt_nl
+      << "return this->ptr_;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE void" << be_nl
+      << fulltiename << "<T>::_tied_object (T &obj)" << be_nl
+      << "{" << be_idt_nl
+      << "if (this->rel_) delete this->ptr_;" << be_nl
+      << "this->ptr_ = &obj;" << be_nl
+      << "this->rel_ = 0;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE void" << be_nl
+      << fulltiename << "<T>::_tied_object (T *obj, "
+      << "CORBA::Boolean release)" << be_nl
+      << "{" << be_idt_nl
+      << "if (this->rel_) delete this->ptr_;" << be_nl
+      << "this->ptr_ = obj;" << be_nl
+      << "this->rel_ = release;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE CORBA::Boolean" << be_nl
+      << fulltiename << "<T>::_is_owner (void)" << be_nl
+      << "{" << be_idt_nl
+      << "return this->rel_;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE void" << be_nl
+      << fulltiename << "<T>::_is_owner (CORBA::Boolean b)" << be_nl
+      << "{" << be_idt_nl
+      << "this->rel_ = b;" << be_uidt_nl
+      << "}" << be_nl << be_nl;
+
+  *os << "template <class T> ACE_INLINE "
+      << "PortableServer::POA_ptr" << be_nl
+      << fulltiename << "<T>::_default_POA (CORBA::Environment &env)" << be_nl
+      << "{" << be_idt_nl
+      << "if (!CORBA::is_nil (this->poa_.in ()))" << be_idt_nl
+      << "return PortableServer::POA::_duplicate (this->poa_.in ());"
+      << be_uidt_nl
+      << "else" << be_nl
+      << "{" << be_idt_nl
+      << "TAO_POA *poa = TAO_ORB_Core_instance ()->root_poa ();" << be_nl
+      << "PortableServer::POA_var result = poa->_this (env);" << be_nl
+      << "if (env.exception () != 0)" << be_idt_nl
+      << "return PortableServer::POA::_nil ();" << be_uidt_nl
+      << "else" << be_idt_nl
+      << "return result._retn ();" << be_uidt << be_uidt_nl
+      << "}" << be_uidt
+      << "}\n\n";
+
+  // generate code for the operations in the scope
+  if (this->visit_scope (node) ==  -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_interface_tie_si::"
+                         "visit_interface - "
+                         "codegen for scope failed\n"),
+                        -1);
+    }
+
+  if (node->is_nested ())
+    {
+      *os << "#endif /* ACE_HAS_USING_KEYWORD */\n";
+    }
+
+  return 0;
+}