*** empty log message ***

10 files changed, 719 insertions, 521 deletions

diff --git a/TAO/TAO_IDL/be/be_array.cpp b/TAO/TAO_IDL/be/be_array.cpp
index b3211329eb0..967bfb0042c 100644
--- a/TAO/TAO_IDL/be/be_array.cpp
+++ b/TAO/TAO_IDL/be/be_array.cpp
@@ -216,449 +216,6 @@ be_array::gen_dimensions (TAO_OutStream *os, unsigned short slice)
   return 0;
 }
 
-#if 0 // to be eventually removed after we add support
-
-int
-be_array::gen_client_header (void)
-{
-  TAO_OutStream *ch; // output stream
-  TAO_NL  nl;        // end line
-  be_type *bt;       // our base type
-  be_state *s;       // state based code gen object
-
-  if (!this->cli_hdr_gen_) // not already generated
-    {
-      // retrieve a singleton instance of the code generator
-      TAO_CodeGen *cg = TAO_CODEGEN::instance ();
-      cg->push (TAO_CodeGen::TAO_ARRAY_DEFN_CH); // set current code gen state
-
-      ch = cg->client_header (); // retrieve client hdr stream
-
-      if (this->create_name () == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "name creation failed\n"),
-                            0);
-        }
-      s = cg->make_state (); // get the state-based code generation object
-      if (!s)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "Bad state\n"),
-                            -1);
-        }
-
-      // retrieve the base type
-      bt = be_type::narrow_from_decl (this->base_type ());
-      if (!bt)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "Bad type\n"),
-                            -1);
-        }
-
-      // generate the ifdefined macro for the array type
-      ch->gen_ifdef_macro (this->flatname ());
-
-      ch->indent (); // start from current indentation
-      // generate code for our base type if required and then print the type
-      // name
-      if (s->gen_code (bt, this) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "state based codegen failed\n"),
-                            -1);
-        }
-
-      // print our name
-      *ch << " " <<  this->local_name ();
-      // print our dimensions
-      if (this->gen_dimensions (ch) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "dimension codegen failed\n"),
-                            -1);
-        }
-
-      *ch << ";" << nl;
-
-      // if our base type is VARIABLE length, then we are variable length too
-      this->size_type (bt->size_type ());
-      cg->pop ();
-
-      cg->push (TAO_CodeGen::TAO_ARRAY_OTHER_CH); // rest of the array defn
-      s = cg->make_state ();
-      if (!s)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "bad state\n"),
-                            -1);
-        }
-
-      // now generate the slice definition
-      *ch << "typedef ";
-      if (s->gen_code (bt, this) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "state based codegen failed\n"),
-                            -1);
-        }
-
-      *ch << " " <<  this->local_name () << "_slice";
-      // print dimensions except first one
-      if (this->gen_dimensions (ch, 1) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "slice dimensions codegen failed\n"),
-                            -1);
-        }
-      *ch << ";" << nl;
-
-      // memory management functions
-
-      // The T_alloc method
-      // first find if we are inside a scope
-      if (this->is_nested ()) // we were defined inside a scope. Hence the
-                              // memory management functions become static
-                              // members of the enclosing class
-        *ch << "static ";
-
-      // the return type is a pointer to slice
-      *ch <<  this->local_name () << "_slice *"
-          << this->local_name () << "_alloc (void);" << nl;
-      // the T_dup method
-      if (this->is_nested ())
-        *ch << "static ";
-      *ch <<  this->local_name () << "_slice *" << this->local_name () <<
-        "_dup (const " << this->local_name () << "_slice *);" << nl;
-      // the T_free method
-      if (this->is_nested ())
-        *ch << "static ";
-      *ch << "void " << this->local_name () << "_free (" << this->local_name ()
-          << "_slice *);\n\n";
-
-      // Generate the typecode decl
-      if (this->is_nested ())
-        {
-          // we have a scoped name
-          ch->indent ();
-          *ch << "static CORBA::TypeCode_ptr "
-              << this->tao_name () << ";\n\n";
-        }
-      else
-        {
-          // we are in the ROOT scope
-          ch->indent ();
-          *ch << "extern "
-              << idl_global->export_macro ()
-              << " CORBA::TypeCode_ptr "
-              << this->tao_name () << ";\n\n";
-        }
-      ch->gen_endif ();
-
-      // generate the ifdefined macro
-      ch->gen_ifdef_macro (this->flatname (), "_var");
-      // generate the _var, _out, and _forany definition
-      if (this->gen_var_defn () == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "error generating _var class\n"),
-                            -1);
-        }
-      ch->gen_endif ();
-
-      // generate the ifdefined macro
-      ch->gen_ifdef_macro (this->flatname (), "_out");
-      if (this->gen_out_defn () == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "error generating _out class\n"),
-                            -1);
-        }
-      ch->gen_endif ();
-
-      // generate the ifdefined macro
-      ch->gen_ifdef_macro (this->flatname (), "_forany");
-      if (this->gen_forany_defn () == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_header - "
-                             "error generating _forany class\n"),
-                            -1);
-        }
-      ch->gen_endif ();
-
-      this->cli_hdr_gen_ = I_TRUE;
-      cg->pop ();
-    }
-
-  return 0;
-}
-
-int
-be_array::gen_client_stubs (void)
-{
-  TAO_OutStream *cs; // output stream
-  TAO_NL  nl;        // end line
-  unsigned long i;
-
-  if (!this->cli_stub_gen_)
-    {
-      // retrieve a singleton instance of the code generator
-      TAO_CodeGen *cg = TAO_CODEGEN::instance ();
-      cg->push (TAO_CodeGen::TAO_SEQUENCE_BODY_CS); // set current code gen state
-
-      cs = cg->client_stubs ();
-
-      // generate the typecode information here
-      cs->indent (); // start from current indentation level
-      *cs << "static const CORBA::Long _oc_"
-          << this->tao_name () << "[] =" << nl;
-      *cs << "{\n";
-      cs->incr_indent (0);
-      if (this->gen_encapsulation () == -1)
-        {
-          ACE_ERROR ((LM_ERROR, "be_array:Error generating encapsulation\n\n"));
-          return -1;
-        }
-      cs->decr_indent ();
-      *cs << "};" << nl;
-
-      *cs << "static CORBA::TypeCode _tc__tc_"
-          << this->tao_name ()
-          << " (CORBA::tk_sequence, "
-          << "sizeof (_oc_" <<  this->tao_name ()
-          << "), (char *) &_oc_"
-          << this->tao_name ()
-          << ", CORBA::B_FALSE);" << nl;
-      *cs << "CORBA::TypeCode_ptr "
-          << this->tao_name () << " = &_tc__tc_"
-          << this->tao_name () << ";\n\n";
-
-      cg->pop ();
-      this->cli_stub_gen_ = I_TRUE;
-
-      // T_dup method
-      *cs << this->name () << "_slice *" << nl;
-      *cs << this->name () << "_dup (const "
-          << this->name () << "_slice * s)" << nl;
-      *cs << "{\n";
-      cs->incr_indent ();
-      *cs << this->name () << "_slice *temp;" << nl;
-      *cs << "// alloc an array" << nl;
-      *cs << "temp = " << this->name () << "_alloc ();" << nl;
-      *cs << "// copy each individual elements" << nl;
-      // generate nested loops for as many dimensions as there are
-      for (i = 0; i < this->n_dims (); i++)
-        {
-          AST_Expression *expr = this->dims ()[i]; // retrieve the ith
-                                                   // dimension value
-          if ((expr == NULL) || ((expr != NULL) && (expr->ev () == NULL)))
-            {
-              ACE_ERROR_RETURN ((LM_ERROR,
-                                 "(%N:%l) be_array::"
-                                 "gen_client_stubs - "
-                                 "bad array dimension\n"),
-                                -1);
-            }
-          if (expr->ev ()->et == AST_Expression::EV_ulong)
-            {
-              // generate a loop for each dimension
-              *cs << "for (CORBA::ULong i" << i << " = 0; i" << i << " < " <<
-                expr->ev ()->u.ulval << "; i" << i << "++)\n";
-              cs->incr_indent ();
-            }
-          else
-            {
-              ACE_ERROR_RETURN ((LM_ERROR,
-                                 "(%N:%l) be_array::"
-                                 "gen_client_stubs - "
-                                 "bad array dimension value\n"),
-                                -1);
-            }
-        }
-
-      // now generate code such that every element of the array gets assigned
-      // inside the innermost level of the  nested loops generated above
-      *cs << "temp"; // generate the lvalue
-      for (i = 0; i < this->n_dims (); i++)
-        {
-          *cs << "[i" << i << "]";
-        }
-      *cs << " = ";
-      *cs << "s";  // generate the rvalue
-      for (i = 0; i < this->n_dims (); i++)
-        {
-          *cs << "[i" << i << "]";
-        }
-      *cs << ";\n";
-      for (i = 0; i < this->n_dims (); i++)
-        {
-          // decrement indentation as many times as the number of dimensions
-          cs->decr_indent (0);
-        }
-      cs->indent ();
-      *cs << "return temp;\n";
-      // one more to get to the outermost level
-      cs->decr_indent ();
-      *cs << "}\n\n";
-    }
-
-  return 0;
-}
-
-// Generates the client-side inline information
-int
-be_array::gen_client_inline (void)
-{
-
-  if (!this->cli_inline_gen_)
-    {
-      TAO_OutStream *ci; // output stream
-      TAO_NL  nl;        // end line
-      be_type *bt;       // our base type
-      be_state *s;       // state based code gen obj
-
-      // retrieve a singleton instance of the code generator
-      TAO_CodeGen *cg = TAO_CODEGEN::instance ();
-
-      ci = cg->client_inline ();
-      cg->push (TAO_CodeGen::TAO_ARRAY_DEFN_CI);
-      s = cg->make_state ();
-      if (!s)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_inline - "
-                             "bad state\n"),
-                            -1);
-        }
-
-      // retrieve our base type
-      bt = be_type::narrow_from_decl (this->base_type ());
-      if (!bt)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_inline - "
-                             "bad base type\n"),
-                            -1);
-        }
-
-      // first define the _alloc, _dup and _free methods
-      // If we are defined inside some scope, these methods become static
-      // members of the enclosing scope
-
-      // alloc method
-      ci->indent (); // start from current indentation
-      *ci << "ACE_INLINE " << this->name () << "_slice *" << nl;
-      *ci << this->name () << "_alloc (void)" << nl;
-      *ci << "{\n";
-      ci->incr_indent ();
-      *ci << "return new ";
-      if (s->gen_code (bt, this) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_inline - "
-                             "state based codegen failed\n"),
-                            -1);
-        }
-      if (this->gen_dimensions (ci) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "(%N:%l) be_array::"
-                             "gen_client_inline - "
-                             "dimensions codegen failed\n"),
-                            -1);
-        }
-
-      *ci << ";\n";
-      ci->decr_indent ();
-      *ci << "}\n\n";
-
-      // free method
-      *ci << "ACE_INLINE void" << nl
-          << this->name () << "_free (" << this->name ()
-          << "_slice *s)" << nl;
-      *ci << "{\n";
-      ci->incr_indent ();
-      *ci << "delete [] s;\n";
-      ci->decr_indent ();
-      *ci << "}\n\n";
-
-      // emit implementations of methods of the _var, _out, and _forany classes
-      if (this->gen_var_impl () == -1)
-        {
-          ACE_ERROR ((LM_ERROR, "be_array: _var impl code gen failed\n"));
-          return -1;
-        }
-      if (this->gen_out_impl () == -1)
-        {
-          ACE_ERROR ((LM_ERROR, "be_array: _out impl code gen failed\n"));
-          return -1;
-        }
-      if (this->gen_forany_impl () == -1)
-        {
-          ACE_ERROR ((LM_ERROR, "be_array: _forany impl code gen failed\n"));
-          return -1;
-        }
-
-      // generate client inline for base type
-      if (bt->gen_client_inline () == -1)
-        {
-          ACE_ERROR ((LM_ERROR, "be_array: base type inline code gen failed\n"));
-          return -1;
-        }
-
-      cg->pop ();
-      this->cli_inline_gen_ = I_TRUE;
-    }
-
-  return 0;
-}
-
-int
-be_array::gen_server_header (void)
-{
-  return 0;
-}
-
-int
-be_array::gen_server_skeletons (void)
-{
-  return 0;
-}
-
-int
-be_array::gen_server_inline (void)
-{
-  // nothing to be done
-  return 0;
-}
-#endif
-
 
 // generate the var defn
 int
