ChangeLogTag: Thu Jun 26 17:13:39 2003 Jeff Parsons <j.parsons@vanderbilt.edu>

19 files changed, 765 insertions, 254 deletions

diff --git a/TAO/ChangeLog_ref b/TAO/ChangeLog_ref
index 22736e14c95..ff778b7a423 100644
--- a/TAO/ChangeLog_ref
+++ b/TAO/ChangeLog_ref
@@ -1,3 +1,46 @@
+Thu Jun 26 17:13:39 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * TAO_IDL/be/be_visitor_array/array_ch.cpp:
+        * TAO_IDL/be/be_visitor_array/array_ci.cpp:
+        * TAO_IDL/be/be_visitor_array/array_cs.cpp:
+        * tao/Array_VarOut_T.cpp:
+        * tao/Array_VarOut_T.h:
+        * tao/Array_VarOut_T.inl:
+
+          Added Array_Traits to Array_VarOut_T.h. Even though
+          only the slice type is used in this traits template,
+          I had to have the array type for a parameter as well,
+          to distinguish among more than one array with the 
+          same element type. So this parameter had to be added
+          to the _var and _out classes, and changed in generated
+          code.
+
+        * TAO_IDL/be_include/be_typedef.h:
+        * TAO_IDL/be/be_typedef.cpp:
+
+          Added overrides for the seen_in_* and used_in_*
+          methods to propagate these flags to the underlying
+          type.
+
+        * TAO_IDL/be/be_visitor_traits.cpp:
+        * TAO_IDL/be_include/be_visitor_traits.h:
+
+          Completed the traits generation methods.
+
+        * tao/BD_String_Argument_T.cpp:
+        * tao/BD_String_Argument_T.h:
+        * tao/Fixed_Array_Argument_T.cpp:
+        * tao/Fixed_Array_Argument_T.h:
+        * tao/Object_Argument_T.h:
+        * tao/Var_Array_Argument_T.cpp:
+        * tao/Var_Array_Argument_T.h:
+
+          Minor changes.
+
+        * tao/corba.h:
+
+          Added the argument helper files to corba.h.
+
 Wed Jun 25 19:01:33 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * TAO_IDL/be_include/be_visitor_traits.h:
