ChangeLogTag: Wed Apr 16 000:14:10 2003 Jeff Parsons <j.parsons@vanderbilt.edu>

9 files changed, 191 insertions, 109 deletions

diff --git a/TAO/ChangeLog_ref b/TAO/ChangeLog_ref
index 170eb8b598a..c83dc51aac6 100644
--- a/TAO/ChangeLog_ref
+++ b/TAO/ChangeLog_ref
@@ -1,3 +1,20 @@
+Wed Apr 16 000:14:10 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * TAO_IDL/be/be_sequence.cpp:
+        * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp:
+        * TAO_IDL/be_include/be_sequence.h:
+        * TAO_IDL/be_include/be_type.h:
+        * tao/Array_VarOut_T.inl:
+        * tao/Seq_VarOut_T.inl:
+
+	  Changes to remove compile errors in Param_Test and IDL_Test.
+
+        * tests/Param_Test/recursive_union.cpp:
+
+	  Changed use of TAO-specific recursive member names to
+	  spec-defined and generated recursive member names.
+
 Mon Apr 14 17:10:59 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * tao/TAO.dsp:
diff --git a/TAO/TAO_IDL/be/be_sequence.cpp b/TAO/TAO_IDL/be/be_sequence.cpp
index 3a072c83d13..15d58887b74 100644
--- a/TAO/TAO_IDL/be/be_sequence.cpp
+++ b/TAO/TAO_IDL/be/be_sequence.cpp
@@ -29,6 +29,7 @@
 #include "be_helper.h"
 #include "utl_identifier.h"
 #include "idl_defines.h"
+#include "nr_extern.h"
 #include "ace/Log_Msg.h"
 
 ACE_RCSID (be, 
@@ -488,8 +489,10 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Unbounded_Object_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life," << be_nl
-              << elem->fwd_helper_name () << "_cast" << be_uidt_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life," << be_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_cast" << be_uidt_nl
               << ">" << be_uidt;
         }
       else
@@ -497,8 +500,10 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Bounded_Object_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life," << be_nl
-              << elem->fwd_helper_name () << "_cast," << be_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life," << be_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_cast," << be_nl
               << this->max_size ()->ev ()->u.ulval << be_uidt_nl
               << ">" << be_uidt;
         }
@@ -510,7 +515,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Unbounded_Abstract_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life" << be_uidt_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life" << be_uidt_nl
               << ">" << be_uidt;
         }
       else
@@ -518,7 +524,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Bounded_Abstract_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life," << be_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life," << be_nl
               << this->max_size ()->ev ()->u.ulval << be_uidt_nl
               << ">" << be_uidt;
         }
@@ -548,7 +555,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Unbounded_Valuetype_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life" << be_uidt_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life" << be_uidt_nl
               << ">" << be_uidt;
         }
       else
@@ -556,7 +564,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
           *os << "TAO_Bounded_Valuetype_Sequence<" << be_idt << be_idt_nl
               << elem->nested_type_name (elem_scope) << "," << be_nl;
           *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl
-              << elem->fwd_helper_name () << "_life," << be_nl
+              << this->smart_fwd_helper_name (elem_scope, elem) 
+              << "_life," << be_nl
               << this->max_size ()->ev ()->u.ulval << be_uidt_nl
               << ">" << be_uidt;
         }
@@ -595,7 +604,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
                 *os << "TAO_Unbounded_Array_Sequence<"
                     << be_idt << be_idt_nl
                     << elem->nested_type_name (elem_scope) << "," << be_nl
-                    << elem->fwd_helper_name () << "_life" << be_uidt_nl
+                    << this->smart_fwd_helper_name (elem_scope, elem) 
+                    << "_life" << be_uidt_nl
                     << ">" << be_uidt;
               }
             else
@@ -603,7 +613,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os,
                 *os << "TAO_Bounded_Array_Sequence<"
                     << be_idt << be_idt_nl
                     << elem->nested_type_name (elem_scope) << "," << be_nl
-                    << elem->fwd_helper_name () << "_life," << be_nl
+                    << this->smart_fwd_helper_name (elem_scope, elem) 
+                    << "_life," << be_nl
                     << this->max_size ()->ev ()->u.ulval << be_uidt_nl
                     << ">" << be_uidt;
               }