@@ -1184,8 +741,10 @@ be_array::gen_forany_defn (void)
   *ch << this->local_name () << "_slice *_retn (void);" << nl;
 
   // generate an additional member function that returns the underlying pointer
-  *ch << this->local_name () << "_slice *ptr (void) const;\n";
+  *ch << this->local_name () << "_slice *ptr (void) const;" << nl;
 
+  // additional member function that returns the NOCOPY flag
+  *ch << "CORBA::Boolean nocopy (void) const;\n";
   *ch << "\n";
   ch->decr_indent ();
 
@@ -1263,10 +822,8 @@ be_array::gen_forany_impl (void)
   ci->indent ();
   *ci << "ACE_INLINE" << nl;
   *ci << fname << "::~" << lname << " (void) // destructor" << nl;
-  *ci << "{\n";
-  ci->incr_indent ();
-  *ci << this->name () << "_free (this->ptr_);\n";
-  ci->decr_indent ();
+  *ci << "{" << nl;
+  *ci << "   // don't do anything" << nl;
   *ci << "}\n\n";
 
   // assignment operator
@@ -1397,23 +954,35 @@ be_array::gen_forany_impl (void)
   ci->decr_indent ();
   *ci << "}\n\n";
 
+  // the additional nocopy member function
+  ci->indent ();
+  *ci << "ACE_INLINE CORBA::Boolean" << nl;
+  *ci << fname << "::nocopy (void) const" << nl;
+  *ci << "{\n";
+  ci->incr_indent ();
+  *ci << "return this->nocopy_;\n";
+  ci->decr_indent ();
+  *ci << "}\n\n";
+
   return 0;
 }
 
 int
 be_array::gen_typecode (void)
 {
-  TAO_OutStream *cs; // output stream
-  TAO_NL  nl;        // end line
-  TAO_CodeGen *cg = TAO_CODEGEN::instance ();
+  TAO_OutStream *os; // output stream
 
-  cs = cg->client_stubs ();
-  cs->indent (); // start from whatever indentation level we were at
+  os = tao_cg->client_stubs ();
+  os->indent (); // start from whatever indentation level we were at
 
-  *cs << "CORBA::tk_array, // typecode kind" << nl;
-  *cs << this->tc_size () << ", // encapsulation length\n";
+  *os << "CORBA::tk_array, // typecode kind" << be_nl;
+  *os << this->tc_encap_len () << ", // encapsulation length" << be_idt << "\n";
   // now emit the encapsulation
-  return this->gen_encapsulation ();
+  if (this->gen_encapsulation () == -1)
+    {
+    }
+  //  *os << (this->dims () [0]) << "," << be_nl;
+  return 0;
 }
 
 // generate encapsulation