diff --git a/TAO/TAO_IDL/be/be_typedef.cpp b/TAO/TAO_IDL/be/be_typedef.cpp
index 3a9a71562bf..982449e51fa 100644
--- a/TAO/TAO_IDL/be/be_typedef.cpp
+++ b/TAO/TAO_IDL/be/be_typedef.cpp
@@ -52,6 +52,27 @@ be_typedef::be_typedef (AST_Type *bt,
 {
 }
 
+void 
+be_typedef::seq_elem_tmplinst (idl_bool val)
+{
+  this->be_type::seq_elem_tmplinst (val);
+  this->primitive_base_type ()->seq_elem_tmplinst (val);
+}
+
+void 
+be_typedef::seen_in_sequence (idl_bool val)
+{
+  this->be_type::seen_in_sequence (val);
+  this->primitive_base_type ()->seen_in_sequence (val);
+}
+
+void 
+be_typedef::seen_in_operation (idl_bool val)
+{
+  this->be_type::seen_in_operation (val);
+  this->primitive_base_type ()->seen_in_operation (val);
+}
+
 // Given a typedef node, traverse the chain of base types until they are no
 // more typedefs, and return that most primitive base type.
 be_type *
diff --git a/TAO/TAO_IDL/be/be_visitor_array/array_ch.cpp b/TAO/TAO_IDL/be/be_visitor_array/array_ch.cpp
index f0bedf7632b..aee5198015c 100644
--- a/TAO/TAO_IDL/be/be_visitor_array/array_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_array/array_ch.cpp
@@ -230,6 +230,7 @@ int be_visitor_array_ch::visit_array (be_array *node)
           *os << be_nl << be_nl
               << "typedef" << be_idt_nl
               << "TAO_VarArray_Var_T<" << be_idt << be_idt_nl
+              << node->local_name () << "," << be_nl
               << node->local_name () << "_slice," << be_nl
               << "tao_" << node->local_name () << "_life" << be_uidt_nl
               << ">" << be_uidt_nl
@@ -238,6 +239,7 @@ int be_visitor_array_ch::visit_array (be_array *node)
           *os << be_nl << be_nl
               << "typedef" << be_idt_nl
               << "TAO_Array_Out_T<" << be_idt << be_idt_nl
+              << node->local_name () << "," << be_nl
               << node->local_name () << "_var," << be_nl
               << node->local_name () << "_slice," << be_nl
               << "tao_" << node->local_name () << "_life" << be_uidt_nl
@@ -249,6 +251,7 @@ int be_visitor_array_ch::visit_array (be_array *node)
           *os << be_nl << be_nl
               << "typedef" << be_idt_nl
               << "TAO_FixedArray_Var_T<" << be_idt << be_idt_nl
+              << node->local_name () << "," << be_nl
               << node->local_name () << "_slice," << be_nl
               << "tao_" << node->local_name () << "_life" << be_uidt_nl
               << ">" << be_uidt_nl
@@ -264,6 +267,7 @@ int be_visitor_array_ch::visit_array (be_array *node)
   *os << be_nl << be_nl
       << "typedef" << be_idt_nl
       << "TAO_Array_Forany_T<" << be_idt << be_idt_nl
+      << anon_p << node->local_name () << "," << be_nl
       << anon_p << node->local_name () << "_slice," << be_nl
       << "tao_" << node->local_name () << "_life" << be_uidt_nl
       << ">" << be_uidt_nl
diff --git a/TAO/TAO_IDL/be/be_visitor_array/array_ci.cpp b/TAO/TAO_IDL/be/be_visitor_array/array_ci.cpp
index 44deb5b26df..a60f13dfb9e 100644
--- a/TAO/TAO_IDL/be/be_visitor_array/array_ci.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_array/array_ci.cpp
@@ -159,6 +159,58 @@ int be_visitor_array_ci::visit_array (be_array *node)
       << "// " << __FILE__ << ":" << __LINE__;
 
   *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "ACE_INLINE" << be_nl
+      << "void" << be_nl
+      << "TAO::Array_Traits<" << node->name () << ", " 
+      << node->name () << "_slice>::tao_free ("
+      << be_idt << be_idt_nl
+      << fname << "_slice * _tao_slice" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << fname << "_free (_tao_slice);" << be_uidt_nl
+      << "}";
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "ACE_INLINE" << be_nl
+      << fname << "_slice *" << be_nl
+      << "TAO::Array_Traits<" << node->name () << ", " 
+      << node->name () << "_slice>::tao_dup ("
+      << be_idt << be_idt_nl
+      << "const " << fname << "_slice * _tao_slice" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << "return " << fname << "_dup (_tao_slice);" << be_uidt_nl
+      << "}";
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "ACE_INLINE" << be_nl
+      << "void" << be_nl
+      << "TAO::Array_Traits<" << node->name () << ", " 
+      << node->name () << "_slice>::tao_copy ("
+      << be_idt << be_idt_nl
+      << fname << "_slice * _tao_to," << be_nl
+      << "const " << fname << "_slice * _tao_from" << be_uidt_nl
+      << ")" << be_uidt_nl
+      << "{" << be_idt_nl
+      << fname << "_copy (_tao_to, _tao_from);" << be_uidt_nl
+      << "}";
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "ACE_INLINE" << be_nl
+      << fname << "_slice *" << be_nl
+      << "TAO::Array_Traits<" << node->name () << ", " 
+      << node->name () << "_slice>::tao_alloc (void)" << be_nl
+      << "{" << be_idt_nl
+      << "return " << fname << "_alloc ();" << be_uidt_nl
+      << "}";
+
+// ===================================================
+
+  *os << be_nl << be_nl
       << "ACE_INLINE" << be_nl
       << "void" << be_nl
       << node->fwd_helper_name () << "_life::tao_free ("
diff --git a/TAO/TAO_IDL/be/be_visitor_array/array_cs.cpp b/TAO/TAO_IDL/be/be_visitor_array/array_cs.cpp
index 4aa659f29d0..3b7e02691f8 100644
--- a/TAO/TAO_IDL/be/be_visitor_array/array_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_array/array_cs.cpp
@@ -122,10 +122,9 @@ int be_visitor_array_cs::visit_array (be_array *node)
       << "}" << be_uidt_nl << be_nl;
   *os << fname << "_copy (_tao_dup_array, _tao_src_array);" << be_nl;
   *os << "return _tao_dup_array;" << be_uidt_nl;
-  *os << "}\n\n";
+  *os << "}" << be_nl << be_nl;
 
   // alloc method.
-  os->indent ();
   *os << fname << "_slice *" << be_nl;
   *os << fname << "_alloc (void)" << be_nl;
   *os << "{" << be_idt_nl;
@@ -152,20 +151,18 @@ int be_visitor_array_cs::visit_array (be_array *node)
 
   *os << ", 0);" << be_nl;
   *os << "return retval;" << be_uidt_nl;
-  *os << "}\n\n";
+  *os << "}" << be_nl << be_nl;
 
   // free method.
-  os->indent ();
   *os << "void" << be_nl
       << fname << "_free (" << be_idt << be_idt_nl
       << fname << "_slice *_tao_slice" << be_uidt_nl
       << ")" << be_uidt_nl;
   *os << "{" << be_idt_nl;
   *os << "delete [] _tao_slice;" << be_uidt_nl;
-  *os << "}\n\n";
+  *os << "}" << be_nl << be_nl;
 
   // copy method.
-  os->indent ();
   *os << "void " << be_nl;
   *os << fname << "_copy (" << be_idt << be_idt_nl
       << fname << "_slice * _tao_to," << be_nl
@@ -377,6 +374,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "template class" << be_idt_nl
               << "TAO_FixedArray_Var_T<" << be_idt << be_idt_nl
+              << fname << "," << be_nl
               << fname << "_slice," << be_nl
               << node->fwd_helper_name () << "_life" << be_uidt_nl
               << ">;" << be_uidt << be_uidt;
@@ -386,6 +384,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "template class" << be_idt_nl
               << "TAO_VarArray_Var_T<" << be_idt << be_idt_nl
+              << fname << "," << be_nl
               << fname << "_slice," << be_nl
               << node->fwd_helper_name () << "_life" << be_uidt_nl
               << ">;" << be_uidt << be_uidt;
@@ -393,6 +392,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "template class" << be_idt_nl
               << "TAO_Array_Out_T<" << be_idt << be_idt_nl
+              << fname << "," << be_nl
               << fname << "_var," << be_nl
               << fname << "_slice," << be_nl
               << node->fwd_helper_name () << "_life" << be_uidt_nl
@@ -402,6 +402,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
       *os << be_nl << be_nl
           << "template class" << be_idt_nl
           << "TAO_Array_Var_Base_T<" << be_idt << be_idt_nl
+          << fname << "," << be_nl
           << fname << "_slice," << be_nl
           << node->fwd_helper_name () << "_life" << be_uidt_nl
           << ">;" << be_uidt << be_uidt;
@@ -410,6 +411,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
   *os << be_nl << be_nl
       << "template class" << be_idt_nl
       << "TAO_Array_Forany_T<" << be_idt << be_idt_nl
+      << fname << "," << be_nl
       << fname << "_slice," << be_nl
       << node->fwd_helper_name () << "_life" << be_uidt_nl
       << ">;" << be_uidt << be_uidt;
@@ -423,6 +425,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "# pragma instantiate \\" << be_idt << be_idt_nl
               << "TAO_FixedArray_Var_T< \\" << be_idt << be_idt_nl
+              << fname << ", \\" << be_nl
               << fname << "_slice, \\" << be_nl
               << node->fwd_helper_name () << "_life \\" << be_uidt_nl
               << ">" << be_uidt << be_uidt << be_uidt;
@@ -432,6 +435,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "# pragma instantiate \\" << be_idt << be_idt_nl
               << "TAO_VarArray_Var_T< \\" << be_idt << be_idt_nl
+              << fname << ", \\" << be_nl
               << fname << "_slice, \\" << be_nl
               << node->fwd_helper_name () << "_life \\" << be_uidt_nl
               << ">" << be_uidt << be_uidt << be_uidt;
@@ -439,6 +443,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
           *os << be_nl << be_nl
               << "# pragma instantiate \\" << be_idt << be_idt_nl
               << "TAO_Array_Out_T< \\" << be_idt << be_idt_nl
+              << fname << ", \\" << be_nl
               << fname << "_var, \\" << be_nl
               << fname << "_slice, \\" << be_nl
               << node->fwd_helper_name () << "_life \\" << be_uidt_nl
@@ -448,6 +453,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
       *os << be_nl << be_nl
           << "# pragma instantiate \\" << be_idt << be_idt_nl
           << "TAO_Array_Var_Base_T< \\" << be_idt << be_idt_nl
+          << fname << ", \\" << be_nl
           << fname << "_slice, \\" << be_nl
           << node->fwd_helper_name () << "_life \\" << be_uidt_nl
           << ">" << be_uidt << be_uidt << be_uidt;
@@ -456,6 +462,7 @@ be_visitor_array_cs::gen_tmplinst (be_array *node,
   *os << be_nl << be_nl
       << "# pragma instantiate \\" << be_idt << be_idt_nl
       << "TAO_Array_Forany_T< \\" << be_idt << be_idt_nl
+      << fname << ", \\" << be_nl
       << fname << "_slice, \\" << be_nl
       << node->fwd_helper_name () << "_life \\" << be_uidt_nl
       << ">" << be_uidt << be_uidt << be_uidt;
diff --git a/TAO/TAO_IDL/be/be_visitor_traits.cpp b/TAO/TAO_IDL/be/be_visitor_traits.cpp
index 7e44beb5c4e..f3dc9b10f79 100644
--- a/TAO/TAO_IDL/be/be_visitor_traits.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_traits.cpp
@@ -24,8 +24,12 @@
 #include "be_eventtype_fwd.h"
 #include "be_array.h"
 #include "be_enum.h"
+#include "be_sequence.h"
+#include "be_string.h"
 #include "be_structure.h"
+#include "be_field.h"
 #include "be_union.h"
+#include "be_union_branch.h"
 #include "be_typedef.h"
 #include "be_helper.h"
 #include "be_extern.h"
@@ -70,7 +74,7 @@ be_visitor_traits::visit_root (be_root *node)
 int
 be_visitor_traits::visit_module (be_module *node)
 {
-  if (!node->imported () && this->visit_scope (node) == -1)
+  if (this->visit_scope (node) == -1)
     {
       ACE_ERROR_RETURN ((LM_ERROR,
                          "(%N:%l) be_visitor_traits::"
@@ -84,7 +88,8 @@ be_visitor_traits::visit_module (be_module *node)
 int
 be_visitor_traits::visit_interface (be_interface *node)
 {
-  if (node->cli_traits_gen ())
+  if (node->cli_traits_gen ()
+      || (node->imported () && !node->seen_in_operation ()))
     {
       return 0;
     }
@@ -94,8 +99,6 @@ be_visitor_traits::visit_interface (be_interface *node)
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__;
 
-  os->gen_ifdef_macro (node->flat_name (), "traits");
-
   // Since the three blocks below generate specialized (i.e., non-template)
   // classes, we don't want to generate them unless it's necessary - thus
   // the logic surrounding each one.
@@ -124,25 +127,27 @@ be_visitor_traits::visit_interface (be_interface *node)
           << "};";
     }
 
-  // This should be generated even for imported nodes. The ifdef guard
-  // around these and the one above will protect against double declaration.
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
   if (node->seen_in_operation ())
     {
+      os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
       *os << be_nl << be_nl
           << "template<>" << be_nl
           << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
           << node->name () << ">" << be_idt_nl
           << ": public" << be_idt << be_idt_nl
           << "Object_Arg_Traits_T<" << be_idt << be_idt_nl
-          << node->name () << "," << be_nl
+          << node->name () << "_ptr," << be_nl
           << node->name () << "_var," << be_nl
           << node->name () << "_out" << be_uidt_nl
           << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
           << "{" << be_nl
           << "};";
-    }
 
-  os->gen_endif ();
+      os->gen_endif ();
+    }
 
   int status = this->visit_scope (node);
 
@@ -188,7 +193,8 @@ be_visitor_traits::visit_interface_fwd (be_interface_fwd *node)
 int 
 be_visitor_traits::visit_valuetype (be_valuetype *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen ()
+      || (node->imported () && !node->seen_in_operation ()))
     {
       return 0;
     }
@@ -198,15 +204,42 @@ be_visitor_traits::visit_valuetype (be_valuetype *node)
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__;
 
-  *os << be_nl << be_nl
-      << "template<>" << be_nl
-      << "struct " << be_global->stub_export_macro () << " Value_Traits<"
-      << node->name () << ">" << be_nl
-      << "{" << be_idt_nl
-      << "static void tao_add_ref (" << node->name () << " *);" << be_nl
-      << "static void tao_remove_ref (" << node->name () << " *);" 
-      << be_uidt_nl
-      << "};";
+  // This is used by the _var and _out classes, so it should always be
+  // generated in the main file.
+  if (!node->imported ())
+    {
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "struct " << be_global->stub_export_macro () << " Value_Traits<"
+          << node->name () << ">" << be_nl
+          << "{" << be_idt_nl
+          << "static void tao_add_ref (" << node->name () << " *);" << be_nl
+          << "static void tao_remove_ref (" << node->name () << " *);" 
+          << be_uidt_nl
+          << "};";
+    }
+
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
+  if (node->seen_in_operation ())
+    {
+      os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
+          << node->name () << ">" << be_idt_nl
+          << ": public" << be_idt << be_idt_nl
+          << "Object_Arg_Traits_T<" << be_idt << be_idt_nl
+          << node->name () << " *," << be_nl
+          << node->name () << "_var," << be_nl
+          << node->name () << "_out" << be_uidt_nl
+          << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+          << "{" << be_nl
+          << "};";
+
+      os->gen_endif ();
+    }
 
   int status = this->visit_scope (node);
 
@@ -225,38 +258,183 @@ be_visitor_traits::visit_valuetype (be_valuetype *node)
 int 
 be_visitor_traits::visit_valuetype_fwd (be_valuetype_fwd *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen ())
     {
       return 0;
     }
 
+  be_valuetype *fd = 
+    be_valuetype::narrow_from_decl (node->full_definition ());
+
+  // The logic in visit_interface() should handle what gets generated
+  // and what doesn't.
+  int status = this->visit_valuetype (fd);
+
+  if (status != 0)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_valuetype_fwd - code generation failed\n"),
+                        -1);
+    }
+
   node->cli_traits_gen (I_TRUE);
-  be_decl *fd =
-    be_decl::narrow_from_decl (node->full_definition ());
-  fd->cli_traits_gen (I_TRUE);
   return 0;
 }
 
 int 
 be_visitor_traits::visit_eventtype (be_eventtype *node)
 {
-  return 0;
+  return this->visit_valuetype (node);
 }
 
 int 
 be_visitor_traits::visit_eventtype_fwd (be_eventtype_fwd *node)
 {
+  return this->visit_valuetype_fwd (node);
+}
+
+int
+be_visitor_traits::visit_sequence (be_sequence *node)
+{
+  if (node->cli_traits_gen () || !node->seen_in_operation ())
+    {
+      return 0;
+    }
+
+  TAO_OutStream *os = this->ctx_->stream ();
+
+  *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+      << "// " << __FILE__ << ":" << __LINE__;
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "class " << be_global->stub_export_macro () << " Arg_Traits<"
+      << node->name () << ">" << be_idt_nl
+      << ": public" << be_idt << be_idt_nl
+      << "Var_Size_Arg_Traits_T<" << be_idt << be_idt_nl
+      << node->name () << "," << be_nl
+      << node->name () << "_var," << be_nl
+      << node->name () << "_out" << be_uidt_nl
+      << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+      << "{" << be_nl
+      << "};";
+
+  node->cli_traits_gen (I_TRUE);
+  return 0;
+}
+
+int 
+be_visitor_traits::visit_string (be_string *node)
+{
+  if (node->cli_traits_gen () || !node->seen_in_operation ())
+    {
+      return 0;
+    }
+
+  unsigned long bound = node->max_size ()->ev ()->u.ulval;
+  be_typedef *alias = this->ctx_->alias ();
+
+  // Unbounded (w)strings can be handled as a predefined type.
+  // Bounded (w)strings must come in as a typedef - they can't
+  // be used directly as arguments or return types.
+  if (bound == 0 || alias == 0)
+    {
+      return 0;
+    }
+
+  TAO_OutStream *os = this->ctx_->stream ();
+
+  *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+      << "// " << __FILE__ << ":" << __LINE__;
+
+  idl_bool wide = (node->width () != 1);
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "class " << be_global->stub_export_macro () << " Arg_Traits<"
+      << alias->name () << ">" << be_idt_nl
+      << ": public" << be_idt << be_idt_nl
+      << "BD_" << (wide ? "W" : "") 
+      << "String_Arg_Traits<" << bound << ">" 
+      << be_uidt << be_uidt << be_uidt_nl
+      << "{" << be_nl
+      << "};";
+
+  node->cli_traits_gen (I_TRUE);
   return 0;
 }
 
 int 
 be_visitor_traits::visit_array (be_array *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen ()
+      || (node->imported () && !node->seen_in_operation ()))
     {
       return 0;
     }
 
+  TAO_OutStream *os = this->ctx_->stream ();
+
+  *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+      << "// " << __FILE__ << ":" << __LINE__;
+
+  // This is used by the _var and _out classes, so it should always be
+  // generated in the main file.
+  if (!node->imported ())
+    {
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "struct " << be_global->stub_export_macro () << " Array_Traits<"
+          << be_idt << be_idt_nl
+          << node->name () << "," << be_nl
+          << node->name () << "_slice" << be_uidt_nl
+          << ">" << be_uidt_nl
+          << "{" << be_idt_nl
+          << "static " << node->name () << "_slice * tao_alloc (void);" 
+          << be_nl
+          << "static void tao_free (" << node->name () 
+          << "_slice *);" << be_nl
+          << "static " << node->name () << "_slice * tao_dup (const "
+          << node->name () << "_slice *);" << be_nl
+          << "static void tao_copy (" << be_idt << be_idt_nl
+          << node->name () << "_slice * tao_to," << be_nl
+          << "const " << node->name () << "_slice * tao_from" << be_uidt_nl
+          << ");" << be_uidt << be_uidt_nl
+          << "};";
+    }
+
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
+  if (node->seen_in_operation ())
+    {
+      os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
+          << node->name () << ">" << be_idt_nl
+          << ": public" << be_idt << be_idt_nl;
+
+      *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
+          << "_Array_Arg_Traits_T<" << be_idt << be_idt_nl
+          << node->name () << "," << be_nl
+          << node->name () << "_slice," << be_nl
+          << node->name () << "_var," << be_nl;
+
+      if (node->size_type () == AST_Type::VARIABLE)
+        {
+          *os << node->name () << "_out," << be_nl;
+        }
+
+      *os << node->name () << "_forany" << be_uidt_nl
+          << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+          << "{" << be_nl
+          << "};";
+
+      os->gen_endif ();
+    }
+
   node->cli_traits_gen (I_TRUE);
   return 0;
 }
@@ -264,11 +442,34 @@ be_visitor_traits::visit_array (be_array *node)
 int 
 be_visitor_traits::visit_enum (be_enum *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen () || !node->seen_in_operation ())
     {
       return 0;
     }
 
+  TAO_OutStream *os = this->ctx_->stream ();
+
+  *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+      << "// " << __FILE__ << ":" << __LINE__;
+
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
+  os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
+  *os << be_nl << be_nl
+      << "template<>" << be_nl
+      << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
+      << node->name () << ">" << be_idt_nl
+      << ": public" << be_idt << be_idt_nl;
+
+  *os << "Basic_Arg_Traits_T<" << be_idt << be_idt_nl
+      << node->name () << be_uidt_nl
+      << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+      << "{" << be_nl
+      << "};";
+
+  os->gen_endif ();
+
   node->cli_traits_gen (I_TRUE);
   return 0;
 }