@@ -645,6 +656,20 @@ be_sequence::field_node (be_field *node)
   this->field_node_ = node;
 }
 
+const char *
+be_sequence::smart_fwd_helper_name (AST_Decl *elem_scope,
+                                    be_type *elem)
+{
+  if (ScopeAsDecl (this->defined_in ()) == elem_scope)
+    {
+      ACE_CString retval = "tao_";
+      retval += elem->local_name ()->get_string ();
+      return retval.rep ();
+    }
+
+  return elem->fwd_helper_name ();
+}
+
 void
 be_sequence::destroy (void)
 {
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
index 8481ffa1788..388e021b90e 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp
@@ -38,15 +38,6 @@ be_visitor_sequence_cdr_op_cs::~be_visitor_sequence_cdr_op_cs (void)
 int
 be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
 {
-  if (this->ctx_->alias ())
-    {
-      // We are here because the base type of the sequence node is
-      // itself a typedef'd sequence i.e., this is nested call resulting
-      // from bt->accept(0 below. For the case of sequence of
-      // anonymous sequence, see comment below.
-      return this->visit_node (node);
-    }
-
   if (node->cli_stub_cdr_op_gen ()
       || node->imported ()
       || node->is_local ())
@@ -73,21 +64,30 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
   // Save the sequence node for further use.
   this->ctx_->node (node);
 
+  // If our element type is an anonymous sequence, generate code for it here.
+  if (bt->node_type () == AST_Decl::NT_sequence)
+    {
+      if (bt->accept (this) == -1)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "be_visitor_sequence_cdr_op_cs::"
+                             "visit_sequence - "
+                             "Base type codegen failed\n"),
+                            -1);
+        }
+    }
+
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
     << "// " << __FILE__ << ":" << __LINE__ << be_nl << be_nl;
 
-  // If we're an anonymous sequence, we must protect against
-  // being declared more than once.
-  if (!this->ctx_->tdef ())
-    {
-      *os << "#if !defined _TAO_CDR_OP_"
-          << node->flat_name () << "_CPP_" << be_nl
-          << "#define _TAO_CDR_OP_" << node->flat_name () << "_CPP_"
-          << be_nl << be_nl;
-    }
+  *os << "#if !defined _TAO_CDR_OP_"
+      << node->flat_name () << "_CPP_" << be_nl
+      << "#define _TAO_CDR_OP_" << node->flat_name () << "_CPP_"
+      << be_nl << be_nl;
 
   //  Set the sub state as generating code for the output operator.
   this->ctx_->sub_state (TAO_CodeGen::TAO_CDR_OUTPUT);
+
   *os << "CORBA::Boolean operator<< (" << be_idt << be_idt_nl
       << "TAO_OutputCDR &strm," << be_nl
       << "const " << node->name ()
@@ -103,28 +103,13 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
   // Now encode the sequence elements.
   *os << "// Encode all elements." << be_nl;
 
-  if (bt->node_type () == AST_Decl::NT_sequence)
-    {
-      this->visit_node (node);
-    }
-  else
-    {
-      if (bt->accept (this) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "be_visitor_sequence_cdr_op_cs::"
-                             "visit_sequence - "
-                             "Base type codegen failed\n"),
-                            -1);
-        }
-    }
+  this->visit_node (bt);
 
   *os << "}" << be_uidt_nl << be_nl
       << "return 0;" << be_uidt_nl
       << "}" << be_nl << be_nl;
 
   //  Set the sub state as generating code for the input operator.
-  os->indent ();
   this->ctx_->sub_state(TAO_CodeGen::TAO_CDR_INPUT);
 
   *os << "CORBA::Boolean operator>> (" << be_idt << be_idt_nl
@@ -180,6 +165,7 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
 
   *os << "// Set the length of the sequence." << be_nl
       << "_tao_sequence.length (_tao_seq_len);" << be_nl << be_nl;
+
   // Now we do a check for the sequence length to be non zero.
   // If length is 0 we return true.
   *os << "// If length is 0 we return true." << be_nl;
@@ -190,39 +176,21 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node)
 
   *os << "// Retrieve all the elements." << be_nl;
 