@@ -1426,28 +995,48 @@ int
 be_array::gen_encapsulation (void)
 {
   TAO_OutStream *os; // output stream
-  TAO_NL  nl;        // end line
-  TAO_CodeGen *cg = TAO_CODEGEN::instance ();
   be_type *bt; // base type
+  unsigned long i;
 
-  os = cg->client_stubs ();
+  os = tao_cg->client_stubs ();
   os->indent (); // start from the current indentation level
 
-  // XXXASG - byte order must be based on what m/c we are generating code -
-  // TODO
-  *os << "TAO_ENCAP_BYTE_ORDER, // byte order" << nl;
-
-  // emit typecode of element type
+  // retrieve the base type
   bt = be_type::narrow_from_decl (this->base_type ());
-  if (!bt || (bt->gen_typecode () == -1))
+  if (!bt)
     {
-      ACE_ERROR ((LM_ERROR, "be_sequence::gen_typecode - bad base type\n"));
-      return -1;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_array::gen_encapsulation - "
+                         "bad base type\n"),
+                        -1);
     }
 
-  //  emit the length
+  for (i=0; i < (this->n_dims () - 1); i++)
+    {
+      unsigned long rem_encap_len;
+
+      *os << "TAO_ENCAP_BYTE_ORDER, // byte order" << be_nl;
+      *os << "CORBA::tk_array, // typecode kind" << be_nl;
+      rem_encap_len
+        = (this->n_dims () - (i+1))*(4+4)
+        + (this->n_dims () - (i+2))*(4+4)
+        + bt->tc_size ();
+      *os << rem_encap_len << ", // encapsulation length" << be_idt_nl;
+    }
+  *os << "TAO_ENCAP_BYTE_ORDER, // byte order\n";
+  if (bt->gen_typecode () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_array::gen_encapsulation - "
+                         "base type tyepcode gen failed\n"),
+                        -1);
+    }
   os->indent ();
-  //  *os << this->max_size () << ",\n";
+  for (i = (this->n_dims ()-1); i > 0; i--)
+    {
+      *os << this->dims ()[i] << "," << be_uidt_nl;
+    }
+  *os << this->dims ()[0] << be_uidt << ",\n";
   return 0;
 }
 
@@ -1456,19 +1045,23 @@ long
 be_array::tc_size (void)
 {
   // 4 bytes for enumeration, 4 bytes for storing encap length val, followed by the
-  // actual encapsulation length
+  // actual encapsulation
   return 4 + 4 + this->tc_encap_len ();
 }
 
 long
 be_array::tc_encap_len (void)
 {
+  // Suppose "N" is the number of dimensions, then for a N dimensional array,
+  // we will have N encapsulations. The innermost encapsulation will hold the
+  // typecode of the real base type.
+  // Thus, we will have N byte order flags and dimensions, and N-1 tk_array
+  // enumerations, encapsulation lengths, and dimensions.
+
   if (this->encap_len_ == -1) // not computed yet
     {
       be_type *bt; // base type
 
-      this->encap_len_ = 4;  // holds the byte order flag
-      // add the encapsulation length of our base type
       bt = be_type::narrow_from_decl (this->base_type ());
       if (!bt)
         {
@@ -1476,9 +1069,11 @@ be_array::tc_encap_len (void)
                       "be_array::tc_encap_len - bad base type\n"));
           return 0;
         }
+      this->encap_len_ =
+        this->n_dims () * (4+4) // N byte order flags and dims
+        + (this->n_dims ()-1)* (4+4); // N-1 of Enum and encap lengths
+      // to this you add the typecode size of the underlying type
       this->encap_len_ += bt->tc_size ();