@@ -276,11 +477,47 @@ be_visitor_traits::visit_enum (be_enum *node)
 int 
 be_visitor_traits::visit_structure (be_structure *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen ())
     {
       return 0;
     }
 
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
+  if (node->seen_in_operation ())
+    {
+      TAO_OutStream *os = this->ctx_->stream ();
+
+      *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+          << "// " << __FILE__ << ":" << __LINE__;
+
+      os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
+          << node->name () << ">" << be_idt_nl
+          << ": public" << be_idt << be_idt_nl;
+
+      *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
+          << "_Size_Arg_Traits_T<" << be_idt << be_idt_nl
+          << node->name ();
+
+      if (node->size_type () == AST_Type::VARIABLE)
+        {
+          *os << "," << be_nl
+              << node->name () << "_var," << be_nl
+              << node->name () << "_out";
+        }
+
+      *os << be_uidt_nl
+          << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+          << "{" << be_nl
+          << "};";
+
+      os->gen_endif ();
+    }
+
   int status = this->visit_scope (node);
 
   if (status != 0)
@@ -295,14 +532,78 @@ be_visitor_traits::visit_structure (be_structure *node)
   return 0;
 }
 
+int
+be_visitor_traits::visit_field (be_field *node)
+{
+  be_type *bt = be_type::narrow_from_decl (node->field_type ());
+
+  if (!bt)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_field - "
+                         "Bad field type\n"), 
+                        -1);
+    }
+
+  if (bt->accept (this) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_field - "
+                         "codegen for field type failed\n"), 
+                        -1);
+    }
+
+  node->cli_traits_gen (I_TRUE);
+  bt->cli_traits_gen (I_TRUE);
+  return 0;
+}
+
 int 
 be_visitor_traits::visit_union (be_union *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  if (node->cli_traits_gen ())
     {
       return 0;
     }
 
+  // This should be generated even for imported nodes. The ifdef guard prevents
+  // multiple declarations.
+  if (node->seen_in_operation ())
+    {
+      TAO_OutStream *os = this->ctx_->stream ();
+
+      *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
+          << "// " << __FILE__ << ":" << __LINE__;
+
+      os->gen_ifdef_macro (node->flat_name (), "arg_traits");
+
+      *os << be_nl << be_nl
+          << "template<>" << be_nl
+          << "class " << be_global->stub_export_macro () << " Arg_Traits<" 
+          << node->name () << ">" << be_idt_nl
+          << ": public" << be_idt << be_idt_nl;
+
+      *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
+          << "_Size_Arg_Traits_T<" << be_idt << be_idt_nl
+          << node->name ();
+
+      if (node->size_type () == AST_Type::VARIABLE)
+        {
+          *os << "," << be_nl
+              << node->name () << "_var," << be_nl
+              << node->name () << "_out";
+        }
+
+      *os << be_uidt_nl
+          << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
+          << "{" << be_nl
+          << "};";
+
+      os->gen_endif ();
+    }
+
   int status = this->visit_scope (node);
 
   if (status != 0)
@@ -317,14 +618,52 @@ be_visitor_traits::visit_union (be_union *node)
   return 0;
 }
 