-
-  if (bt->node_type () == AST_Decl::NT_sequence)
-    {
-      this->visit_node (node);
-    }
-  else
-    {
-      if (bt->accept (this) == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "be_visitor_sequence_cdr_op_cs::"
-                             "visit_sequence - "
-                             "Base type codegen failed\n"),
-                            -1);
-        }
-    }
+  this->visit_node (bt);
 
   if (expr->ev ()->u.ulval > 0)
     {
       // We are dealing with a bounded sequence.
-      *os << "}" << be_uidt << be_uidt_nl;
+      *os << be_nl << "}" << be_uidt << be_uidt;
     }
 
-  *os << "}" << be_uidt_nl << be_nl
+  *os << be_nl << "}" << be_uidt_nl << be_nl
       << "return 0;" << be_uidt_nl
       << "}";
 
-  if (!this->ctx_->tdef ())
-    {
-      *os << be_nl << be_nl
-          << "#endif /* _TAO_CDR_OP_"
-          << node->flat_name () << "_CPP_ */";
-    }
+  *os << be_nl << be_nl
+      << "#endif /* _TAO_CDR_OP_"
+      << node->flat_name () << "_CPP_ */";
 
   node->cli_stub_cdr_op_gen (1);
   return 0;
@@ -562,15 +530,18 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt)
                         -1);
     }
 
-  // If the type was a string, an obj ref, or a pseudo-obj, we are dealing
-  // with a manager type and hence we must use the appropriate in() and
-  // out() methods.
-  //
+  AST_Decl::NodeType nt = bt->node_type ();
+
+  if (nt == AST_Decl::NT_typedef)
+    {
+      be_typedef *td = be_typedef::narrow_from_decl (bt);
+      nt = td->base_node_type ();
+    }
 
   switch (this->ctx_->sub_state ())
     {
     case TAO_CodeGen::TAO_CDR_INPUT:
-      switch (bt->node_type ())
+      switch (nt)
         {
         case AST_Decl::NT_array:
           if (bt->accept (&visitor) == -1)
@@ -681,19 +652,36 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt)
                                   -1);
               }
 
-            AST_PredefinedType::PredefinedType pdt = pt->pt ();
-
-            if (pdt == AST_PredefinedType::PT_pseudo
-                || pdt == AST_PredefinedType::PT_object
-                || pdt == AST_PredefinedType::PT_value)
+            switch (pt->pt ())
               {
-                *os << "_tao_marshal_flag = (strm >> _tao_sequence[i].out ());"
-                    << be_uidt_nl;
-              }
-            else
-              {
-                *os << "_tao_marshal_flag = (strm >> _tao_sequence[i]);"
-                    << be_uidt_nl;
+                case AST_PredefinedType::PT_pseudo:
+                case AST_PredefinedType::PT_object:
+                case AST_PredefinedType::PT_value:
+                  *os << "_tao_marshal_flag = (strm >> _tao_sequence[i].out ());";
+                  break;
+                case AST_PredefinedType::PT_char:
+                  *os << "_tao_marshal_flag =" << be_idt_nl
+                      << "(strm >> CORBA::Any::to_char (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_wchar:
+                  *os << "_tao_marshal_flag =" << be_idt_nl
+                      << "(strm >> CORBA::Any::to_wchar (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_boolean:
+                  *os << "_tao_marshal_flag =" << be_idt_nl 
+                      << "(strm >> CORBA::Any::to_boolean (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_octet:
+                  *os << "_tao_marshal_flag =" << be_idt_nl 
+                      << "(strm >> CORBA::Any::to_octet (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                default:
+                  *os << "_tao_marshal_flag = (strm >> _tao_sequence[i]);";
+                  break;
               }
           }
 
@@ -705,11 +693,12 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt)
           break;
         }
 
-      *os << "}";
+      *os << be_uidt_nl
+          << "}";
 
       break;
     case TAO_CodeGen::TAO_CDR_OUTPUT:
-      switch (bt->node_type ())
+      switch (nt)
         {
         case AST_Decl::NT_array:
           if (bt->accept (&visitor) == -1)
@@ -814,17 +803,36 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt)
                                   -1);
               }
 