-      this->encap_len_ += 4; // to hold the array size
-
     }
   return this->encap_len_;
 }
diff --git a/TAO/TAO_IDL/be/be_interpretive.cpp b/TAO/TAO_IDL/be/be_interpretive.cpp
index 346c4b5e039..4cfa72d80b5 100644
--- a/TAO/TAO_IDL/be/be_interpretive.cpp
+++ b/TAO/TAO_IDL/be/be_interpretive.cpp
@@ -26,6 +26,7 @@
 #include "be_interpretive.h"
 
 #include "be_visitor_args.h"
+#include "be_visitor_array.h"
 #include "be_visitor_attribute.h"
 #include "be_visitor_constant.h"
 #include "be_visitor_enum.h"
@@ -328,6 +329,17 @@ TAO_Interpretive_Visitor_Factory::make_visitor (be_visitor_context *ctx)
     case TAO_CodeGen::TAO_EXCEPTION_ANY_OP_CS:
       return new be_visitor_exception_any_op_cs (new_ctx);
 
+    case TAO_CodeGen::TAO_ARRAY_CH:
+      return new be_visitor_array_ch (new_ctx);
+    case TAO_CodeGen::TAO_ARRAY_CI:
+      return new be_visitor_array_ci (new_ctx);
+    case TAO_CodeGen::TAO_ARRAY_CS:
+      return new be_visitor_array_cs (new_ctx);
+    case TAO_CodeGen::TAO_ARRAY_ANY_OP_CH:
+      return new be_visitor_array_any_op_ch (new_ctx);
+    case TAO_CodeGen::TAO_ARRAY_ANY_OP_CS:
+      return new be_visitor_array_any_op_cs (new_ctx);
+
     case TAO_CodeGen::TAO_OPERATION_RESULT_SS:
     case TAO_CodeGen::TAO_ARGUMENT_CH:
     case TAO_CodeGen::TAO_ARGUMENT_CS:
diff --git a/TAO/TAO_IDL/be/be_visitor_array.cpp b/TAO/TAO_IDL/be/be_visitor_array.cpp
new file mode 100644
index 00000000000..0f92cd40b52
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_visitor_array.cpp
@@ -0,0 +1,537 @@
+//
+// $Id$
+//
+
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    be_visitor_array.cpp
+//
+// = DESCRIPTION
+//    Visitors for generation of code for Array
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+#include "be_visitor_array.h"
+
+// ************************************************************************
+//  visitor for array declaration in client header
+// ************************************************************************
+
+be_visitor_array_ch::be_visitor_array_ch (be_visitor_context *ctx)
+  : be_visitor_decl (ctx)
+{
+}
+
+be_visitor_array_ch::~be_visitor_array_ch (void)
+{
+}
+
+int be_visitor_array_ch::visit_array (be_array *node)
+{
+  TAO_OutStream *os = this->ctx_->stream (); // get output stream
+  be_type *bt;  // base type
+  be_decl *scope = this->ctx_->scope (); // scope in which it is used
+
+  // nothing to do if we are imported or code is already generated
+  if (node->imported () || (node->cli_hdr_gen ()))
+    return 0;
+
+  this->ctx_->node (node); // save the array node
+
+  // retrieve the type
+  bt = be_type::narrow_from_decl (node->base_type ());
+  if (!bt)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ch::"
+                         "visit_array - "
+                         "Bad base type\n"),
+                        -1);
+    }
+
+  // generate the ifdefined macro
+  os->gen_ifdef_macro (node->flatname ());
+
+  os->indent ();
+  if (this->ctx_->tdef ())
+    {
+      // this is a typedef to an array node
+      *os << "typedef " << bt->nested_type_name (scope) << " "
+          << node->local_name ();
+      if (node->gen_dimensions (os) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "be_visitor_array_ch::"
+                             "visit_array - "
+                             "gen dimensions failed\n"),
+                            -1);
+        }
+      *os << ";" << be_nl;
+      *os << "typedef " << bt->nested_type_name (scope) << " "
+          << node->local_name () << "_slice";
+      if (node->gen_dimensions (os, 1) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "be_visitor_array_ch::"
+                             "visit_array - "
+                             "gen slice dimensions failed\n"),
+                            -1);
+        }
+      *os << ";" << be_nl;
+    }
+  else
+    {
+    }
+  // typedef the _var, _out, and _forany types
+  if (node->gen_var_defn () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ch::"
+                         "visit_argument - "
+                         "var_defn failed\n"),
+                        -1);
+    }
+  if (node->gen_out_defn () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ch::"
+                         "visit_argument - "
+                         "out_defn failed\n"),
+                        -1);
+    }
+  if (node->gen_forany_defn () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ch::"
+                         "visit_argument - "
+                         "forany_defn failed\n"),
+                        -1);
+    }
+  // the _alloc, _dup, copy, and free methods. If the node is nested, the
+  // methods become static
+  *os << "static " << node->nested_type_name (scope, "_slice") << " *"
+      << node->nested_type_name (scope, "_alloc") << " (void);" << be_nl;
+  *os << "static " << node->nested_type_name (scope, "_slice") << " *"
+      << node->nested_type_name (scope, "_dup") << " (const "
+      << node->nested_type_name (scope, "_slice") << " *_tao_slice);" << be_nl;
+  *os << "static void " << node->nested_type_name (scope, "_copy") << " ("
+      << node->nested_type_name (scope, "_slice") << " *_tao_to, const "
+      << node->nested_type_name (scope, "_slice") << " *_tao_from);" << be_nl;
+  *os << "static void " << node->nested_type_name (scope, "_free") << " ("
+      << node->nested_type_name (scope, "_slice") << " *_tao_slice);" << be_nl;
+
+  // is this a typedefined array? if so, then let the typedef deal with
+  // generation of the typecode
+  if (!this->ctx_->tdef ())
+    {
+      // 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_context ctx = *this->ctx_;
+      ctx.state (TAO_CodeGen::TAO_TYPECODE_DECL);
+      be_visitor *visitor = tao_cg->make_visitor (&ctx);
+      if (!visitor || (node->accept (visitor) == -1))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_array_ch::"
+                             "visit_array - "
+                             "TypeCode declaration failed\n"
+                             ), -1);
+        }
+      delete visitor;
+    }
+
+  // generate the endif macro
+  os->gen_endif ();
+
+  node->cli_hdr_gen (1);
+  return 0;
+}
+
+// ************************************************************************
+//  visitor for array declaration in client inline
+// ************************************************************************
+
+be_visitor_array_ci::be_visitor_array_ci (be_visitor_context *ctx)
+  : be_visitor_decl (ctx)
+{
+}
+
+be_visitor_array_ci::~be_visitor_array_ci (void)
+{
+}
+
+int be_visitor_array_ci::visit_array (be_array *node)
+{
+  TAO_OutStream *os = this->ctx_->stream (); // get output stream
+  be_type *bt;  // base type
+  be_decl *scope = this->ctx_->scope (); // scope in which it is used
+
+  // nothing to do if we are imported or code is already generated
+  if (node->imported () || (node->cli_inline_gen ()))
+    return 0;
+
+  this->ctx_->node (node); // save the array node
+
+  // retrieve the type
+  bt = be_type::narrow_from_decl (node->base_type ());
+  if (!bt)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ci::"
+                         "visit_array - "
+                         "Bad base type\n"),
+                        -1);
+    }
+
+  // alloc method
+  os->indent (); // start from current indentation
+  *os << "ACE_INLINE " << node->name () << "_slice *" << be_nl;
+  *os << node->name () << "_alloc (void)" << be_nl;
+  *os << "{" << be_idt_nl;
+  *os << "return new " << bt->name ();
+  if (node->gen_dimensions (os) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_array::"
+                         "gen_client_inline - "
+                         "dimensions codegen failed\n"),
+                        -1);
+    }
+
+  *os << ";" << be_uidt_nl;
+  *os << "}\n\n";
+
+  // free method
+  os->indent ();
+  *os << "ACE_INLINE void" << be_nl
+      << node->name () << "_free (" << node->name ()
+      << "_slice *_tao_slice)" << be_nl;
+  *os << "{" << be_idt_nl;
+  *os << "delete [] _tao_slice;" << be_uidt_nl;
+  *os << "}\n\n";
+
+  // generate code for the _var, _out, and _forany types
+  if (node->gen_var_impl () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ci::"
+                         "visit_array - "
+                         "var_defn failed\n"),
+                        -1);
+    }
+  if (node->gen_out_impl () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ci::"
+                         "visit_array - "
+                         "out_defn failed\n"),
+                        -1);
+    }
+  if (node->gen_forany_impl () == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ci::"
+                         "visit_array - "
+                         "forany_defn failed\n"),
+                        -1);
+    }
+
+  // is this a typedefined array? if so, then let the typedef deal with
+  // generation of the typecode
+  if (!this->ctx_->tdef ())
+    {
+      // 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_context ctx = *this->ctx_;
+      ctx.state (TAO_CodeGen::TAO_TYPECODE_DEFN);
+      be_visitor *visitor = tao_cg->make_visitor (&ctx);
+      if (!visitor || (node->accept (visitor) == -1))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_array_cs::"
+                             "visit_array - "
+                             "TypeCode definition failed\n"
+                             ), -1);
+        }
+      delete visitor;
+    }
+
+  node->cli_inline_gen (1);
+  return 0;
+}
+
+// ************************************************************************
+//  visitor for array declaration in client stubs
+// ************************************************************************
+
+be_visitor_array_cs::be_visitor_array_cs (be_visitor_context *ctx)
+  : be_visitor_decl (ctx)
+{
+}
+
+be_visitor_array_cs::~be_visitor_array_cs (void)
+{
+}
+
+int be_visitor_array_cs::visit_array (be_array *node)
+{
+  TAO_OutStream *os = this->ctx_->stream (); // get output stream
+  be_type *bt;  // base type
+  be_decl *scope = this->ctx_->scope (); // scope in which it is used
+  unsigned long i;
+
+  // nothing to do if we are imported or code is already generated
+  if (node->imported () || (node->cli_stub_gen ()))
+    return 0;
+
+  this->ctx_->node (node); // save the array node
+
+  // retrieve the type
+  bt = be_type::narrow_from_decl (node->base_type ());
+  if (!bt)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_visitor_array_ci::"
+                         "visit_array - "
+                         "Bad base type\n"),
+                        -1);
+    }
+
+  // dup method
+  os->indent ();
+  *os << node->name () << "_slice *" << be_nl
+      << node->name () << "_dup (const " << node->name ()
+      << "_slice *_tao_src_array)" << be_nl;
+  *os << "{" << be_idt_nl;
+  *os << node->name () << "_slice *_tao_dup_array = " << node->name ()
+      << "_alloc ();" << be_nl;
+  *os << "if (!_tao_dup_array) return (" << node->name ()
+      << "_slice *)0;" << be_nl;
+  *os << node->name () << "_copy (_tao_dup_array, _tao_src_array);" << be_nl;
+  *os << "return _tao_dup_array;" << be_uidt_nl;
+  *os << "}\n\n";
+
+  // copy method
+  *os << "void " << be_nl;
+  *os << node->name () << "_copy (" << node->name () << "_slice * _tao_to, "
+      << "const " << node->name () << "_slice *_tao_from)" << be_nl;
+  *os << "{" << be_idt_nl;
+  *os << "// copy each individual elements" << be_nl;
+
+  // generate nested loops for as many dimensions as there are
+  for (i = 0; i < node->n_dims (); i++)
+    {
+      // retrieve the ith dimension value
+      AST_Expression *expr = node->dims ()[i];
+      // dimension value
+      if ((expr == NULL) || ((expr != NULL) && (expr->ev () == NULL)))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_array_cs::"
+                             "visit_array - "
+                             "bad array dimension\n"),
+                            -1);
+        }
+      if (expr->ev ()->et == AST_Expression::EV_ulong)
+        {
+          // generate a loop for each dimension
+          *os << "for (CORBA::ULong i" << i << " = 0; i" << i << " < "
+              << expr->ev ()->u.ulval << "; i" << i << "++)" << be_idt_nl;
+        }
+      else
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "(%N:%l) be_visitor_array_cs::"
+                             "visit_array - "
+                             "bad array dimension value\n"),
+                            -1);
+        }
+    }
+
+  // now generate code such that every element of the array gets assigned
+  // inside the innermost level of the  nested loops generated above
+  be_array *primitive_type = 0;
+  if (bt->node_type () == AST_Decl::NT_typedef)
+    {
+      // base type of the array node is a typedef. We need to make sure that
+      // this typedef is not to another array type. If it is, then we cannot
+      // assign an array to another. We will have to invoke the underlying
+      // array type's copy method for every array dimension.
+      be_typedef *tdef = be_typedef::narrow_from_decl (bt);
+      // check if the base type of the typedef node is an Array node
+      primitive_type = be_array::narrow_from_decl (tdef->base_type ());
+    }
+  if (primitive_type)
+    {
+      // the base type is not a typedef to a possibly another array type. In
+      // such a case, assign each element.
+
+      *os << "// call the underlying _copy" << be_nl;
+      *os << bt->name () << "_copy (_tao_to";
+      for (i = 0; i < node->n_dims (); i++)
+        {
+          *os << "[i" << i << "]";
+        }
+      *os << ", ";
+      *os << "_tao_from";  // generate the rvalue
+      for (i = 0; i < node->n_dims (); i++)
+        {
+          *os << "[i" << i << "]";
+        }
+      *os << ");";
+    }
+  else
+    {
+      // the base type is not a typedef to a possibly another array type. In
+      // such a case, assign each element.
+
+      *os << "_tao_to"; // generate the lvalue
+      for (i = 0; i < node->n_dims (); i++)
+        {
+          *os << "[i" << i << "]";
+        }
+      *os << " = ";
+      *os << "_tao_from";  // generate the rvalue
+      for (i = 0; i < node->n_dims (); i++)
+        {
+          *os << "[i" << i << "]";
+        }
+      *os << ";";
+    }
+  for (i = 0; i < node->n_dims (); i++)
+    {
+      // decrement indentation as many times as the number of dimensions
+      *os << be_uidt;
+    }
+  *os << be_uidt_nl << "}\n\n";
+
+  node->cli_stub_gen (1);
+
+  return 0;
+}
+
+// ***************************************************************************
+// Array visitor for generating Any operator declarations in the client header
+// ***************************************************************************
+
+be_visitor_array_any_op_ch::be_visitor_array_any_op_ch
+(be_visitor_context *ctx)
+  : be_visitor_decl (ctx)
+{
+}
+
+be_visitor_array_any_op_ch::~be_visitor_array_any_op_ch (void)
+{
+}
+
+int
+be_visitor_array_any_op_ch::visit_array (be_array *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 << "void " << idl_global->export_macro ()
+      << " operator<<= (CORBA::Any &, const " << node->name ()
+      << "_forany &);" << be_nl;
+  *os << "CORBA::Boolean " << idl_global->export_macro ()
+      << " operator>>= (const CORBA::Any &, "
+      << node->name () << "_forany &);\n";
+
+  node->cli_hdr_any_op_gen (1);
+  return 0;
+}
+
+// ***************************************************************************
+// Array visitor for generating Any operator declarations in the client
+// stubs file
+// ***************************************************************************
+
+be_visitor_array_any_op_cs::be_visitor_array_any_op_cs
+(be_visitor_context *ctx)
+  : be_visitor_decl (ctx)
+{
+}
+
+be_visitor_array_any_op_cs::~be_visitor_array_any_op_cs (void)
+{
+}
+
+int
+be_visitor_array_any_op_cs::visit_array (be_array *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, const "
+      << node->name () << "_forany &_tao_elem)" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::Environment _tao_env;" << be_nl
+      << "if (_tao_elem.nocopy ()) // no copy" << be_idt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", "
+      << "_tao_elem.ptr (), 1, _tao_env); // consume it" << be_uidt_nl
+      << "else // copy" << be_idt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", " << node->name ()
+      << "_dup (_tao_elem.ptr ()), 1, _tao_env);" << be_uidt_nl
+      << be_uidt_nl << "}" << be_nl;
+
+  *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
+      << node->name () << "_forany &_tao_elem)" << be_nl
+      << "{" << be_idt_nl
+      << "CORBA::Environment _tao_env;" << be_nl
+      << "if (!_tao_any.type ()->equal (" << node->tc_name ()
+      << ", _tao_env)) return 0; // not equal" << be_nl
+      << "if (_tao_any.any_owns_data ())" << be_nl
+      << "{" << be_idt_nl
+      << node->name () << "_slice *&_tao_elem_ptr = _tao_elem.out ();" << be_nl
+      << "_tao_elem_ptr = " << node->name () << "_alloc ();" << be_nl
+      << "if (!_tao_elem_ptr) return 0;" << be_nl
+      << "TAO_InputCDR stream ((ACE_Message_Block *)_tao_any.value ());"
+      << be_nl
+      << "if (stream.decode (" << node->tc_name ()
+      << ", _tao_elem_ptr, 0, _tao_env)" << be_nl
+      << "  == CORBA::TypeCode::TRAVERSE_CONTINUE)" << be_nl
+      << "{" << be_idt_nl
+      << "((CORBA::Any *)&_tao_any)->replace (_tao_any.type (), "
+      << "_tao_elem_ptr, 1, _tao_env);"
+      << be_nl
+      << "  return 1;" << be_uidt_nl
+      << "}" << be_nl
+      << "else" << be_nl  // decode failed
+      << "{" << be_idt_nl
+      << node->name () << "_free (_tao_elem_ptr);" << be_nl
+      << "return 0;" << be_uidt_nl
+      << "}" << be_uidt_nl
+      << "}" << be_nl
+      << "else" << be_nl  // else Any does not own the data
+      << "{" << be_idt_nl
+      << "_tao_elem = (" << node->name () << "_slice *)_tao_any.value ();"
+      << be_nl
+      << "return 1;" << be_uidt_nl
+      << "}" << be_uidt_nl
+      << "}\n\n";
+
+  node->cli_stub_any_op_gen (1);
+  return 0;
+}
diff --git a/TAO/TAO_IDL/be/be_visitor_enum.cpp b/TAO/TAO_IDL/be/be_visitor_enum.cpp
index a9ea5665410..162475bfc2c 100644
--- a/TAO/TAO_IDL/be/be_visitor_enum.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_enum.cpp
@@ -216,8 +216,8 @@ be_visitor_enum_any_op_cs::visit_enum (be_enum *node)
       << node->name () << " _tao_elem)" << be_nl
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
-      << "_tao_any.replace (" << node->tc_name () << ", &"
-      << "_tao_elem, 1, _tao_env);" << be_uidt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", new "
+      << node->name () << "(_tao_elem), 1, _tao_env);" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
diff --git a/TAO/TAO_IDL/be/be_visitor_exception.cpp b/TAO/TAO_IDL/be/be_visitor_exception.cpp
index dc9bd2458cd..338cf3cc375 100644
--- a/TAO/TAO_IDL/be/be_visitor_exception.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_exception.cpp
@@ -1090,8 +1090,8 @@ be_visitor_exception_any_op_cs::visit_exception (be_exception *node)
       << node->name () << " &_tao_elem) // copying" << be_nl
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
-      << "_tao_any.replace (" << node->tc_name () << ", &"
-      << "_tao_elem, 1, _tao_env);" << be_uidt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", new "
+      << node->name () << "(_tao_elem), 1, _tao_env);" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "void operator<<= (CORBA::Any &_tao_any, "
@@ -1099,7 +1099,7 @@ be_visitor_exception_any_op_cs::visit_exception (be_exception *node)
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
       << "_tao_any.replace (" << node->tc_name () << ", "