+int
+be_visitor_traits::visit_union_branch (be_union_branch *node)
+{
+  be_type *bt = be_type::narrow_from_decl (node->field_type ());
+
+  if (!bt)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_union_branch - "
+                         "Bad union_branch type\n"), 
+                        -1);
+    }
+
+  if (bt->accept (this) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_union_branch - "
+                         "codegen for union_branch type failed\n"), 
+                        -1);
+    }
+
+  node->cli_traits_gen (I_TRUE);
+  bt->cli_traits_gen (I_TRUE);
+  return 0;
+}
+
 int 
 be_visitor_traits::visit_typedef (be_typedef *node)
 {
-  if (node->imported () || node->cli_traits_gen ())
+  this->ctx_->alias (node);
+
+  // Make a decision based on the primitive base type.
+  be_type *bt = node->primitive_base_type ();
+
+  if (!bt || (bt->accept (this) == -1))
     {
-      return 0;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "(%N:%l) be_visitor_traits::"
+                         "visit_typedef - "
+                         "Bad primitive type\n"),
+                        -1);
     }
 
+  this->ctx_->alias (0);
   node->cli_traits_gen (I_TRUE);
   return 0;
 }
diff --git a/TAO/TAO_IDL/be_include/be_typedef.h b/TAO/TAO_IDL/be_include/be_typedef.h
index dd9de21206e..94af3381b5f 100644
--- a/TAO/TAO_IDL/be_include/be_typedef.h
+++ b/TAO/TAO_IDL/be_include/be_typedef.h
@@ -40,6 +40,12 @@ public:
               idl_bool a);
   // Constructor.
 
+  virtual void seq_elem_tmplinst (idl_bool val);
+  virtual void seen_in_sequence (idl_bool val);
+  virtual void seen_in_operation (idl_bool val);
+  // Mutator overrides for be_type members. If we have been
+  // defined, we want the underlying type to be set as well.
+
   be_type *primitive_base_type (void);
   // Return the most primitive base type by traversing the chain of typedefed
   // base types.