-            AST_PredefinedType::PredefinedType pdt = pt->pt ();
-
-            if (pdt == AST_PredefinedType::PT_pseudo
-                || pdt == AST_PredefinedType::PT_object
-                || pdt == AST_PredefinedType::PT_value)
+            switch (pt->pt ())
               {
-                *os << "_tao_marshal_flag = (strm << _tao_sequence[i].in ());";
-              }
-            else
-              {
-                *os << "_tao_marshal_flag = (strm << _tao_sequence[i]);";
+                case AST_PredefinedType::PT_pseudo:
+                case AST_PredefinedType::PT_object:
+                case AST_PredefinedType::PT_value:
+                  *os << "_tao_marshal_flag = (strm << _tao_sequence[i].in ());";
+                  break;
+                case AST_PredefinedType::PT_char:
+                  *os << "_tao_marshal_flag =" << be_idt_nl
+                      << "(strm << CORBA::Any::from_char (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_wchar:
+                  *os << "_tao_marshal_flag =" << be_idt_nl
+                      << "(strm << CORBA::Any::from_wchar (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_boolean:
+                  *os << "_tao_marshal_flag =" << be_idt_nl 
+                      << "(strm << CORBA::Any::from_boolean (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                case AST_PredefinedType::PT_octet:
+                  *os << "_tao_marshal_flag =" << be_idt_nl 
+                      << "(strm << CORBA::Any::from_octet (_tao_sequence[i]));" 
+                      << be_uidt;
+                  break;
+                default:
+                  *os << "_tao_marshal_flag = (strm << _tao_sequence[i]);";
+                  break;
               }
           }
 
@@ -847,8 +855,8 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt)
                         -1);
     }
 
-  *os << be_uidt_nl<< be_nl;
+  *os << be_uidt_nl << be_nl;
   *os << "return _tao_marshal_flag;" << be_uidt_nl;