-      << "_tao_elem, 0, _tao_env);" << be_uidt_nl
+      << "_tao_elem, 1, _tao_env); // consume it" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
diff --git a/TAO/TAO_IDL/be/be_visitor_interface.cpp b/TAO/TAO_IDL/be/be_visitor_interface.cpp
index a70e554e0d2..c1bc39dee31 100644
--- a/TAO/TAO_IDL/be/be_visitor_interface.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_interface.cpp
@@ -1966,7 +1966,7 @@ be_visitor_interface_any_op_cs::visit_interface (be_interface *node)
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
       << "_tao_any.replace (" << node->tc_name () << ", "
-      << "_tao_elem, 0, _tao_env);" << be_uidt_nl
+      << "_tao_elem, 1, _tao_env); // consume it" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
@@ -2111,7 +2111,7 @@ be_visitor_interface_tie_sh::visit_interface (be_interface *node)
 
   *os << be_uidt << "private:" << be_idt_nl
       << "T *ptr_;" << be_nl
-      << "PortableServer::POA_ptr poa_;" << 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
@@ -2255,11 +2255,18 @@ be_visitor_interface_tie_si::visit_interface (be_interface *node)
       << "PortableServer::POA_ptr" << be_nl
       << fulltiename << "<T>::_default_POA (CORBA::Environment &env)" << be_nl
       << "{" << be_idt_nl