diff --git a/TAO/TAO_IDL/be_include/be_visitor_traits.h b/TAO/TAO_IDL/be_include/be_visitor_traits.h
index 9f61c5dd94c..201ea06dc8e 100644
--- a/TAO/TAO_IDL/be_include/be_visitor_traits.h
+++ b/TAO/TAO_IDL/be_include/be_visitor_traits.h
@@ -49,10 +49,18 @@ public:
 
   virtual int visit_eventtype_fwd (be_eventtype_fwd *node);
 
+  virtual int visit_sequence (be_sequence *node);
+
+  virtual int visit_string (be_string *node);
+
   virtual int visit_structure (be_structure *node);
 
+  virtual int visit_field (be_field *node);
+
   virtual int visit_union (be_union *node);
 
+  virtual int visit_union_branch (be_union_branch *node);
+
   virtual int visit_typedef (be_typedef *node);
 };
 
diff --git a/TAO/tao/Array_VarOut_T.cpp b/TAO/tao/Array_VarOut_T.cpp
index b9058fedc07..90841d0d445 100644
--- a/TAO/tao/Array_VarOut_T.cpp
+++ b/TAO/tao/Array_VarOut_T.cpp
@@ -13,33 +13,33 @@ ACE_RCSID (tao,
            Array_VarOut_T, 
            "$Id$")
 
-template<typename T_slice, typename T_life>
-TAO_FixedArray_Var_T<T_slice,T_life> &
-TAO_FixedArray_Var_T<T_slice,T_life>::operator= (T_slice * p)
+template<typename T, typename T_slice, typename T_life>
+TAO_FixedArray_Var_T<T,T_slice,T_life> &
+TAO_FixedArray_Var_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   // Is what we own the same that is being assigned to us?
   if (this->ptr_ != p)
     {
       // Delete our stuff and assume ownership of p.
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       this->ptr_ = p;
     }
   
   return *this;
 }
 