-
+ 
   return 0;
 }
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
index faed84b3860..0ca8edd7e1d 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp
@@ -372,13 +372,27 @@ be_visitor_sequence_ch::gen_varout_typedefs (be_sequence *node,
     default: // Not a managed type.
       {
         AST_Type::SIZE_TYPE st = elem->size_type ();
+        be_typedef *td = be_typedef::narrow_from_decl (elem);
+        AST_Decl::NodeType nt = elem->node_type ();
+
+        if (td != 0)
+          {
+            nt = td->base_node_type ();
+          }
 
         *os << "typedef" << be_idt_nl
             << (st == AST_Type::FIXED ? "TAO_FixedSeq_Var_T<" 
                                       : "TAO_VarSeq_Var_T<")
             << be_idt << be_idt_nl
             << node->local_name () << "," << be_nl
-            << elem->nested_type_name (scope) << be_uidt_nl
+            << elem->nested_type_name (scope);
+
+        if (nt == AST_Decl::NT_array)
+          {
+            *os << "_slice *";
+          }
+
+        *os << be_uidt_nl
             << ">" << be_uidt_nl
             << node->local_name () << "_var;" << be_uidt;
 
@@ -387,7 +401,14 @@ be_visitor_sequence_ch::gen_varout_typedefs (be_sequence *node,
             << "TAO_Seq_Out_T<" << be_idt << be_idt_nl
             << node->local_name () << "," << be_nl
             << node->local_name () << "_var," << be_nl
-            << elem->nested_type_name (scope) << be_uidt_nl
+            << elem->nested_type_name (scope);
+
+        if (nt == AST_Decl::NT_array)
+          {
+            *os << "_slice *";
+          }
+
+        *os << be_uidt_nl
             << ">" << be_uidt_nl
             << node->local_name () << "_out;" << be_uidt;
       }
diff --git a/TAO/TAO_IDL/be_include/be_sequence.h b/TAO/TAO_IDL/be_include/be_sequence.h
index 74f89274fbd..77d73afe16b 100644
--- a/TAO/TAO_IDL/be_include/be_sequence.h
+++ b/TAO/TAO_IDL/be_include/be_sequence.h
@@ -104,6 +104,10 @@ protected:
   // Helper to create_name.
 
 private:
+  const char *smart_fwd_helper_name (AST_Decl *elem_scope,
+                                     be_type *elem);
+
+private:
   MANAGED_TYPE mt_;
   // Our managed type.
 
diff --git a/TAO/TAO_IDL/be_include/be_type.h b/TAO/TAO_IDL/be_include/be_type.h
index a73d51f21da..3eb97f4bdfc 100644
--- a/TAO/TAO_IDL/be_include/be_type.h
+++ b/TAO/TAO_IDL/be_include/be_type.h
@@ -57,6 +57,7 @@ public:
   void gen_fwd_helper_name (void);
 
   const char *fwd_helper_name (void) const;
+  void fwd_helper_name (const char *name);
   // Accessor to the member.
 
   void gen_common_varout (TAO_OutStream *os);
diff --git a/TAO/tao/Array_VarOut_T.inl b/TAO/tao/Array_VarOut_T.inl
index c5b1c141e32..8822fbe0543 100644
--- a/TAO/tao/Array_VarOut_T.inl
+++ b/TAO/tao/Array_VarOut_T.inl
@@ -64,7 +64,10 @@ ACE_INLINE
 const T_slice *
 TAO_Array_Var_Base_T<T_slice,T_life>::in (void) const
 {
-  return this->ptr_;
+  // @@@ (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_);
 }
 
 template<typename T_slice, typename T_life>
@@ -134,7 +137,7 @@ TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (void)
 template<typename T_slice, typename T_life>
 ACE_INLINE
 TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (T_slice * p)
-  : TAO_VarArray_Var_T<T_slice,T_life> (p)
+  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
 {}
 
 template<typename T_slice, typename T_life>
@@ -316,7 +319,10 @@ ACE_INLINE
 const T_slice *
 TAO_Array_Forany_T<T_slice,T_life>::in (void) const
 {
-  return this->ptr_;
+  // @@@ (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_);
 }
 
 template<typename T_slice, typename T_life>
diff --git a/TAO/tao/Seq_VarOut_T.inl b/TAO/tao/Seq_VarOut_T.inl
index 09c4455f25a..5402cb95771 100644
--- a/TAO/tao/Seq_VarOut_T.inl
+++ b/TAO/tao/Seq_VarOut_T.inl
@@ -145,7 +145,7 @@ ACE_INLINE
 T_elem &
 TAO_FixedSeq_Var_T<T,T_elem>::operator[] (CORBA::ULong index)
 {
-  return this->ptr_->operator[] (index);
+  return (T_elem &) this->ptr_->operator[] (index);
 }
 
 template<typename T, typename T_elem>
@@ -153,7 +153,7 @@ ACE_INLINE
 const T_elem &
 TAO_FixedSeq_Var_T<T,T_elem>::operator[] (CORBA::ULong index) const
 {
-  return ACE_const_cast (const T_elem &, this->ptr_->operator[] (index));
+  return (const T_elem &) this->ptr_->operator[] (index));
 }
 
 // ***************************************************************
diff --git a/TAO/tests/Param_Test/recursive_union.cpp b/TAO/tests/Param_Test/recursive_union.cpp
index 12034ad2c16..dc0852cfa6a 100644
--- a/TAO/tests/Param_Test/recursive_union.cpp
+++ b/TAO/tests/Param_Test/recursive_union.cpp
@@ -208,7 +208,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru,
 
       ru.nested_member (nru);
 
-      Param_Test::Recursive_Union::_tao_seq_Recursive_Union tmp (MAX_SEQ_LENGTH);
+      Param_Test::Recursive_Union::_rec_member_seq tmp (MAX_SEQ_LENGTH);
 
       ru.rec_member (tmp);
 
@@ -223,7 +223,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru,
       // This line is TAO-specific, but some compilers we support
       // are broken in their handling of the portable scoped typedef
       // required by CORBA 2.3
-      Param_Test::Recursive_Union::_tao_seq_Recursive_Union tmp (MAX_SEQ_LENGTH);
+      Param_Test::Recursive_Union::_rec_member_seq tmp (MAX_SEQ_LENGTH);
 
       tmp.length (len);
 
@@ -261,7 +261,7 @@ Test_Recursive_Union::deep_init_nested (Param_Test::nested_rec_union &nu,
       // This line is TAO-specific, but some compilers we support
       // are broken in their handling of the portable scoped typedef
       // required by CORBA 2.3
-      Param_Test::nested_rec_union::_tao_seq_nested_rec_union tmp (MAX_SEQ_LENGTH);
+      Param_Test::nested_rec_union::_nested_rec_member_seq tmp (MAX_SEQ_LENGTH);
 
       tmp.length (len);