-      << "if (!CORBA::is_nil (this->poa_))" << be_idt_nl
-      << "return this->poa_;" << be_uidt_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 TAO_ORB_Core_instance ()->root_poa ();"
-      << be_uidt << be_uidt_nl
+      << "return result._retn ();" << be_uidt << be_uidt_nl
+      << "}" << be_uidt
       << "}\n\n";
 
   // generate code for the operations in the scope
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence.cpp b/TAO/TAO_IDL/be/be_visitor_sequence.cpp
index dd13ee27f05..466d3959f85 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence.cpp
@@ -112,9 +112,6 @@ int be_visitor_sequence_ch::visit_sequence (be_sequence *node)
   be_type *bt;       // type node
   TAO_OutStream *os = this->ctx_->stream ();
 
-  if (node->cli_hdr_gen () || node->imported ())
-    return 0;
-
   // first create a name for ourselves
   if (node->create_name (this->ctx_->tdef ()) == -1)
     {
@@ -124,6 +121,9 @@ int be_visitor_sequence_ch::visit_sequence (be_sequence *node)
                          "failed creating name\n"), -1);
     }
 
+  if (node->cli_hdr_gen () || node->imported ())
+    return 0;
+
    // generate the ifdefined macro for the sequence type
   os->gen_ifdef_macro (node->flatname ());
 
diff --git a/TAO/TAO_IDL/be/be_visitor_structure.cpp b/TAO/TAO_IDL/be/be_visitor_structure.cpp
index a988f291b24..3e5261a34c6 100644
--- a/TAO/TAO_IDL/be/be_visitor_structure.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_structure.cpp
@@ -389,8 +389,9 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
       << node->name () << " &_tao_elem) // copying" << be_nl
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
-      << "_tao_any.replace (" << node->tc_name () << ", &"
-      << "_tao_elem, 1, _tao_env);" << be_uidt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", new "
+      << node->name () << "(_tao_elem), 1, _tao_env);" 
+      << " // copy the value" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "void operator<<= (CORBA::Any &_tao_any, "
@@ -398,7 +399,7 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
       << "_tao_any.replace (" << node->tc_name () << ", "
-      << "_tao_elem, 0, _tao_env);" << be_uidt_nl
+      << "_tao_elem, 1, _tao_env); // consume it" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "
diff --git a/TAO/TAO_IDL/be/be_visitor_typedef.cpp b/TAO/TAO_IDL/be/be_visitor_typedef.cpp
index ef0b9ce4478..2c3921daa59 100644
--- a/TAO/TAO_IDL/be/be_visitor_typedef.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_typedef.cpp
@@ -591,14 +591,14 @@ be_visitor_typedef_ch::visit_array (be_array *node)
   be_decl *scope = this->ctx_->scope (); // scope in which it is used
   be_type *bt;
 
-  if (this->ctx_->alias ()) // typedef of a typedef
+  // is the base type an alias to an array node or an actual array node
+  if (this->ctx_->alias ())
     bt = this->ctx_->alias ();
   else
     bt = node;
 
-  if (!bt->imported () &&
-      bt->node_type () == AST_Decl::NT_array) // direct typedef of a base node
-                                              // type
+  // is our base type an array node. If so, generate code for that array node
+  if (bt->node_type () == AST_Decl::NT_array)
     {
       // let the base class visitor handle this case
       if (this->be_visitor_typedef::visit_array (node) == -1)
@@ -610,30 +610,36 @@ be_visitor_typedef_ch::visit_array (be_array *node)
                              ),  -1);
         }
     }