-template<typename T_slice, typename T_life>
-TAO_FixedArray_Var_T<T_slice,T_life> &
-TAO_FixedArray_Var_T<T_slice,T_life>::operator= (
-    const TAO_FixedArray_Var_T<T_slice,T_life> & p
+template<typename T, typename T_slice, typename T_life>
+TAO_FixedArray_Var_T<T,T_slice,T_life> &
+TAO_FixedArray_Var_T<T,T_slice,T_life>::operator= (
+    const TAO_FixedArray_Var_T<T,T_slice,T_life> & p
   )
 {
   if (this != &p)
     {
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       
       // Deep copy.
-      this->ptr_ = T_life::tao_dup (p.in ());
+      this->ptr_ = TAO::Array_Traits<T,T_slice>::tao_dup (p.in ());
     }
   
   return *this;
@@ -47,33 +47,33 @@ TAO_FixedArray_Var_T<T_slice,T_life>::operator= (
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
-TAO_VarArray_Var_T<T_slice,T_life> &
-TAO_VarArray_Var_T<T_slice,T_life>::operator= (T_slice * p)
+template<typename T, typename T_slice, typename T_life>
+TAO_VarArray_Var_T<T,T_slice,T_life> &
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   // Is what we own the same that is being assigned to us?
   if (this->ptr_ != p)
     {
       // Delete our stuff and assume ownership of p.
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       this->ptr_ = p;
     }
   
   return *this;
 }
 
-template<typename T_slice, typename T_life>
-TAO_VarArray_Var_T<T_slice,T_life> &
-TAO_VarArray_Var_T<T_slice,T_life>::operator= (
-    const TAO_VarArray_Var_T<T_slice,T_life> & p
+template<typename T, typename T_slice, typename T_life>
+TAO_VarArray_Var_T<T,T_slice,T_life> &
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator= (
+    const TAO_VarArray_Var_T<T,T_slice,T_life> & p
   )
 {
   if (this != &p)
     {
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       
       // Deep copy.
-      this->ptr_ = T_life::tao_dup (p.in ());
+      this->ptr_ = TAO::Array_Traits<T,T_slice>::tao_dup (p.in ());
     }
   
   return *this;
@@ -81,14 +81,14 @@ TAO_VarArray_Var_T<T_slice,T_life>::operator= (
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 void
-TAO_Array_Forany_T<T_slice,T_life>::_tao_any_destructor (
+TAO_Array_Forany_T<T,T_slice,T_life>::_tao_any_destructor (
     void * _tao_void_pointer
   )
 {
   T_slice * tmp = ACE_static_cast (T_slice *, _tao_void_pointer);
-  T_life::tao_free (tmp);
+  TAO::Array_Traits<T,T_slice>::tao_free (tmp);
 }
 
 #endif /* TAO_ARRAY_VAROUT_T_C */
diff --git a/TAO/tao/Array_VarOut_T.h b/TAO/tao/Array_VarOut_T.h
index 8cc81092e72..89cb2c680e0 100644
--- a/TAO/tao/Array_VarOut_T.h
+++ b/TAO/tao/Array_VarOut_T.h
@@ -20,27 +20,46 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+namespace TAO
+{
+  /**
+   * struct Array_Traits
+   *
+   * @brief Specialized for each array in generated code.
+   *
+   */
+  template<typename T, typename T_slice>
+  struct Array_Traits
+  {
+    static T_slice * tao_alloc (void);
+    static void tao_free (T_slice * _tao_slice);
+    static T_slice * tao_dup (const T_slice * _tao_slice);
+    static void tao_copy (T_slice * _tao_to,
+                          const T_slice * _tao_from);
+  };
+};
+
 /**
  * @class TAO_Array_Var_Base_T
  *
  * @brief Parametrized implementation of _var base class for arrays.
  *
  */
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 class TAO_Array_Var_Base_T
 {
 public:
   TAO_Array_Var_Base_T (void);
   TAO_Array_Var_Base_T (T_slice *);
-  TAO_Array_Var_Base_T (const TAO_Array_Var_Base_T<T_slice,T_life> &);
+  TAO_Array_Var_Base_T (const TAO_Array_Var_Base_T<T,T_slice,T_life> &);
   ~TAO_Array_Var_Base_T (void);
   
   T_slice & operator[] (CORBA::ULong index);
-  const T_slice & operator[] (CORBA::ULong index) const;
+  T_slice const & operator[] (CORBA::ULong index) const;
   operator T_slice * const & () const; 
   
   // in, inout, out, _retn 
-  const T_slice * in (void) const;
+  T_slice * const in (void) const;
   T_slice * inout (void);
   T_slice *& out (void);
   T_slice * _retn (void);
@@ -57,17 +76,17 @@ protected:
  * elements of fixed size.
  *
  */
-template<typename T_slice, typename T_life>
-class TAO_FixedArray_Var_T: public TAO_Array_Var_Base_T<T_slice,T_life>
+template<typename T, typename T_slice, typename T_life>
+class TAO_FixedArray_Var_T: public TAO_Array_Var_Base_T<T,T_slice,T_life>
 {
 public:
   TAO_FixedArray_Var_T (void);
   TAO_FixedArray_Var_T (T_slice *);
-  TAO_FixedArray_Var_T (const TAO_FixedArray_Var_T<T_slice,T_life> &);
+  TAO_FixedArray_Var_T (const TAO_FixedArray_Var_T<T,T_slice,T_life> &);
   
-  TAO_FixedArray_Var_T<T_slice,T_life> &operator= (T_slice *);
-  TAO_FixedArray_Var_T<T_slice,T_life> &operator= (
-      const TAO_FixedArray_Var_T<T_slice,T_life> &
+  TAO_FixedArray_Var_T<T,T_slice,T_life> &operator= (T_slice *);
+  TAO_FixedArray_Var_T<T,T_slice,T_life> &operator= (
+      const TAO_FixedArray_Var_T<T,T_slice,T_life> &
     );
 };
 
@@ -78,17 +97,17 @@ public:
  * elements of variable size.
  *
  */
-template<typename T_slice, typename T_life>
-class TAO_VarArray_Var_T : public TAO_Array_Var_Base_T<T_slice,T_life>
+template<typename T, typename T_slice, typename T_life>
+class TAO_VarArray_Var_T : public TAO_Array_Var_Base_T<T,T_slice,T_life>
 {
 public:
   TAO_VarArray_Var_T (void);
   TAO_VarArray_Var_T (T_slice *);
-  TAO_VarArray_Var_T (const TAO_VarArray_Var_T<T_slice,T_life> &);
+  TAO_VarArray_Var_T (const TAO_VarArray_Var_T<T,T_slice,T_life> &);
   
-  TAO_VarArray_Var_T<T_slice,T_life> &operator= (T_slice *);
-  TAO_VarArray_Var_T<T_slice,T_life> &operator= (
-      const TAO_VarArray_Var_T<T_slice,T_life> &
+  TAO_VarArray_Var_T<T,T_slice,T_life> &operator= (T_slice *);
+  TAO_VarArray_Var_T<T,T_slice,T_life> &operator= (
+      const TAO_VarArray_Var_T<T,T_slice,T_life> &
     );
   
   operator T_slice *& ();
@@ -100,18 +119,18 @@ public:
  * @brief Parametrized implementation of _out class for arrays.
  *
  */
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 class TAO_Array_Out_T
 {
 public:
   TAO_Array_Out_T (T_slice *&);
   TAO_Array_Out_T (T_var &);
-  TAO_Array_Out_T (const TAO_Array_Out_T<T_var,T_slice,T_life> &);
+  TAO_Array_Out_T (const TAO_Array_Out_T<T,T_var,T_slice,T_life> &);
   
-  TAO_Array_Out_T<T_var,T_slice,T_life> &operator= (
-      const TAO_Array_Out_T<T_var,T_slice,T_life> &
+  TAO_Array_Out_T<T,T_var,T_slice,T_life> &operator= (
+      const TAO_Array_Out_T<T,T_var,T_slice,T_life> &
     );
-  TAO_Array_Out_T<T_var,T_slice,T_life> &operator= (T_slice *);
+  TAO_Array_Out_T<T,T_var,T_slice,T_life> &operator= (T_slice *);
   
   operator T_slice *& ();
   T_slice *& ptr (void);
@@ -119,7 +138,7 @@ public:
   T_slice & operator[] (CORBA::ULong index);
   const T_slice & operator[] (CORBA::ULong index) const;
 private:
-  typedef TAO_Array_Out_T<T_var,T_slice,T_life> THIS_OUT_TYPE;
+  typedef TAO_Array_Out_T<T,T_var,T_slice,T_life> THIS_OUT_TYPE;
   T_slice *& ptr_;
   // Assignment from T_var not allowed.
   void operator= (const T_var &);
@@ -131,20 +150,22 @@ private:
  * @brief Parametrized implementation of _forany class for arrays.
  *
  */
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 class TAO_Array_Forany_T
 {
 public:
   TAO_Array_Forany_T (void);
   TAO_Array_Forany_T (T_slice *,
                       CORBA::Boolean nocopy = 0);
-  TAO_Array_Forany_T (const TAO_Array_Forany_T<T_slice,T_life> &);
+  TAO_Array_Forany_T (const TAO_Array_Forany_T<T,T_slice,T_life> &);
   ~TAO_Array_Forany_T (void);
   
   static void _tao_any_destructor (void *);
   
   TAO_Array_Forany_T & operator= (T_slice *);
-  TAO_Array_Forany_T & operator= (const TAO_Array_Forany_T<T_slice,T_life> &);
+  TAO_Array_Forany_T & operator= (
+      const TAO_Array_Forany_T<T,T_slice,T_life> &
+    );
   
   T_slice & operator[] (CORBA::ULong index);
   const T_slice & operator[] (CORBA::ULong index) const;
diff --git a/TAO/tao/Array_VarOut_T.inl b/TAO/tao/Array_VarOut_T.inl
index a7ba28c7e68..a02d97c1ce2 100644
--- a/TAO/tao/Array_VarOut_T.inl
+++ b/TAO/tao/Array_VarOut_T.inl
@@ -1,242 +1,231 @@
 //$Id$
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (void)
   : ptr_ (0)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (T_slice * p)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (T_slice * p)
   : ptr_ (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (
     const TAO_Array_Var_Base_T & p
   )
 {
-  this->ptr_ = T_life::tao_dup (p.in ());
+  this->ptr_ = TAO::Array_Tratis<T,T_slice, T_forany>::tao_dup (p.in ());
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::~TAO_Array_Var_Base_T (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::~TAO_Array_Var_Base_T (void)
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::operator T_slice * const & () const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::operator T_slice * const & () const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-const T_slice &
-TAO_Array_Var_Base_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
+T_slice const &
+TAO_Array_Var_Base_T<T,T_slice,T_life>::operator[] (CORBA::ULong index) const
 {
-#if defined (ACE_HAS_BROKEN_IMPLICIT_CONST_CAST)
-  return ACE_const_cast (
-      const T_slice &,
-      this->ptr_[index]
-    );
-#else
-  const T_slice & tmp = this->ptr_[index];
-  return tmp;
-#endif /* ACE_HAS_BROKEN_IMPLICIT_CONST_CAST */
+  return this->ptr_[index];
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Var_Base_T<T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-const T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::in (void) const
+T_slice * const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::in (void) const
 {
-  // @@@ (JP) This looks scary I know but it helps MSVC understand
-  // things better when the array is multi-dimensional.
-  return ACE_const_cast (const T_slice *,
-                         this->ptr_);
+  return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::inout (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::inout (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Var_Base_T<T_slice,T_life>::out (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::out (void)
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::_retn (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::_retn (void)
 {
   T_slice * tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::ptr (void) const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (void)
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (void)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (T_slice * p)
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (T_slice * p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (
     const TAO_FixedArray_Var_T & p
   )
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (void)
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (void)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (T_slice * p)
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (T_slice * p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (
     const TAO_VarArray_Var_T & p
   )
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::operator T_slice *& ()
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
 // *************************************************************
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (T_slice *& p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (T_slice *& p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (T_var & p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (T_var & p)
   : ptr_ (p.out ())
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
   this->ptr_ = 0;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (
-    const TAO_Array_Out_T<T_var,T_slice,T_life> & p
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (
+    const TAO_Array_Out_T<T,T_var,T_slice,T_life> & p
   )
   : ptr_ (ACE_const_cast (THIS_OUT_TYPE &, p).ptr_)
 {}
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life> &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator= (
-    const TAO_Array_Out_T<T_var,T_slice,T_life> & p
+TAO_Array_Out_T<T,T_var,T_slice,T_life> &
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator= (
+    const TAO_Array_Out_T<T,T_var,T_slice,T_life> & p
   )
 {
   this->ptr_ = ACE_const_cast (THIS_OUT_TYPE &, p).ptr_;
   return *this;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life> &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator= (T_slice *p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life> &
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator= (T_slice *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator T_slice *& ()
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Out_T<T_var,T_slice,T_life>::ptr (void)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::ptr (void)
 {
   return this->ptr_;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (void)
   : ptr_ (0),
     nocopy_ (0)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (
     T_slice * p,
     CORBA::Boolean nocopy
   )
@@ -244,36 +233,36 @@ TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
     nocopy_ (nocopy)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
-    const TAO_Array_Forany_T<T_slice,T_life> & p
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (
+    const TAO_Array_Forany_T<T,T_slice,T_life> & p
   )
 {
   this->ptr_ = p.ptr_;
   this->nocopy_ = p.nocopy_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::~TAO_Array_Forany_T (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::~TAO_Array_Forany_T (void)
 {
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life> &
-TAO_Array_Forany_T<T_slice,T_life>::operator= (T_slice * p)
+TAO_Array_Forany_T<T,T_slice,T_life> &
+TAO_Array_Forany_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life> &
-TAO_Array_Forany_T<T_slice,T_life>::operator= (
-    const TAO_Array_Forany_T<T_slice,T_life> & p
+TAO_Array_Forany_T<T,T_slice,T_life> &
+TAO_Array_Forany_T<T,T_slice,T_life>::operator= (
+    const TAO_Array_Forany_T<T,T_slice,T_life> & p
   )
 {
   this->ptr_ = p.ptr_;
@@ -281,24 +270,24 @@ TAO_Array_Forany_T<T_slice,T_life>::operator= (
   return *this;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::operator T_slice * const & () const
+TAO_Array_Forany_T<T,T_slice,T_life>::operator T_slice * const & () const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::operator T_slice *& ()
+TAO_Array_Forany_T<T,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 const T_slice &
-TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
+TAO_Array_Forany_T<T,T_slice,T_life>::operator[] (CORBA::ULong index) const
 {
 #if defined (ACE_HAS_BROKEN_IMPLICIT_CONST_CAST)
   return ACE_const_cast (
@@ -311,18 +300,18 @@ TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
 #endif /* ACE_HAS_BROKEN_IMPLICIT_CONST_CAST */
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Forany_T<T,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 const T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::in (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::in (void) const
 {
   // @@@ (JP) This looks scary I know but it helps MSVC understand
   // things better when the array is multi-dimensional.
@@ -330,51 +319,51 @@ TAO_Array_Forany_T<T_slice,T_life>::in (void) const
                          this->ptr_);
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::inout (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::inout (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Forany_T<T_slice,T_life>::out (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::out (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::_retn (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::_retn (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::ptr (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::ptr (void) const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 CORBA::Boolean
-TAO_Array_Forany_T<T_slice,T_life>::nocopy (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::nocopy (void) const
 {
   return this->nocopy_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::tao_alloc (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::tao_alloc (void)
 {
-  return T_life::tao_alloc ();
+  return TAO::Array_Traits<T,T_slice>::tao_alloc ();
 }
 
diff --git a/TAO/tao/BD_String_Argument_T.cpp b/TAO/tao/BD_String_Argument_T.cpp
index 8a21ca7c699..4b1ef4d4e37 100644
--- a/TAO/tao/BD_String_Argument_T.cpp
+++ b/TAO/tao/BD_String_Argument_T.cpp
@@ -11,7 +11,7 @@ ACE_RCSID (tao,
 
 template<typename S, typename to_S, typename from_S, size_t BOUND>
 TAO::In_BD_String_Argument_T<S,to_S,from_S,BOUND>::In_BD_String_Argument_T (
-    S * const & x
+    const S * x
   )
   : x_ (x)
 {}
@@ -197,7 +197,11 @@ TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
 In_BD_String_SArgument_T (void)
 {}
 
-template<typename S, typename to_S, typename from_S, size_t BOUND>
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
 CORBA::Boolean
 TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::demarshal (
     TAO_InputCDR & cdr
diff --git a/TAO/tao/BD_String_Argument_T.h b/TAO/tao/BD_String_Argument_T.h
index d5f18f6ae1b..8bf5fe4ff5c 100644
--- a/TAO/tao/BD_String_Argument_T.h
+++ b/TAO/tao/BD_String_Argument_T.h
@@ -15,6 +15,7 @@
 #define TAO_BD_STRING_ARGUMENT_T_H
 
 #include "ace/pre.h"
+#include "ace/CDR_Stream.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -207,7 +208,7 @@ namespace TAO
            typename to_S, 
            typename from_S, 
            size_t BOUND>
-  class Ret_BD_String_SArgument_T : public Skel_Retval
+  class Ret_BD_String_SArgument_T : public Argument
   {
   public:
     Ret_BD_String_SArgument_T (void);
@@ -306,7 +307,7 @@ namespace TAO
                                     CORBA::String_out,
                                     ACE_InputCDR::to_string,
                                     ACE_OutputCDR::from_string,
-                                    size_t BOUND>
+                                    BOUND>
   {
   };
 
@@ -317,7 +318,7 @@ namespace TAO
                                     CORBA::WString_out,
                                     ACE_InputCDR::to_wstring,
                                     ACE_OutputCDR::from_wstring,
-                                    size_t BOUND>
+                                    BOUND>
   {
   };
 };
diff --git a/TAO/tao/Fixed_Array_Argument_T.cpp b/TAO/tao/Fixed_Array_Argument_T.cpp
index b9746a6ca3f..dca96b64fc4 100644
--- a/TAO/tao/Fixed_Array_Argument_T.cpp
+++ b/TAO/tao/Fixed_Array_Argument_T.cpp
@@ -101,19 +101,20 @@ TAO::Out_Fixed_Array_Argument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
 
 // ============================================================
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
 Ret_Fixed_Array_Argument_T (void)
 {
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
   S_slice * tmp = 0;
   ACE_ALLOCATOR (tmp,
-                 S_life::tao_alloc ());
+                 ARRAY_TRAITS::tao_alloc ());
   this->x_ = tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 CORBA::Boolean
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::demarshal (
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::demarshal (
     TAO_InputCDR & cdr
   )
 {
@@ -121,33 +122,33 @@ TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::demarshal (
   return cdr >> tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 void
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
 interceptor_result (CORBA::Any * any)
 {
   (*any) <<= S_forany (this->x_.ptr ());
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 CORBA::Boolean
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
 interceptor_replace (CORBA::Any & any)
 {
   S_forany tmp (this->x_.ptr ());
   return any >>= tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 S_slice *
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::excp (void)
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::excp (void)
 {
   return this->x_.ptr ();
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 S_slice *
-TAO::Ret_Fixed_Array_Argument_T<S_slice,S_var,S_life,S_forany>::retn (void)
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::retn (void)
 {
   return this->x_._retn ();
 }
diff --git a/TAO/tao/Fixed_Array_Argument_T.h b/TAO/tao/Fixed_Array_Argument_T.h
index ab2b3156cf9..35e9031cce4 100644
--- a/TAO/tao/Fixed_Array_Argument_T.h
+++ b/TAO/tao/Fixed_Array_Argument_T.h
@@ -90,9 +90,9 @@ namespace TAO
    * @brief Return stub value of fixed size element array.
    *
    */
-  template<typename S_slice, 
+  template<typename S,
+           typename S_slice, 
            typename S_var, 
-           typename S_life, 
            typename S_forany>
   class Ret_Fixed_Array_Argument_T : public Argument
   {
@@ -218,7 +218,6 @@ namespace TAO
   template<typename T, 
            typename T_slice, 
            typename T_var, 
-           typename T_life,
            typename T_forany>
   struct Fixed_Array_Arg_Traits_T
   {
@@ -232,9 +231,9 @@ namespace TAO
                                       T_forany>         in_arg_val;
     typedef Inout_Fixed_Array_Argument_T<T,T_forany>    inout_arg_val;
     typedef Out_Fixed_Array_Argument_T<T,T_forany>      out_arg_val;
-    typedef Ret_Fixed_Array_Argument_T<T_slice,
+    typedef Ret_Fixed_Array_Argument_T<T,
+                                       T_slice,
                                        T_var,
-                                       T_life, 
                                        T_forany>        stub_ret_val;
 
     typedef In_Fixed_Array_SArgument_T<T,T_forany>      in_sarg_val;
diff --git a/TAO/tao/Object_Argument_T.h b/TAO/tao/Object_Argument_T.h
index c67d77ef1b4..688109157b8 100644
--- a/TAO/tao/Object_Argument_T.h
+++ b/TAO/tao/Object_Argument_T.h
@@ -21,9 +21,13 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+// This set of classes is also used by valuetype arguments. If the
+// specialization is done using S * for the parameter, the semantics
+// are the same as for interfaces, so there's no need for another
+// set of classes.
+
 namespace TAO
 {
-
   /**
    * @class In_Object_Argument_T
    *
diff --git a/TAO/tao/Var_Array_Argument_T.cpp b/TAO/tao/Var_Array_Argument_T.cpp
index b8301513e0d..d5ccfa010a1 100644
--- a/TAO/tao/Var_Array_Argument_T.cpp
+++ b/TAO/tao/Var_Array_Argument_T.cpp
@@ -87,18 +87,19 @@ TAO::Inout_Var_Array_Argument_T<S,S_forany>::interceptor_replace (
 
 // ==============================================================
 
-template<typename S_var, typename S_out, typename S_life, typename S_forany>
-TAO::Out_Var_Array_Argument_T<S_var,S_out,S_life,S_forany>::
+template<typename S, typename S_var, typename S_out, typename S_forany>
+TAO::Out_Var_Array_Argument_T<S,S_var,S_out,S_forany>::
 Out_Var_Array_Argument_T (S_out x)
 {
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
   ACE_ALLOCATOR (x.ptr (),
-                 S_life::tao_alloc ());
+                 ARRAY_TRAITS::tao_alloc ());
   this->x_ = x.ptr ();
 }
 
-template<typename S_var, typename S_out, typename S_life, typename S_forany>
+template<typename S, typename S_var, typename S_out, typename S_forany>
 CORBA::Boolean
-TAO::Out_Var_Array_Argument_T<S_var,S_out,S_life,S_forany>::demarshal (
+TAO::Out_Var_Array_Argument_T<S,S_var,S_out,S_forany>::demarshal (
     TAO_InputCDR & cdr
   )
 {
@@ -108,19 +109,20 @@ TAO::Out_Var_Array_Argument_T<S_var,S_out,S_life,S_forany>::demarshal (
 
 // ============================================================
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
 Ret_Var_Array_Argument_T (void)
 {
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
   S_slice * tmp = 0;
   ACE_ALLOCATOR (tmp,
-                 S_life::tao_alloc ());
+                 ARRAY_TRAITS::tao_alloc ());
   this->x_ = tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 CORBA::Boolean
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::demarshal (
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::demarshal (
     TAO_InputCDR & cdr
   )
 {
@@ -128,33 +130,33 @@ TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::demarshal (
   return cdr >> tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 void
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
 interceptor_result (CORBA::Any * any)
 {
   (*any) <<= S_forany (this->x_.ptr ());
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 CORBA::Boolean
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
 interceptor_replace (CORBA::Any & any)
 {
   S_forany tmp (this->x_.ptr ());
   return any >>= tmp;
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 S_slice *
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::excp (void)
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::excp (void)
 {
   return this->x_.ptr ();
 }
 
-template<typename S_slice, typename S_var, typename S_life, typename S_forany>
+template<typename S, typename S_slice, typename S_var, typename S_forany>
 S_slice *
-TAO::Ret_Var_Array_Argument_T<S_slice,S_var,S_life,S_forany>::retn (void)
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::retn (void)
 {
   return this->x_._retn ();
 }
diff --git a/TAO/tao/Var_Array_Argument_T.h b/TAO/tao/Var_Array_Argument_T.h
index 506f7da6a61..c977106dff2 100644
--- a/TAO/tao/Var_Array_Argument_T.h
+++ b/TAO/tao/Var_Array_Argument_T.h
@@ -72,7 +72,7 @@ namespace TAO
    * @brief OUT stub argument of variable size element array.
    *
    */
-  template<typename S_var, typename S_out, typename S_life, typename S_forany>
+  template<typename S, typename S_var, typename S_out, typename S_forany>
   class Out_Var_Array_Argument_T : public Argument
   {
   public:
@@ -90,9 +90,9 @@ namespace TAO
    * @brief Return stub value of variable size element array.
    *
    */
-  template<typename S_slice, 
+  template<typename S,
+           typename S_slice, 
            typename S_var, 
-           typename S_life, 
            typename S_forany>
   class Ret_Var_Array_Argument_T : public Argument
   {
@@ -219,7 +219,6 @@ namespace TAO
            typename T_slice, 
            typename T_var, 
            typename T_out,
-           typename T_life,
            typename T_forany>
   struct Var_Array_Arg_Traits_T
   {
@@ -232,13 +231,13 @@ namespace TAO
                                     T_slice,
                                     T_forany>           in_arg_val;
     typedef Inout_Var_Array_Argument_T<T,T_forany>      inout_arg_val;
-    typedef Out_Var_Array_Argument_T<T_var,
+    typedef Out_Var_Array_Argument_T<T,
+                                     T_var,
                                      T_out,
-                                     T_life,
                                      T_forany>          out_arg_val;
-    typedef Ret_Var_Array_Argument_T<T_slice,
+    typedef Ret_Var_Array_Argument_T<T,
+                                     T_slice,
                                      T_var,
-                                     T_life, 
                                      T_forany>          stub_ret_val;
 
     typedef In_Var_Array_SArgument_T<T,T_forany>        in_sarg_val;
diff --git a/TAO/tao/corba.h b/TAO/tao/corba.h
index 3f720fd9557..92ed6d6dd62 100644
--- a/TAO/tao/corba.h
+++ b/TAO/tao/corba.h
@@ -79,6 +79,17 @@
 #include "tao/Array_VarOut_T.h"
 #include "tao/VarOut_T.h"
 
+// Template arg helper classes.
+#include "tao/Basic_Argument_T.h"
+#include "tao/BD_String_Argument_T.h"
+#include "tao/Fixed_Array_Argument_T.h"
+#include "tao/Fixed_Size_Argument_T.h"
+#include "tao/Object_Argument_T.h"
+#include "tao/Special_Basic_Argument_T.h"
+#include "tao/UB_String_Argument_T.h"
+#include "tao/Var_Array_Argument_T.h"
+#include "tao/Var_Size_Argument_T.h"
+
 #include "tao/Remote_Object_Proxy_Impl.h"
 
 #include "tao/StringSeqC.h"