+  else
+    {
+      // base type is simply an alias to an array node. Simply output the
+      // required typedefs
 
-  // now generate the typedefs
-  os->indent ();
-  // typedef the type and the _slice type
-  *os << "typedef " << bt->nested_type_name (scope)
-      << " " << tdef->nested_type_name (scope) << ";" << be_nl;
-  *os << "typedef " << bt->nested_type_name (scope, "_slice")
-      << " " << tdef->nested_type_name (scope, "_slice") << ";" << be_nl;
-  // typedef the _var, _out, and _forany types
-  *os << "typedef " << bt->nested_type_name (scope, "_var")
-      << " " << tdef->nested_type_name (scope, "_var") << ";" << be_nl;
-  *os << "typedef " << bt->nested_type_name (scope, "_out")
-      << " " << tdef->nested_type_name (scope, "_out") << ";" << be_nl;
-  *os << "typedef " << bt->nested_type_name (scope, "_forany")
-      << " " << tdef->nested_type_name (scope, "_forany") << ";" << be_nl;
-  // the _alloc, _dup, and free methods
-  *os << tdef->nested_type_name (scope, "_slice") << " *"
-      << tdef->nested_type_name (scope, "_alloc") << " (void);" << be_nl;
-  *os << tdef->nested_type_name (scope, "_slice") << " *"
-      << tdef->nested_type_name (scope, "_dup") << " ("
-      << tdef->nested_type_name (scope, "_slice") << " *slice);" << be_nl;
-  *os << tdef->nested_type_name (scope, "_slice") << " *"
-      << tdef->nested_type_name (scope, "_free") << " ("
-      << tdef->nested_type_name (scope, "_slice") << " *slice);" << be_nl;
+      os->indent ();
+      // typedef the type and the _slice type
+      *os << "typedef " << bt->nested_type_name (scope)
+          << " " << tdef->nested_type_name (scope) << ";" << be_nl;
+      *os << "typedef " << bt->nested_type_name (scope, "_slice")
+          << " " << tdef->nested_type_name (scope, "_slice") << ";" << be_nl;
+      // typedef the _var, _out, and _forany types
+      *os << "typedef " << bt->nested_type_name (scope, "_var")
+          << " " << tdef->nested_type_name (scope, "_var") << ";" << be_nl;
+      *os << "typedef " << bt->nested_type_name (scope, "_out")
+          << " " << tdef->nested_type_name (scope, "_out") << ";" << be_nl;
+      *os << "typedef " << bt->nested_type_name (scope, "_forany")
+          << " " << tdef->nested_type_name (scope, "_forany") << ";" << be_nl;
+      // the _alloc, _dup, copy, and free methods
+      *os << "static " << tdef->nested_type_name (scope, "_slice") << " *"
+          << tdef->nested_type_name (scope, "_alloc") << " (void);" << be_nl;
+      *os << "static " << tdef->nested_type_name (scope, "_slice") << " *"
+          << tdef->nested_type_name (scope, "_dup") << " (const "
+          << tdef->nested_type_name (scope, "_slice") << " *_tao_slice);" << be_nl;
+      *os << "static void " << tdef->nested_type_name (scope, "_copy") << " ("
+          << tdef->nested_type_name (scope, "_slice") << " *_tao_to, const "
+          << tdef->nested_type_name (scope, "_slice") << " *_tao_from);" << be_nl;
+      *os << "static void " << tdef->nested_type_name (scope, "_free") << " ("
+          << tdef->nested_type_name (scope, "_slice") << " *_tao_slice);" << be_nl;
+    }
   return 0;
 }
 
@@ -1012,6 +1018,46 @@ be_visitor_typedef_ci::visit_array (be_array *node)
                              ),  -1);
         }
     }
+  else
+    {
+      // generate the inline code for alloc, dup, copy, and free methods
+
+      // alloc method
+      os->indent ();
+      *os << "ACE_INLINE " << tdef->name () << "_slice *" << be_nl;
+      *os << tdef->name () << "_alloc (void)" << be_nl;
+      *os << "{" << be_idt_nl;
+      *os << "return " << bt->name () << "_alloc ();" << be_uidt_nl;
+      *os << "}\n\n";
+
+      // dup method
+      os->indent ();
+      *os << "ACE_INLINE " << tdef->name () << "_slice *" << be_nl;
+      *os << tdef->name () << "_dup (const " << tdef->name ()
+          << "_slice *_tao_src)" << be_nl;
+      *os << "{" << be_idt_nl;
+      *os << "return " << bt->name () << "_dup (_tao_src);" << be_uidt_nl;
+      *os << "}\n\n";
+
+      // copy method
+      os->indent ();
+      *os << "ACE_INLINE void" << be_nl;
+      *os << tdef->name () << "_copy (" << tdef->name ()
+          << "_slice *_tao_dest, const " << tdef->name ()
+          << "_slice *_tao_src)" << be_nl;
+      *os << "{" << be_idt_nl;
+      *os << bt->name () << "_copy (_tao_dest, _tao_src);" << be_uidt_nl;
+      *os << "}\n\n";
+
+      // free method
+      os->indent ();
+      *os << "ACE_INLINE void" << be_nl;
+      *os << tdef->name () << "_free (" << tdef->name ()
+          << "_slice *_tao_src)" << be_nl;
+      *os << "{" << be_idt_nl;
+      *os << bt->name () << "_free (_tao_src);" << be_uidt_nl;
+      *os << "}\n\n";
+    }
   return 0;
 }
 
diff --git a/TAO/TAO_IDL/be/be_visitor_union.cpp b/TAO/TAO_IDL/be/be_visitor_union.cpp
index 9e7b6e43e08..09ea167c66b 100644
--- a/TAO/TAO_IDL/be/be_visitor_union.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_union.cpp
@@ -948,8 +948,8 @@ be_visitor_union_any_op_cs::visit_union (be_union *node)
       << node->name () << " &_tao_elem) // copying" << be_nl
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
-      << "_tao_any.replace (" << node->tc_name () << ", &"
-      << "_tao_elem, 1, _tao_env);" << be_uidt_nl
+      << "_tao_any.replace (" << node->tc_name () << ", new "
+      << node->name () << "(_tao_elem), 1, _tao_env);" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "void operator<<= (CORBA::Any &_tao_any, "
@@ -957,7 +957,7 @@ be_visitor_union_any_op_cs::visit_union (be_union *node)
       << "{" << be_idt_nl
       << "CORBA::Environment _tao_env;" << be_nl
       << "_tao_any.replace (" << node->tc_name () << ", "
-      << "_tao_elem, 0, _tao_env);" << be_uidt_nl
+      << "_tao_elem, 1, _tao_env); // consume it" << be_uidt_nl
       << "}" << be_nl;
 
   *os << "CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, "