ChangeLogTag:Wed Mar 8 19:18:10 2000 Carlos O'Ryan <coryan@uci.edu>

111 files changed, 4187 insertions, 5440 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index 02514807d0d..375ebf1f906 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,35 +1,216 @@
-Wed Mar  8 17:22:32 2000  Ossama Othman  <ossama@uci.edu>
+Wed Mar  8 19:18:10 2000  Carlos O'Ryan  <coryan@uci.edu>
+
+        * tao/Makefile:
+        * tao/Marshal.h:
+        * tao/decode.cpp:
+        * tao/encode.cpp:
+          I have started the work to remove the interpretive engine.
+          The first step was to remove the the encode() and decode()
+          methods.  We have re-implemented all the other components in the
+          ORB to use compiled marshaling instead.
+
+        * tao/Any.h:
+        * tao/Any.i:
+        * tao/Any.cpp:
+          All the methods taking void* are deprecated (unfortunately due
+          to an editorial mistake this resolution didn't make it into the
+          text of the CORBA 2.3 mapping).  There is no portable way to use
+          them anyway.
+          For the time beign we have commented them out, to check that no
+          portion of TAO invokes them, eventually we will make them
+          visible again, but they will raise the CORBA::NO_IMPLEMENT
+          exception.
+          Re-implement all the basic <<= and >>= operators using
+          _tao_replace() instead of replace().
+          The extraction operators for the CORBA::Any::to_string,
+          CORBA::Any::to_wstring and CORBA::Any::to_object classes were
+          not implemented properly.  First they did not unalias the types,
+          and next they used equivalent() with the wrong TypeCode.
+          Implement the CDR operators for Any using compiled marshaling.
+
+        * tao/Makefile:
+        * tao/BoundsC.h:
+        * tao/BoundsC.cpp:
+          BoundsC was not compiled, though this is the right exception to
+          raise from certain NVList operations.
+          Updated to use _tao_replace() in the >>= and <<= operators.
+
+        * tao/CDR.h:
+        * tao/CDR.cpp:
+          Remove the decode() and encode() methods
+
+        * tao/Stub.h:
+        * tao/Stub.cpp:
+        * tao/GIOP_Server_Request.h:
+        * tao/GIOP_Server_Request.cpp:
+        * tao/Server_Request.h:
+          Remove the support for interpretive marshaling.
+
+        * tao/Invocation.h:
+        * tao/Invocation.cpp:
+          Removed old comments about interpretive marshaling.
+
+        * tao/NVList.cpp:
+          It was raising CORBA::TypeCode::Bounds to signal an error, but
+          the correct exception is CORBA::Bounds.
+
+        * tao/Exception.cpp:
+
+        * tao/DynAny_i.cpp:
+        * tao/Forwarding_Servant.cpp:
+        * tao/MessagingS.cpp:
+        * tao/ObjectIDList.cpp:
+        * tao/ObjectIDList.h:
+        * tao/POAS.cpp:
+        * tao/PolicyS.cpp:
+        * tao/PollableS.cpp:
+        * tao/Services.cpp:
+        * tao/Services.h:
+        * tao/Typecode.h:
+        * tao/Typecode.cpp:
+        * tao/append.cpp:
+        * tao/skip.cpp:
+          Re-implemented several stubs using compiled marshaling.
+          Use _tao_replace() in <<= and >>= operators.
 
-	* docs/pluggable_protocols/index.html:
 
-	  Fixed typographical errors.
+        * TAO_IDL/be/be_visitor_operation/ami_exception_holder_operation_cs.cpp:
+          Use _tao_encode() and _tao_decode() to marshal and demarshal
+          exceptions.  Those methods are implemented using compiled
+          marshaling.
 
-	* tao/ORB.cpp (ORB_init):
+        * tao/POAC.cpp:
+        * TAO_IDL/be/be_visitor_array/cdr_op_ci.cpp:
+        * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp:
+          Cosmetic changes.
 
-	  It doesn't make sense for argc to be zero and argv to be
-	  non-empty/zero, or for argc to be greater than zero and argv be
-	  zero/empty.  Throw a CORBA::BAD_PARAM() exception if argc/argv
-	  combination is invalid.
+        * tests/Param_Test/Makefile:
+        * tests/Param_Test/anyop.cpp:
+          New test to verify that the <<= and >>= operators work
+          correctly.
 
-	* tao/ORB_Core.cpp (init):
+        * tests/Param_Test/param_test.idl:
 
-	  Throw a CORBA::BAD_PARAM() exception if an unrecognized "-ORB"
-	  option is encountered.  This behavior is in accordance with the
-	  CORBA 2.3.1 specification.
+        * tests/Param_Test/client.cpp:
+        * tests/Param_Test/any.h:
+        * tests/Param_Test/any.cpp:
+        * tests/Param_Test/bd_array_seq.h:
+        * tests/Param_Test/bd_array_seq.cpp:
+        * tests/Param_Test/bd_long_seq.h:
+        * tests/Param_Test/bd_long_seq.cpp:
+        * tests/Param_Test/bd_short_seq.h:
+        * tests/Param_Test/bd_short_seq.cpp:
+        * tests/Param_Test/bd_str_seq.h:
+        * tests/Param_Test/bd_str_seq.cpp:
+        * tests/Param_Test/bd_string.h:
+        * tests/Param_Test/bd_string.cpp:
+        * tests/Param_Test/bd_struct_seq.h:
+        * tests/Param_Test/bd_struct_seq.cpp:
+        * tests/Param_Test/bd_wstr_seq.h:
+        * tests/Param_Test/bd_wstr_seq.cpp:
+        * tests/Param_Test/bd_wstring.h:
+        * tests/Param_Test/bd_wstring.cpp:
+        * tests/Param_Test/big_union.h:
+        * tests/Param_Test/big_union.cpp:
+        * tests/Param_Test/complex_any.h:
+        * tests/Param_Test/complex_any.cpp:
+        * tests/Param_Test/except.h:
+        * tests/Param_Test/except.cpp:
+        * tests/Param_Test/fixed_array.h:
+        * tests/Param_Test/fixed_array.cpp:
+        * tests/Param_Test/fixed_struct.h:
+        * tests/Param_Test/fixed_struct.cpp:
+        * tests/Param_Test/multdim_array.h:
+        * tests/Param_Test/multdim_array.cpp:
+        * tests/Param_Test/nested_struct.h:
+        * tests/Param_Test/nested_struct.cpp:
+        * tests/Param_Test/objref.h:
+        * tests/Param_Test/objref.cpp:
+        * tests/Param_Test/objref_struct.h:
+        * tests/Param_Test/objref_struct.cpp:
+        * tests/Param_Test/recursive_struct.h:
+        * tests/Param_Test/recursive_struct.cpp:
+        * tests/Param_Test/recursive_union.h:
+        * tests/Param_Test/recursive_union.cpp:
+        * tests/Param_Test/short.h:
+        * tests/Param_Test/short.cpp:
+        * tests/Param_Test/typecode.h:
+        * tests/Param_Test/typecode.cpp:
+        * tests/Param_Test/ub_any_seq.h:
+        * tests/Param_Test/ub_any_seq.cpp:
+        * tests/Param_Test/ub_array_seq.h:
+        * tests/Param_Test/ub_array_seq.cpp:
+        * tests/Param_Test/ub_long_seq.h:
+        * tests/Param_Test/ub_long_seq.cpp:
+        * tests/Param_Test/ub_objref_seq.h:
+        * tests/Param_Test/ub_objref_seq.cpp:
+        * tests/Param_Test/ub_short_seq.h:
+        * tests/Param_Test/ub_short_seq.cpp:
+        * tests/Param_Test/ub_str_seq.h:
+        * tests/Param_Test/ub_str_seq.cpp:
+        * tests/Param_Test/ub_string.h:
+        * tests/Param_Test/ub_string.cpp:
+        * tests/Param_Test/ub_struct_seq.h:
+        * tests/Param_Test/ub_struct_seq.cpp:
+        * tests/Param_Test/ub_wstr_seq.h:
+        * tests/Param_Test/ub_wstr_seq.cpp:
+        * tests/Param_Test/ub_wstring.h:
+        * tests/Param_Test/ub_wstring.cpp:
+        * tests/Param_Test/ulonglong.h:
+        * tests/Param_Test/ulonglong.cpp:
+        * tests/Param_Test/var_array.h:
+        * tests/Param_Test/var_array.cpp:
+        * tests/Param_Test/var_struct.h:
+        * tests/Param_Test/var_struct.cpp:
+          We now use the standard <<= and >>= operators to test DII. We
+          also use the add_in_arg(), add_out_arg() and add_inout_arg()
+          helper methods.
+          The add_args() method was removed because it relied on the
+          non-portable, deprecated and ugly replace() operation in
+          CORBA::Any.
+          The SII tests are all passing, most of the DII tests pass too,
+          but these changes uncovered several problems with the
+          implementation of deep_free(), since deep_free has to be
+          removed we better wait for those changes instead of trying to
+          support the current scheme.
+
+        * tao/IIOP_Profile.cpp:
+        * tao/SHMIOP_Profile.cpp:
+        * tao/UIOP_Profile.cpp:
+          Cosmetic fixes.
+
+Wed Mar  8 17:22:32 2000  Ossama Othman  <ossama@uci.edu>
+
+        * docs/pluggable_protocols/index.html:
+
+          Fixed typographical errors.
+
+        * tao/ORB.cpp (ORB_init):
+
+          It doesn't make sense for argc to be zero and argv to be
+          non-empty/zero, or for argc to be greater than zero and argv be
+          zero/empty.  Throw a CORBA::BAD_PARAM() exception if argc/argv
+          combination is invalid.
+
+        * tao/ORB_Core.cpp (init):
 
-	  Use ACE_NEW_THROW_EX(), instead of ACE_NEW_RETURN() in
-	  "-ORBLogFile" option processing code.
-	
-	  Explicitly consume "-ORBid" options passed to this method since
-	  they are specifically handled in the CORBA::ORB_init() method.
-	  According to the CORBA specification, if the ORBid third
-	  argument is used then any "-ORBid" options must be ignored.
-	  However, the above fix that forces the ORB to throw an
-	  exception when encountering an unrecognized "-ORB" option,
-	  also forces us to explicitly recognize the "-ORBid" option in
-	  the TAO_ORB_Core::init() method since it may "slip" through when
-	  both the ORBid third argument to CORBA::ORB_init() and a
-	  "-ORBid" ORB option are provided.
+          Throw a CORBA::BAD_PARAM() exception if an unrecognized "-ORB"
+          option is encountered.  This behavior is in accordance with the
+          CORBA 2.3.1 specification.
+
+          Use ACE_NEW_THROW_EX(), instead of ACE_NEW_RETURN() in
+          "-ORBLogFile" option processing code.
+
+          Explicitly consume "-ORBid" options passed to this method since
+          they are specifically handled in the CORBA::ORB_init() method.
+          According to the CORBA specification, if the ORBid third
+          argument is used then any "-ORBid" options must be ignored.
+          However, the above fix that forces the ORB to throw an
+          exception when encountering an unrecognized "-ORB" option,
+          also forces us to explicitly recognize the "-ORBid" option in
+          the TAO_ORB_Core::init() method since it may "slip" through when
+          both the ORBid third argument to CORBA::ORB_init() and a
+          "-ORBid" ORB option are provided.
 
 Wed Mar  8 12:03:21 2000  Carlos O'Ryan  <coryan@uci.edu>
 
diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp
index ef0bfeec8a6..fca84306ff2 100644
--- a/TAO/tao/Any.cpp
+++ b/TAO/tao/Any.cpp
@@ -76,42 +76,61 @@ CORBA_Any::CORBA_Any (void)
 // and either holds or "consumes" an arbitrary data value satisfying
 // the normal binary interface rules.
 
-CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc,
-                      void *value,
-                      CORBA::Boolean any_owns_data)
-  : type_ (CORBA::TypeCode::_duplicate (tc)),
-    value_ (value),
+#if 0
+CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr,
+                      void *,
+                      CORBA::Environment &ACE_TRY_ENV)
+  : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)),
+    value_ (0),
     byte_order_ (TAO_ENCAP_BYTE_ORDER),
     cdr_ (0),
-    any_owns_data_ (any_owns_data)
+    any_owns_data_ (0)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_THROW (CORBA::NO_IMPLEMENT ());
+}
 
-  ACE_TRY
-    {
-      if (this->value_ != 0)
-        {
-          TAO_OutputCDR stream;
+CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr,
+                      void *,
+                      CORBA::Boolean,
+                      CORBA::Environment &ACE_TRY_ENV)
+  : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)),
+    value_ (0),
+    byte_order_ (TAO_ENCAP_BYTE_ORDER),
+    cdr_ (0),
+    any_owns_data_ (0)
+{
+  ACE_THROW (CORBA::NO_IMPLEMENT ());
+}
 
-          // Encode the value.
-          stream.encode (this->type_,
-                         this->value_,
-                         0,
-                         ACE_TRY_ENV);
-          ACE_TRY_CHECK;
+// All-at-once replacement of the contents of an "Any."
 
-          // Retrieve the start of the message block chain and save it.
-          this->byte_order_ = TAO_ENCAP_BYTE_ORDER;
-          ACE_NEW (this->cdr_, ACE_Message_Block);
-          ACE_CDR::consolidate (this->cdr_, stream.begin ());
-        }
-    }
-  ACE_CATCHANY
-    {
-      // do nothing
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
+void
+CORBA_Any::replace (CORBA::TypeCode_ptr,
+                    const void *,
+                    CORBA::Boolean,
+                    CORBA::Environment &ACE_TRY_ENV)
+{
+  ACE_THROW (CORBA::NO_IMPLEMENT ());
+}
+
+void
+CORBA_Any::replace (CORBA::TypeCode_ptr,
+                    const void *,
+                    CORBA::Environment &ACE_TRY_ENV)
+{
+  ACE_THROW (CORBA::NO_IMPLEMENT ());
+}
+#endif /* 0 */
+
+CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc,
+                      CORBA::Environment &)
+  : type_ (CORBA::TypeCode::_duplicate (tc)),
+    value_ (0),
+    byte_order_ (TAO_ENCAP_BYTE_ORDER),
+    cdr_ (0),
+    any_owns_data_ (0)
+{
+  // ACE_THROW (CORBA::NO_IMPLEMENT ());
 }
 
 // Constructor using a message block.
@@ -238,53 +257,8 @@ CORBA_Any::~CORBA_Any (void)
   ACE_CHECK;
 }
 
-// All-at-once replacement of the contents of an "Any."
-
-void
-CORBA_Any::replace (CORBA::TypeCode_ptr tc,
-                    const void *value,
-                    CORBA::Boolean any_owns_data,
-                    CORBA::Environment &ACE_TRY_ENV)
-{
-  // Decrement the refcount on the Message_Block we hold, it does not
-  // matter if we own the data or not, because we always own the
-  // message block (i.e. it is always cloned or duplicated).
-  ACE_Message_Block::release (this->cdr_);
-  this->cdr_ = 0;
-
-  this->free_value (ACE_TRY_ENV);
-  ACE_CHECK;
-
-  // Duplicate tc and then release this->type_, just in case tc and
-  // type_ are the same thing.
-  CORBA::TypeCode_ptr tmp =
-    CORBA::TypeCode::_duplicate (tc);
-  CORBA::release (this->type_);
-  this->type_ = tmp;
-
-  this->value_ = ACE_const_cast (void *, value);
-  this->any_owns_data_ = any_owns_data;
-  this->cdr_ = 0;
-
-  if (value)
-    {
-      // @@ NW: I think an Any should alway owns the CDR stream,
-      //  so I removed the check here.
-      // if the Any owns the data, we encode the "value" into a CDR stream
-      // and store it. We also destroy the "value" since we own it.
-      TAO_OutputCDR stream;
-      stream.encode (tc,
-                     value,
-                     0,
-                     ACE_TRY_ENV);
-      ACE_CHECK;
-
-      // Retrieve the start of the message block chain and duplicate it.
-      this->byte_order_ = TAO_ENCAP_BYTE_ORDER;
-      ACE_NEW (this->cdr_, ACE_Message_Block);
-      ACE_CDR::consolidate (this->cdr_, stream.begin ());
-    }
-}
+// TAO proprietary methods, used in the implementation of the >>= and
+// <<= operators.
 
 void
 CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
@@ -390,15 +364,9 @@ CORBA_Any::_tao_encode (TAO_OutputCDR &cdr,
                         TAO_ORB_Core *orb_core,
                         CORBA::Environment &ACE_TRY_ENV)
 {
-  // If the Any owns the data, then we have allocated space.
-  if (this->value_ != 0)
-    {
-      (void) cdr.encode (this->type_,
-                         this->value_,
-                         0,
-                         ACE_TRY_ENV);
-      return;
-    }
+  // Always append the CDR stream, even when the value_.
+  if (this->cdr_ == 0)
+    ACE_THROW (CORBA::NO_IMPLEMENT ());
 
   TAO_InputCDR in (this->cdr_,
                    this->byte_order_,
@@ -412,15 +380,7 @@ void
 CORBA_Any::_tao_decode (TAO_InputCDR &cdr,
                         CORBA::Environment &ACE_TRY_ENV)
 {
-  if (this->value_ != 0)
-    {
-      // @@ Should we free that value first?
-      cdr.decode (this->type_,
-                  this->value_,
-                  0,
-                  ACE_TRY_ENV);
-      return;
-    }
+  // Just read into the CDR stream...
 
   // @@ (JP) The following code depends on the fact that
   //         TAO_InputCDR does not contain chained message blocks,
@@ -467,13 +427,16 @@ CORBA_Any::operator<<= (CORBA::Short s)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << s;
       CORBA::Short *ns;
-      ACE_NEW (ns,
-               CORBA::Short (s));
-      this->replace (CORBA::_tc_short,
-                     ns,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (ns, CORBA::Short (s));
+      this->_tao_replace (CORBA::_tc_short,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          ns,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -491,13 +454,16 @@ CORBA_Any::operator<<= (CORBA::UShort s)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << s;
       CORBA::UShort *ns;
-      ACE_NEW (ns,
-               CORBA::UShort (s));
-      this->replace (CORBA::_tc_ushort,
-                     ns,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (ns, CORBA::UShort (s));
+      this->_tao_replace (CORBA::_tc_ushort,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          ns,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -515,13 +481,16 @@ CORBA_Any::operator<<= (CORBA::Long l)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << l;
       CORBA::Long *nl;
-      ACE_NEW (nl,
-               CORBA::Long (l));
-      this->replace (CORBA::_tc_long,
-                     nl,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nl, CORBA::Long (l));
+      this->_tao_replace (CORBA::_tc_long,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nl,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -539,13 +508,16 @@ CORBA_Any::operator<<= (CORBA::ULong l)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << l;
       CORBA::ULong *nl;
-      ACE_NEW (nl,
-               CORBA::ULong (l));
-      this->replace (CORBA::_tc_ulong,
-                     nl,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nl, CORBA::ULong (l));
+      this->_tao_replace (CORBA::_tc_ulong,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nl,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -563,13 +535,16 @@ CORBA_Any::operator<<= (CORBA::LongLong l)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << l;
       CORBA::LongLong *nl;
-      ACE_NEW (nl,
-               CORBA::LongLong (l));
-      this->replace (CORBA::_tc_longlong,
-                     nl,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nl, CORBA::LongLong (l));
+      this->_tao_replace (CORBA::_tc_longlong,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nl,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -587,13 +562,16 @@ CORBA_Any::operator<<= (CORBA::ULongLong l)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << l;
       CORBA::ULongLong *nl;
-      ACE_NEW (nl,
-               CORBA::ULongLong (l));
-      this->replace (CORBA::_tc_ulonglong,
-                     nl,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nl, CORBA::ULongLong (l));
+      this->_tao_replace (CORBA::_tc_ulonglong,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nl,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -611,13 +589,16 @@ CORBA_Any::operator<<= (CORBA::Float f)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << f;
       CORBA::Float *nf;
-      ACE_NEW (nf,
-               CORBA::Float (f));
-      this->replace (CORBA::_tc_float,
-                     nf,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nf, CORBA::Float (f));
+      this->_tao_replace (CORBA::_tc_float,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nf,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -635,13 +616,16 @@ CORBA_Any::operator<<= (CORBA::Double d)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << d;
       CORBA::Double *nd;
-      ACE_NEW (nd,
-               CORBA::Double (d));
-      this->replace (CORBA::_tc_double,
-                     nd,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nd, CORBA::Double (d));
+      this->_tao_replace (CORBA::_tc_double,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nd,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -654,18 +638,21 @@ CORBA_Any::operator<<= (CORBA::Double d)
 }
 
 void
-CORBA_Any::operator<<= (CORBA::LongDouble ld)
+CORBA_Any::operator<<= (CORBA::LongDouble d)
 {
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      CORBA::LongDouble *nld;
-      ACE_NEW (nld,
-               CORBA::LongDouble (ld));
-      this->replace (CORBA::_tc_longdouble,
-                     nld,
-                     1,
-                     ACE_TRY_ENV);
+      TAO_OutputCDR stream;
+      stream << d;
+      CORBA::LongDouble *nd;
+      ACE_NEW (nd, CORBA::LongDouble (d));
+      this->_tao_replace (CORBA::_tc_longdouble,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nd,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -684,13 +671,16 @@ CORBA_Any::operator<<= (const CORBA_Any& a)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << a;
       CORBA_Any_ptr na;
-      ACE_NEW (na,
-               CORBA::Any (a));
-      this->replace (CORBA::_tc_any,
-                     na,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (na, CORBA::Any (a));
+      this->_tao_replace (CORBA::_tc_any,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          na,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -704,15 +694,19 @@ CORBA_Any::operator<<= (const CORBA_Any& a)
 
 // insertion of Any - non-copying
 void
-CORBA::Any::operator<<= (CORBA::Any_ptr anyptr)
+CORBA::Any::operator<<= (CORBA::Any* a)
 {
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      this->replace (CORBA::_tc_any,
-                     anyptr,
-                     1,
-                     ACE_TRY_ENV);
+      TAO_OutputCDR stream;
+      stream << *a;
+      this->_tao_replace (CORBA::_tc_any,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          a,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -732,13 +726,16 @@ CORBA_Any::operator<<= (from_boolean b)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << b;
       CORBA::Boolean *nb;
-      ACE_NEW (nb,
-               CORBA::Boolean (b.val_));
-      this->replace (CORBA::_tc_boolean,
-                     nb,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nb, CORBA::Boolean (b.val_));
+      this->_tao_replace (CORBA::_tc_boolean,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nb,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -756,13 +753,16 @@ CORBA_Any::operator<<= (from_octet o)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << o;
       CORBA::Octet *no;
-      ACE_NEW (no,
-               CORBA::Octet (o.val_));
-      this->replace (CORBA::_tc_octet,
-                     no,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (no, CORBA::Octet (o.val_));
+      this->_tao_replace (CORBA::_tc_octet,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          no,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -780,13 +780,16 @@ CORBA_Any::operator<<= (from_char c)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << c;
       CORBA::Char *nc;
-      ACE_NEW (nc,
-               CORBA::Char (c.val_));
-      this->replace (CORBA::_tc_char,
-                     nc,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nc, CORBA::Char (c.val_));
+      this->_tao_replace (CORBA::_tc_char,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nc,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -804,13 +807,16 @@ CORBA_Any::operator<<= (from_wchar wc)
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << wc;
       CORBA::WChar *nwc;
-      ACE_NEW (nwc,
-               CORBA::WChar (wc.val_));
-      this->replace (CORBA::_tc_wchar,
-                     nwc,
-                     1,
-                     ACE_TRY_ENV);
+      ACE_NEW (nwc, CORBA::WChar (wc.val_));
+      this->_tao_replace (CORBA::_tc_wchar,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          nwc,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -829,16 +835,20 @@ CORBA_Any::operator<<= (CORBA::TypeCode_ptr tc)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << tc;
       CORBA::TypeCode_ptr *_tao_tc;
 
       ACE_NEW (_tao_tc,
                CORBA::TypeCode_ptr);
 
       *_tao_tc = CORBA::TypeCode::_duplicate (tc);
-      this->replace (CORBA::_tc_TypeCode,
-                     _tao_tc,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (CORBA::_tc_TypeCode,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          _tao_tc,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -897,16 +907,20 @@ CORBA::Any::operator<<= (CORBA::Object_ptr *objptr)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << *objptr;
       CORBA::Object_ptr *_tao_object_ptr;
 
       ACE_NEW (_tao_object_ptr,
                CORBA::Object_ptr);
 
       *_tao_object_ptr = *objptr;
-      this->replace (CORBA::_tc_Object,
-                     _tao_object_ptr,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (CORBA::_tc_Object,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          _tao_object_ptr,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -927,6 +941,9 @@ CORBA_Any::operator<<= (from_string s)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << s;
+
       // If the inserted string is bounded, we create a typecode.
       static CORBA::Long _oc_string [] =
       {
@@ -967,10 +984,12 @@ CORBA_Any::operator<<= (from_string s)
                    char* (CORBA::string_dup (s.val_)));
         }
 
-      this->replace (tc,
-                     tmp,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (tc,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          tmp,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -989,6 +1008,9 @@ CORBA_Any::operator<<= (from_wstring ws)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << ws;
+
       // If the inserted string is bounded, we create a typecode.
       static CORBA::Long _oc_wstring [] =
       {
@@ -1029,10 +1051,12 @@ CORBA_Any::operator<<= (from_wstring ws)
                    CORBA::WChar* (CORBA::wstring_dup (ws.val_)));
         }
 
-      this->replace (tc,
-                     tmp,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (tc,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          tmp,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -1440,17 +1464,8 @@ CORBA_Any::operator>>= (CORBA::Any &a) const
             {
               TAO_InputCDR stream (this->cdr_,
                                    this->byte_order_);
-              // decode the CDR
-              CORBA::TypeCode::traverse_status retval =
-                stream.decode (CORBA::_tc_any,
-                               &a,
-                               0,
-                               ACE_TRY_ENV);
-              ACE_TRY_CHECK;
-
-              return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-                                       ? 1
-                                       : 0);
+              if (stream >> a)
+                return 1;
             }
         }
       else
@@ -1475,55 +1490,37 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const
 
   ACE_TRY
     {
-      CORBA::Boolean result =
+      CORBA::Boolean equivalent =
         this->type_->equivalent (CORBA::_tc_any,
                                  ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      if (result)
+      if (!equivalent)
+        return 0;
+      if (this->any_owns_data_ && this->value_)
         {
-          if (this->any_owns_data_ && this->value_)
-            {
-              a = (CORBA::Any *) this->value_;
-              return 1;
-            }
-          else
-            {
-              ACE_NEW_RETURN (a,
-                              CORBA::Any,
-                              0);
-              TAO_InputCDR stream (this->cdr_,
-                                   this->byte_order_);
-              // decode the CDR
-              CORBA::TypeCode::traverse_status retval =
-                stream.decode (CORBA::_tc_any,
-                               a,
-                               0,
-                               ACE_TRY_ENV);
-              ACE_TRY_CHECK;
-
-              if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-                {
-                  return 1;
-                }
-              else
-                {
-                  delete ACE_const_cast (CORBA::Any *&, a);
-                  a = 0;
-                  return 0;
-                }
-            }
+          a = (CORBA::Any *) this->value_;
+          return 1;
         }
       else
         {
-          a = 0;
-          return 0;
+          ACE_NEW_RETURN (a,
+                          CORBA::Any,
+                          0);
+          TAO_InputCDR stream (this->cdr_,
+                               this->byte_order_);
+          if (stream >> *ACE_const_cast (CORBA::Any*&,a))
+            return 1;
+          delete ACE_const_cast (CORBA::Any *&, a);
         }
     }
   ACE_CATCHANY
     {
-      ACE_DEBUG ((LM_DEBUG,
-                  ASYS_TEXT ("Exception in CORBA::Any extraction\n")));
+      if (TAO_debug_level > 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      ASYS_TEXT ("Exception in CORBA::Any extraction\n")));
+        }
     }
   ACE_ENDTRY;
 
@@ -1814,15 +1811,8 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const
             {
               TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
                                    this->byte_order_);
-              CORBA::TypeCode::traverse_status retval =
-                stream.decode (CORBA::_tc_TypeCode,
-                               &tc,
-                               0,
-                               ACE_TRY_ENV);
-              ACE_TRY_CHECK;
-              return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-                                       ? 1
-                                       : 0);
+              if (stream >> tc)
+                return 1;
             }
         }
       else
@@ -2013,47 +2003,44 @@ CORBA_Any::operator>>= (to_string s) const
 
   ACE_TRY
     {
-      CORBA::Boolean result =
-        this->type_->equivalent (CORBA::_tc_string,
-                                 ACE_TRY_ENV);
+      CORBA::ULong kind =
+        this->type_->kind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      if (result)
+      CORBA::TypeCode_var tcvar =
+        CORBA::TypeCode::_duplicate (this->type_);
+
+      while (kind == CORBA::tk_alias)
         {
-          CORBA::ULong bound = this->type_->length (ACE_TRY_ENV);
+          tcvar = tcvar->content_type (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          kind = tcvar->kind (ACE_TRY_ENV);
           ACE_TRY_CHECK;
-          if (s.bound_ == bound) // bounds are same
-            {
-              if (this->any_owns_data_ && this->value_)
-                {
-                  s.val_ = *(char **) this->value_;
-                  return 1;
-                }
-              else
-                {
-                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
-                                   this->byte_order_);
-                  if (stream.read_string (s.val_))
-                    {
-                      ACE_const_cast (CORBA_Any *,
-                                      this)->any_owns_data_ = 1;
-                      return 1;
-                    }
-                  else
-                    {
-                      return 0;
-                    }
-                }
-            }
-          else
-            {
-              return 0;
-            }
         }
-      else
+
+      if (kind != CORBA::tk_string)
+        return 0;
+
+      CORBA::ULong bound = tcvar->length (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      if (s.bound_ != bound)
+        return 0;
+
+      if (this->any_owns_data_ && this->value_)
         {
-          return 0;
+          s.val_ = *(char **) this->value_;
+          return 1;
+        }
+
+      TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                           this->byte_order_);
+      if (stream.read_string (s.val_))
+        {
+          ACE_const_cast (CORBA_Any *,this)->any_owns_data_ = 1;
+          return 1;
         }
+      // FALLTHROUGH
     }
   ACE_CATCHANY
     {
@@ -2072,46 +2059,42 @@ CORBA_Any::operator>>= (to_wstring ws) const
 
   ACE_TRY
     {
-      CORBA::Boolean result =
-        this->type_->equivalent (CORBA::_tc_wstring,
-                                 ACE_TRY_ENV);
+      CORBA::ULong kind =
+        this->type_->kind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      if (result)
+      CORBA::TypeCode_var tcvar =
+        CORBA::TypeCode::_duplicate (this->type_);
+
+      while (kind == CORBA::tk_alias)
         {
-          CORBA::ULong bound = this->type_->length (ACE_TRY_ENV);
+          tcvar = tcvar->content_type (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          kind = tcvar->kind (ACE_TRY_ENV);
           ACE_TRY_CHECK;
-          if (ws.bound_ == bound) // bounds are same
-            {
-              if (this->any_owns_data_ && this->value_)
-                {
-                  ws.val_ = *(CORBA::WChar **) this->value_;
-                  return 1;
-                }
-              else
-                {
-                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
-                                   this->byte_order_);
-                  if (stream.read_wstring (ws.val_))
-                    {
-                      ACE_const_cast (CORBA_Any *,
-                                      this)->any_owns_data_ = 1;
-                      return 1;
-                    }
-                  else
-                    {
-                      return 0;
-                    }
-                }
-            }
-          else
-            {
-              return 0;
-            }
         }
-      else
+
+      if (kind != CORBA::tk_wstring)
+        return 0;
+
+      CORBA::ULong bound = tcvar->length (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      if (ws.bound_ != bound)
+        return 0;
+
+      if (this->any_owns_data_ && this->value_)
         {
-          return 0;
+          ws.val_ = *(CORBA::WChar **) this->value_;
+          return 1;
+        }
+
+      TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                           this->byte_order_);
+      if (stream.read_wstring (ws.val_))
+        {
+          ACE_const_cast (CORBA_Any *,this)->any_owns_data_ = 1;
+          return 1;
         }
     }
   ACE_CATCHANY
@@ -2131,40 +2114,43 @@ CORBA_Any::operator>>= (to_object obj) const
 
   ACE_TRY
     {
-      // Any interface is allowed
-      CORBA::Boolean result =
-        (this->type_->kind (ACE_TRY_ENV) == CORBA::tk_objref);
+      CORBA::ULong kind =
+        this->type_->kind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      if (result)
+      CORBA::TypeCode_var tcvar =
+        CORBA::TypeCode::_duplicate (this->type_);
+
+      while (kind == CORBA::tk_alias)
         {
-          if (this->any_owns_data_ && this->value_)
-            {
-              // CORBA 2.3 has changed the behavior of this operator. Caller
-              // is now responsible for release.
-              obj.ref_ =
-                CORBA::Object::_duplicate (*(CORBA::Object_ptr *) this->value_);
+          tcvar = tcvar->content_type (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
 
-              return 1;
-            }
-          else
-            {
-              // @@ This uses ORB_Core instance because we need one to
-              // demarshal objects (to create the right profiles for that
-              // object), but the Any does not belong to any ORB.
-              TAO_InputCDR stream (this->cdr_,
-                                   this->byte_order_,
-                                   TAO_ORB_Core_instance ());
+          kind = tcvar->kind (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+        }
 
-              int result = stream >> obj.ref_;
+      if (kind != CORBA::tk_objref)
+        return 0;
 
-              return !result;
-            }
-        }
-      else
+      if (this->any_owns_data_ && this->value_)
         {
-          return 0;
+          // CORBA 2.3 has changed the behavior of this operator. Caller
+          // is now responsible for release.
+          obj.ref_ =
+            CORBA::Object::_duplicate (*(CORBA::Object_ptr *)this->value_);
+          return 1;
         }
+
+      // @@ This uses ORB_Core instance because we need one to
+      // demarshal objects (to create the right profiles for that
+      // object), but the Any does not belong to any ORB.
+      TAO_InputCDR stream (this->cdr_,
+                           this->byte_order_,
+                           TAO_ORB_Core_instance ());
+
+      if (stream >> obj.ref_)
+        return 1;
     }
   ACE_CATCHANY
     {
@@ -2186,15 +2172,19 @@ CORBA_Any::operator<<= (const char* s)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << s;
       char **tmp;
 
       ACE_NEW (tmp,
                char * (CORBA::string_dup (s)));
 
-      this->replace (CORBA::_tc_string,
-                     tmp,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (CORBA::_tc_string,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          tmp,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -2214,15 +2204,19 @@ CORBA_Any::operator<<= (const CORBA::WChar* s)
 
   ACE_TRY
     {
+      TAO_OutputCDR stream;
+      stream << s;
       CORBA::WChar **tmp;
 
       ACE_NEW (tmp,
                CORBA::WChar * (CORBA::wstring_dup (s)));
 
-      this->replace (CORBA::_tc_wstring,
-                     tmp,
-                     1,
-                     ACE_TRY_ENV);
+      this->_tao_replace (CORBA::_tc_wstring,
+                          TAO_ENCAP_BYTE_ORDER,
+                          stream.begin (),
+                          1,
+                          tmp,
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -2238,46 +2232,71 @@ CORBA::Boolean
 operator<< (TAO_OutputCDR& cdr,
             const CORBA::Any &x)
 {
-  // @@ This function should *not* use the interpreter, there must be
-  // a way to do this with just CDR operations!!!!
+  if (!(cdr << x.type ()))
+    return 0;
+
   ACE_TRY_NEW_ENV
     {
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_ANY::instance ()->encode (0,
-                                              &x,
-                                              0,
-                                              &cdr,
-                                              ACE_TRY_ENV);
+      TAO_InputCDR input (x._tao_get_cdr (),
+                          x._tao_byte_order ());
+      cdr.append (x.type (),
+                  &input,
+                  ACE_TRY_ENV);
       ACE_TRY_CHECK;
-
-      if (status== CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 1;
-      // else return 0 at the end of the function
     }
   ACE_CATCH (CORBA_Exception, ex)
     {
       return 0;
     }
   ACE_ENDTRY;
-  return 0;
+  return 1;
 }
 
 CORBA::Boolean
 operator>> (TAO_InputCDR &cdr,
             CORBA::Any &x)
 {
+  CORBA::TypeCode_var tc;
+  if (!(cdr >> tc.out ()))
+    return 0;
+
   ACE_TRY_NEW_ENV
     {
+      // @@ (JP) The following code depends on the fact that
+      //         TAO_InputCDR does not contain chained message blocks,
+      //         otherwise <begin> and <end> could be part of
+      //         different buffers!
+
+      // This will be the start of a new message block.
+      char *begin = cdr.rd_ptr ();
+
+      // Skip over the next aregument.
       CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_ANY::instance ()->decode (0,
-                                              &x,
-                                              0,
-                                              &cdr,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
+        cdr.skip (tc.in (), ACE_TRY_ENV);
+      ACE_CHECK;
 
       if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 0;
+        {
+          ACE_THROW (CORBA::MARSHAL ());
+        }
+
+      // This will be the end of the new message block.
+      char *end = cdr.rd_ptr ();
+
+      size_t size = end - begin;
+      ACE_Message_Block mb (size + ACE_CDR::MAX_ALIGNMENT);
+      ACE_CDR::mb_align (&mb);
+      ptr_arith_t offset = ptr_arith_t (begin) % ACE_CDR::MAX_ALIGNMENT;
+      mb.rd_ptr (offset);
+      mb.wr_ptr (offset + size);
+      ACE_OS::memcpy (mb.rd_ptr (), begin, size);
+
+      // Stick it into the Any. It gets duplicated there.
+      x._tao_replace (tc.in (),
+                      cdr.byte_order (),
+                      &mb,
+                      ACE_TRY_ENV);
+      ACE_CHECK;
     }
   ACE_CATCH (CORBA_Exception, ex)
     {
diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h
index 88a1d32f043..a7e719ef13e 100644
--- a/TAO/tao/Any.h
+++ b/TAO/tao/Any.h
@@ -74,9 +74,9 @@ public:
   // Default constructor.
 
   CORBA_Any (CORBA::TypeCode_ptr type,
-             void *value = 0,
-             CORBA::Boolean any_owns_data = 0);
-  // Constructor. The any_owns_data flag determines if the Any owns the value
+             CORBA::Environment &ACE_TRY_ENV
+                 = TAO_default_environment ());
+  // Constructor.
 
   // = TAO extension
   CORBA_Any (CORBA::TypeCode_ptr type,
@@ -278,20 +278,31 @@ public:
   // ORBOS/90-01-11, pg 672: For C++ mapping using the CORBA_Environment
   // parameter, two forms of the replace method are provided.
 
+#if 0
+  CORBA_Any (CORBA::TypeCode_ptr type,
+             void *value,
+             CORBA::Boolean any_owns_data,
+             CORBA::Environment &ACE_TRY_ENV
+                 = TAO_default_environment ());
+  CORBA_Any (CORBA::TypeCode_ptr type,
+             void *value,
+             CORBA::Environment &ACE_TRY_ENV
+                = TAO_default_environment ());
+  // Obsolete. Raises CORBA::NO_IMPLEMENT.
+
   void replace (CORBA::TypeCode_ptr type,
                 const void *value,
                 CORBA::Boolean any_owns_data,
                 CORBA_Environment &ACE_TRY_ENV =
                   TAO_default_environment ());
-  // Replace the current typecode and data with the specified one -
-  // unsafe.
+  // Obsolete. Raises CORBA::NO_IMPLEMENT.
 
   void replace (CORBA::TypeCode_ptr type,
                 const void *value,
                 CORBA_Environment &ACE_TRY_ENV =
                   TAO_default_environment ());
-  // Replace the current typecode and data with the specified one -
-  // unsafe. This uses a default value for the "any_owns_data" parameter
+  // Obsolete. Raises CORBA::NO_IMPLEMENT.
+#endif
 
   CORBA::TypeCode_ptr type (void) const;
   // Return TypeCode of the element stored in the Any.
diff --git a/TAO/tao/Any.i b/TAO/tao/Any.i
index 370cd09cafa..1c709977d11 100644
--- a/TAO/tao/Any.i
+++ b/TAO/tao/Any.i
@@ -3,20 +3,6 @@
 
 // Insertion from special types.
 
-ACE_INLINE
-void
-CORBA_Any::replace (CORBA::TypeCode_ptr type,
-                    const void *value,
-                    CORBA::Environment &ACE_TRY_ENV)
-{
-  // Invoke the first form of the replace method and pass the default
-  // value (FALSE) for the "any_owns_data" parameter
-  this->replace (type,
-                 value,
-                 0,
-                 ACE_TRY_ENV);
-}
-
 ACE_INLINE CORBA::Boolean
 CORBA_Any::any_owns_data (void) const
 {
diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp
index eb573600bd1..9fd40aa7df2 100644
--- a/TAO/tao/BoundsC.cpp
+++ b/TAO/tao/BoundsC.cpp
@@ -85,7 +85,7 @@ CORBA::Exception *CORBA_Bounds::_alloc (void)
 
 
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem)
 {
   CORBA::Bounds *_tao_any_val = 0;
   ACE_NEW (_tao_any_val,
@@ -93,7 +93,14 @@ void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copyi
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_Bounds, _tao_any_val, 1, ACE_TRY_ENV);
+    TAO_OutputCDR stream;
+    stream << *_tao_any_val;
+    _tao_any._tao_replace (CORBA::_tc_Bounds,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_any_val,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY
@@ -107,7 +114,14 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Bounds *_tao_elem) // non copying
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV); // consume it
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+    _tao_any._tao_replace (CORBA::_tc_Bounds,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_elem,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY {}
@@ -129,24 +143,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Bounds *&_tao_ele
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA::Bounds, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
-                           _tao_any._tao_byte_order ());
-      if (stream.decode (CORBA::_tc_Bounds, _tao_elem, 0, ACE_TRY_ENV)
-        == CORBA::TypeCode::TRAVERSE_CONTINUE)
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ());
+      if (stream >> *_tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV);
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_Bounds,
+            1,
+            ACE_reinterpret_cast (void*, _tao_elem),
+            ACE_TRY_ENV);
         ACE_TRY_CHECK;
         return 1;
       }
       else
       {
         delete _tao_elem;
+        _tao_elem = 0;
       }
     }
   }
   ACE_CATCHANY
   {
     delete _tao_elem;
+    _tao_elem = 0;
     return 0;
   }
   ACE_ENDTRY;
diff --git a/TAO/tao/BoundsC.h b/TAO/tao/BoundsC.h
index 88c4c544276..7be65208973 100644
--- a/TAO/tao/BoundsC.h
+++ b/TAO/tao/BoundsC.h
@@ -11,6 +11,9 @@
 #define _TAO_IDL_BOUNDSC_H_
 
 #include "tao/corbafwd.h"
+#include "tao/Exception.h"
+#include "tao/CDR.h"
+#include "tao/Any.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
diff --git a/TAO/tao/CDR.cpp b/TAO/tao/CDR.cpp
index 3755ec6ffe6..4a6f6405cec 100644
--- a/TAO/tao/CDR.cpp
+++ b/TAO/tao/CDR.cpp
@@ -124,27 +124,6 @@ TAO_OutputCDR::TAO_OutputCDR (ACE_Message_Block *data,
 }
 
 CORBA::TypeCode::traverse_status
-TAO_OutputCDR::encode (CORBA::TypeCode_ptr tc,
-                       const void *data,
-                       const void *data2,
-                       CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Marshal_Object *mobj =
-    TAO_MARSHAL_FACTORY::instance ()->make_marshal_object
-    (tc, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-
-  if (!mobj)
-    return CORBA::TypeCode::TRAVERSE_STOP;
-
-  return mobj->encode (tc,
-                       data,
-                       data2,
-                       this,
-                       ACE_TRY_ENV);
-}
-
-CORBA::TypeCode::traverse_status
 TAO_OutputCDR::append (CORBA::TypeCode_ptr tc,
                        TAO_InputCDR *src,
                        CORBA::Environment &ACE_TRY_ENV)
@@ -190,28 +169,6 @@ TAO_InputCDR::init_translators (void)
 }
 
 CORBA::TypeCode::traverse_status
-TAO_InputCDR::decode (CORBA::TypeCode_ptr tc,
-                      const void *data,
-                      const void *data2,
-                      CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Marshal_Object *mobj =
-    TAO_MARSHAL_FACTORY::instance ()->make_marshal_object
-    (tc, ACE_TRY_ENV);
-
-  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-
-  if (!mobj)
-    return CORBA::TypeCode::TRAVERSE_STOP;
-
-  return mobj->decode (tc,
-                       data,
-                       data2,
-                       this,
-                       ACE_TRY_ENV);
-}
-
-CORBA::TypeCode::traverse_status
 TAO_InputCDR::skip (CORBA::TypeCode_ptr tc,
                     CORBA::Environment &ACE_TRY_ENV)
 {
diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h
index 45f7ab8c271..a76f387ef4a 100644
--- a/TAO/tao/CDR.h
+++ b/TAO/tao/CDR.h
@@ -128,14 +128,6 @@ public:
 
   // = TAO specific methods.
 
-  CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                           const void *data,
-                                           const void *,
-                                           CORBA_Environment &ACE_TRY_ENV =
-                                           TAO_default_environment ());
-  // Marshalls the contents of <data> as described by the TypeCode in
-  // <tc>. Any errors are reported though the <ACE_TRY_ENV> parameter.
-
 private:
   TAO_OutputCDR (const TAO_OutputCDR& rhs);
   TAO_OutputCDR& operator= (const TAO_OutputCDR& rhs);
@@ -225,14 +217,6 @@ public:
 
   // = TAO specific methods.
 
-  CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                           const void *data,
-                                           const void *,
-                                           CORBA_Environment &ACE_TRY_ENV =
-                                           TAO_default_environment ());
-  // Demarshall the contents of the CDR stream into <data> as
-  // described by <tc>; returning any errors in <ACE_TRY_ENV>.
-
   CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc,
                                          CORBA_Environment &ACE_TRY_ENV =
                                          TAO_default_environment ());
diff --git a/TAO/tao/DynAny_i.cpp b/TAO/tao/DynAny_i.cpp
index 31e4c676080..5c4a8249545 100644
--- a/TAO/tao/DynAny_i.cpp
+++ b/TAO/tao/DynAny_i.cpp
@@ -431,10 +431,14 @@ TAO_DynAny_i::insert_reference (CORBA::Object_ptr value,
 
       *_tao_object_ptr = CORBA::Object::_duplicate (value);
 
-      this->value_.replace (this->value_.type (),
-                            (void*)_tao_object_ptr,
-                            1,
-                            ACE_TRY_ENV);
+      TAO_OutputCDR stream;
+      stream << *_tao_object_ptr;
+      this->value_._tao_replace (this->value_.type (),
+                                 TAO_ENCAP_BYTE_ORDER,
+                                 stream.begin (),
+                                 1,
+                                 (void*)_tao_object_ptr,
+                                 ACE_TRY_ENV);
       ACE_CHECK;
     }
   else
diff --git a/TAO/tao/Exception.cpp b/TAO/tao/Exception.cpp
index 5525bad34a6..2fdf002a071 100644
--- a/TAO/tao/Exception.cpp
+++ b/TAO/tao/Exception.cpp
@@ -661,22 +661,20 @@ TAO_Exceptions::make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp,
     || stream.write_string (interface_id) == 0
     || stream.write_string (name) == 0
     || stream.write_ulong (1L) == 0
-    || stream.write_string (field_name) == 0
-    || stream.encode (CORBA::_tc_TypeCode,
-                      &CORBA::_tc_any, 0,
-                      ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE;
-  ACE_CHECK;
-
+    || stream.write_string (field_name) == 0;
   if (result)
     ACE_THROW (CORBA_INITIALIZE ());
 
+  if (!(stream << CORBA::_tc_any))
+    ACE_THROW (CORBA_INITIALIZE ());
+
   ACE_NEW_THROW_EX (tcp,
                     CORBA::TypeCode (CORBA::tk_except,
                                      stream.length (),
                                      stream.buffer (),
                                      1,
                                      sizeof (CORBA_UserException)),
-                    CORBA_NO_MEMORY ());
+                    CORBA_INITIALIZE ());
 }
 
 void
@@ -737,19 +735,14 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp,
     || stream.write_string (full_id) == 0
     || stream.write_string (name) == 0
     || stream.write_ulong (2L) != 1
-    || stream.write_string (minor) == 0
-    || stream.encode (CORBA::_tc_TypeCode,
-                      &CORBA::_tc_ulong, 0,
-                      ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE;
-  ACE_CHECK; // @@ Maybe we should transform this exception
+    || stream.write_string (minor) == 0;
+
+  result = result || !(stream << CORBA::_tc_ulong);
 
   CORBA::string_free (full_id);  // No longer need the string
 
-  result = result || stream.write_string (completed) == 0
-    || stream.encode (CORBA::_tc_TypeCode,
-                      &TC_completion_status, 0,
-                      ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE;
-  ACE_CHECK; // @@ Maybe we should transform this exception
+  result = result || stream.write_string (completed) == 0;
+  result = result || !(stream << TC_completion_status);
 
   if (result)
     ACE_THROW (CORBA::INITIALIZE ());
@@ -768,7 +761,7 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp,
                                      stream.buffer (),
                                      1,
                                      sizeof (CORBA_SystemException)),
-                    CORBA_NO_MEMORY ());
+                    CORBA_INITIALIZE ());
   ACE_CHECK;
 
   TAO_Exceptions::system_exceptions->add (tcp);
diff --git a/TAO/tao/Forwarding_Servant.cpp b/TAO/tao/Forwarding_Servant.cpp
index bd2ae762d23..54f7e33fc33 100644
--- a/TAO/tao/Forwarding_Servant.cpp
+++ b/TAO/tao/Forwarding_Servant.cpp
@@ -22,19 +22,12 @@ void
 TAO_Forwarding_Servant::invoke (CORBA::ServerRequest_ptr request,
                                 CORBA::Environment &ACE_TRY_ENV)
 {
-  ACE_UNUSED_ARG (request);
+  PortableServer::ForwardRequest exception (this->forward_to_.in ());
 
-  CORBA::Exception *exception = 0;
-  ACE_NEW_THROW_EX (exception,
-                    PortableServer::ForwardRequest (this->forward_to_.in ()),
-                    CORBA::NO_MEMORY ());
+  CORBA::Any any;
+  any <<= exception;
 
-  CORBA::Any any (exception->_type (),
-                  exception,
-                  1);
-
-  request->set_exception (any,
-                          ACE_TRY_ENV);
+  request->set_exception (any, ACE_TRY_ENV);
 }
 
 CORBA::RepositoryId
diff --git a/TAO/tao/GIOP_Server_Request.cpp b/TAO/tao/GIOP_Server_Request.cpp
index 5bd45d6e149..ea277537627 100644
--- a/TAO/tao/GIOP_Server_Request.cpp
+++ b/TAO/tao/GIOP_Server_Request.cpp
@@ -413,9 +413,9 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV)
           CORBA::TypeCode_var tc = this->retval_->type ();
                 if (this->retval_->any_owns_data ())
             {
-              (void) this->outgoing_->encode (tc.in (),
-                                              retval_->value (),
-                                              0, ACE_TRY_ENV);
+              this->retval_->_tao_encode (*this->outgoing_,
+                                          this->orb_core_,
+                                          ACE_TRY_ENV);
               ACE_CHECK;
             }
           else
@@ -442,132 +442,6 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV)
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-// Extension
-void
-TAO_GIOP_ServerRequest::demarshal (CORBA::Environment &ACE_TRY_ENV,
-                                   // ORB related exception reporting
-                                   const TAO_Call_Data_Skel *info,
-                                   // call description
-                                   ...)
-{
-  CORBA::ULong i;
-  const TAO_Param_Data_Skel *pdp;
-  va_list param_vector;
-  va_start (param_vector, info);
-
-  for (i = 0, pdp = info->params;
-       i < info->param_count;
-       i++, pdp++)
-    {
-      void *ptr = va_arg (param_vector, void *);
-
-      if ((pdp->mode == CORBA::ARG_IN)
-          || (pdp->mode == CORBA::ARG_INOUT))
-        {
-          // Then just unmarshal the value.
-          (void) incoming_->decode (pdp->tc, ptr, 0, ACE_TRY_ENV);
-          ACE_CHECK;
-        }
-    }
-  va_end (param_vector);
-}
-
-// Extension
-
-void
-TAO_GIOP_ServerRequest::marshal (CORBA::Environment &ACE_TRY_ENV,
-                                 // ORB related exception reporting
-                                 //                             CORBA::Environment &skel_env,
-                                 // skeleton related exception reporting
-                                 const TAO_Call_Data_Skel *info,
-                                 // call description
-                                 ...)
-{
-  // what is "ACE_TRY_ENV" and "skel_env"?
-  // "skel_env" holds the exception that got raised inside the operation
-  // implementation (upcall)
-  //
-  // "orb_env" is the exception that may have been raised due to things going
-  // wrong in the entire dispatch process. These are always system exceptions.
-
-  // check if we are inside with an exception. This may have happened
-  // since the upcall could have set some exception
-#if 0 /* ASG */
-  if (skel_env.exception ())
-    {
-      // We must increase the "refcnt" on the exception, because it is
-      // "owned" by both <skel_env> and (eventually) by the
-      // Server_Request.
-      CORBA::Exception_ptr exception = skel_env.exception ();
-      exception->_incr_refcnt ();
-
-      // The Any does not own the because ultimately it will be owned
-      // by the Server_Request via the call to "set_exception"
-      CORBA::Any any (skel_env.exception ()->_type (), exception);
-      this->set_exception (any, ACE_TRY_ENV);
-    }
-#endif
-
-  // Setup a Reply message so that we can marshal all the outgoing parameters
-  // into it. If an exception was set, then that gets marshaled into the reply
-  // message and we don't do anything after that
-  this->init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-
-#if 0 /* ASG */
-  // exception? nothing to do after this
-  if (orb_env.exception () || skel_env.exception ())
-    return;
-  ACE_CHECK;
-#endif
-
-  CORBA::ULong i;
-  const TAO_Param_Data_Skel *pdp;
-  va_list param_vector;
-  va_start (param_vector, info);
-
-  ACE_TRY
-    {
-      for (i = 0, pdp = info->params;
-           i < info->param_count;
-           i++, pdp++)
-        {
-          void *ptr = va_arg (param_vector, void *);
-
-          if (pdp->mode == 0)
-            {
-              // check if the return type is not void
-              CORBA::TCKind result = pdp->tc->kind (ACE_TRY_ENV);
-              ACE_TRY_CHECK;
-              if (result != CORBA::tk_void)
-                {
-                  // Then just marshal the value.
-                  (void) this->outgoing_->encode (pdp->tc, ptr, 0,
-                                                  ACE_TRY_ENV);
-                  ACE_TRY_CHECK;
-                }
-            }
-          else if ((pdp->mode == CORBA::ARG_INOUT)
-                   || (pdp->mode == CORBA::ARG_OUT))
-            {
-              // Then just marshal the value.
-              (void) this->outgoing_->encode (pdp->tc, ptr, 0, ACE_TRY_ENV);
-              ACE_TRY_CHECK;
-            }
-        }
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "TAO_GIOP_ServerRequest::marshal - parameter encode failed");
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-
-  va_end (param_vector);
-}
-
 void
 TAO_GIOP_ServerRequest::init_reply (CORBA::Environment &ACE_TRY_ENV)
 {
diff --git a/TAO/tao/GIOP_Server_Request.h b/TAO/tao/GIOP_Server_Request.h
index c389c88ebe5..8dd5e4f79d5 100644
--- a/TAO/tao/GIOP_Server_Request.h
+++ b/TAO/tao/GIOP_Server_Request.h
@@ -101,19 +101,6 @@ public:
   // meant to be used internally.
   //
 
-  virtual void demarshal (CORBA_Environment &ACE_TRY_ENV,
-                          const TAO_Call_Data_Skel *info,
-                          ...);
-  // demarshal incoming parameters. Used by the SII skeleton (i.e., the IDL
-  // compiler generated skeleton)
-
-  virtual void marshal (CORBA_Environment &ACE_TRY_ENV,
-                        //                        CORBA_Environment &skel_env,
-                        const TAO_Call_Data_Skel *info,
-                        ...);
-  // marshal outgoing parameters and return value. This is used by the SSI
-  // i.e., by the IDL compiler generated skeletons.
-
   virtual void init_reply (CORBA_Environment &ACE_TRY_ENV =
                                TAO_default_environment ());
   // start a Reply message
diff --git a/TAO/tao/IIOP_Profile.cpp b/TAO/tao/IIOP_Profile.cpp
index 24e23372347..021abe01416 100644
--- a/TAO/tao/IIOP_Profile.cpp
+++ b/TAO/tao/IIOP_Profile.cpp
@@ -183,7 +183,7 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr)
       return -1;
     }
 
-  if (this->object_addr_.set (this->port_, 
+  if (this->object_addr_.set (this->port_,
                               this->host_.in ()) == -1)
     {
       if (TAO_debug_level > 0)
@@ -312,7 +312,7 @@ TAO_IIOP_Profile::parse_string (const char *string,
 
   this->host_ = tmp._retn ();
 
-  if (this->object_addr_.set (this->port_, 
+  if (this->object_addr_.set (this->port_,
                               this->host_.in ()) == -1)
     {
       if (TAO_debug_level > 0)
@@ -410,7 +410,7 @@ TAO_IIOP_Profile::operator= (const TAO_IIOP_Profile &src)
   this->version_ = src.version_;
 
   this->object_key_ = src.object_key_;
-  
+
   this->object_addr_.set (src.object_addr_);
 
   this->port_ = src.port_;
diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp
index e7e03d1a227..e24062fb279 100644
--- a/TAO/tao/Invocation.cpp
+++ b/TAO/tao/Invocation.cpp
@@ -438,8 +438,7 @@ TAO_GIOP_Invocation::close_connection (void)
 }
 
 // Handle the GIOP Reply with status = LOCATION_FORWARD
-// Replace the IIOP Profile. The call is then automatically
-// reinvoked by the TAO_Stub::do_static_call method.
+// Replace the IIOP Profile.
 
 int
 TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h
index b843567904f..2240d2a3401 100644
--- a/TAO/tao/Invocation.h
+++ b/TAO/tao/Invocation.h
@@ -223,7 +223,7 @@ public:
               CORBA_Environment &ACE_TRY_ENV =
                 TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::Exception));
-  // Special purpose invoke method used by the interpretive stubs. This
+  // Special purpose invoke method used by the generated stubs. This
   // accomplishes the same task as the normal invoke except that
   // Exceptions are allocated and decoded here. This reduces the
   // footprint of the generated stubs.
diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile
index e76853d9e4f..e1800e95f0c 100644
--- a/TAO/tao/Makefile
+++ b/TAO/tao/Makefile
@@ -102,9 +102,7 @@ DEFAULT_RESOURCES_FILES = \
 
 INTERPRETIVE_MARSHALING_FILES = \
   append \
-  decode \
   deep_free \
-  encode \
   CDR_Interpreter \
   Marshal \
   skip
@@ -175,6 +173,7 @@ ORB_CORE_FILES = \
   CONV_FRAMES \
   Tagged_Components \
   GIOPC \
+  BoundsC \
   TAOC \
   TAOS
 
diff --git a/TAO/tao/Marshal.h b/TAO/tao/Marshal.h
index ab4ea402a28..611c5e9e127 100644
--- a/TAO/tao/Marshal.h
+++ b/TAO/tao/Marshal.h
@@ -35,12 +35,6 @@ class TAO_OutputCDR;
 class TAO_InputCDR;
 
 CORBA::TypeCode::traverse_status
-DEEP_COPY (CORBA::TypeCode_ptr  param,
-           const void *source,
-           const void *dest,
-           CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-
-CORBA::TypeCode::traverse_status
 DEEP_FREE (CORBA::TypeCode_ptr  param,
            const void *source,
            const void *dest,
@@ -117,20 +111,6 @@ class TAO_Export TAO_Marshal_Object
   //    Provides a set of virtual methods for encoding, decoding
   //    and deep_freeing.
 public:
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
-  // encoding operation
-
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
-  // decoding operation
-
   virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc,
                                                  void *context,
                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
@@ -160,16 +140,6 @@ public:
 
   virtual ~TAO_Marshal_Primitive (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -198,16 +168,6 @@ public:
 
   virtual ~TAO_Marshal_Any (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *source,
                                                   const void *,
@@ -236,16 +196,6 @@ public:
 
   virtual ~TAO_Marshal_TypeCode (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -274,16 +224,6 @@ public:
 
   virtual ~TAO_Marshal_Principal (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -312,16 +252,6 @@ public:
 
   virtual ~TAO_Marshal_ObjRef (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -350,16 +280,6 @@ public:
 
   virtual ~TAO_Marshal_Struct (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -388,16 +308,6 @@ public:
 
   virtual ~TAO_Marshal_Union (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -426,16 +336,6 @@ public:
 
   virtual ~TAO_Marshal_String (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -464,16 +364,6 @@ public:
 
   virtual ~TAO_Marshal_Sequence (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -502,16 +392,6 @@ public:
 
   virtual ~TAO_Marshal_Array (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -540,16 +420,6 @@ public:
 
   virtual ~TAO_Marshal_Alias (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -577,16 +447,6 @@ public:
   TAO_Marshal_Except (void);
   ~TAO_Marshal_Except (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
@@ -614,16 +474,6 @@ public:
   TAO_Marshal_WString (void);
   ~TAO_Marshal_WString (void);
 
-  virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
-  virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc,
-                                                  const void *data,
-                                                  const void *parent_typecode,
-                                                  void *context,
-                                                  CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
   static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc,
                                                   const void *data,
                                                   const void *,
diff --git a/TAO/tao/MessagingS.cpp b/TAO/tao/MessagingS.cpp
index b177dca761f..608e0fbc22c 100644
--- a/TAO/tao/MessagingS.cpp
+++ b/TAO/tao/MessagingS.cpp
@@ -2179,37 +2179,27 @@ void POA_Messaging::Poller::_get_op_name_skel (
 }
 
 void POA_Messaging::Poller::_is_a_skel (
-                                        CORBA::ServerRequest &_tao_server_request,
-                                        void * _tao_object_reference,
-                                        void * /*context*/,
-                                        CORBA::Environment &ACE_TRY_ENV
-                                        )
+  CORBA::ServerRequest &_tao_server_request,
+  void * _tao_object_reference,
+  void * /*context*/,
+  CORBA::Environment &ACE_TRY_ENV
+  )
 {
-  static const TAO_Param_Data_Skel Messaging_Poller_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel Messaging_Poller_is_a_calldata =
-  {"_is_a", 1, 2, Messaging_Poller_is_a_paramdata};
-  POA_Messaging::Poller_ptr  _tao_impl = (POA_Messaging::Poller_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-                                 ACE_TRY_ENV,
-                                 &Messaging_Poller_is_a_calldata,
-                                 &_tao_retval,
-                                 &_tao_value.inout ()
-                                 );
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_Messaging::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-                               ACE_TRY_ENV,
-                               &Messaging_Poller_is_a_calldata,
-                               &_tao_retval,
-                               &_tao_value.inout ()
-                               );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 CORBA::Boolean POA_Messaging::Poller::_is_a (
@@ -2227,24 +2217,21 @@ CORBA::Boolean POA_Messaging::Poller::_is_a (
 }
 
 void POA_Messaging::Poller::_non_existent_skel (
-                                                CORBA::ServerRequest &_tao_server_request,
-                                                void * /* _tao_object_reference */ ,
-                                                void * /*context*/,
-                                                CORBA::Environment &ACE_TRY_ENV
-                                                )
+  CORBA::ServerRequest &_tao_server_request,
+  void * _tao_object_reference ,
+  void * /*context*/,
+  CORBA::Environment &ACE_TRY_ENV
+  )
 {
-  static const TAO_Param_Data_Skel Messaging_Poller_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel Messaging_Poller_non_existent_calldata =
-  {"_non_existent", 1, 1, Messaging_Poller_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-                               ACE_TRY_ENV,
-                               &Messaging_Poller_non_existent_calldata,
-                               &_tao_retval
-                               );
+  POA_MessagingCORBA::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void* POA_Messaging::Poller::_downcast (
diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp
index 90baedd7f5b..2f0d49fd49a 100644
--- a/TAO/tao/NVList.cpp
+++ b/TAO/tao/NVList.cpp
@@ -9,6 +9,7 @@
 #include "tao/Exception.h"
 #include "tao/Environment.h"
 #include "tao/ORB.h"
+#include "tao/BoundsC.h"
 #include "tao/debug.h"
 #include "ace/Auto_Ptr.h"
 
@@ -148,20 +149,10 @@ CORBA_NVList::add_value (const char *name,
           // The normal behaviour for parameters is that the ORB "borrows"
           // their memory for the duration of calls.
           //
-          if (value.value_)
-            {
-              nv->any_.replace (value.type_,
-                                value.value_,
-                                0,
-                                ACE_TRY_ENV);
-            }
-          else
-            {
-              nv->any_._tao_replace (value.type_,
-                                     value.byte_order_,
-                                     value.cdr_,
-                                     ACE_TRY_ENV);
-            }
+          nv->any_._tao_replace (value.type_,
+                                 value.byte_order_,
+                                 value.cdr_,
+                                 ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
         }
       return nv;
@@ -265,7 +256,7 @@ CORBA_NVList::item (CORBA::ULong n, CORBA::Environment &ACE_TRY_ENV)
   ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
 
   if (n >= this->max_) // 0 based indexing
-    ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0);
+    ACE_THROW_RETURN (CORBA::Bounds (), 0);
 
   CORBA::NamedValue_ptr *nv;
 
diff --git a/TAO/tao/ObjectIDList.cpp b/TAO/tao/ObjectIDList.cpp
index 4432a72ec46..4a728f5a377 100644
--- a/TAO/tao/ObjectIDList.cpp
+++ b/TAO/tao/ObjectIDList.cpp
@@ -91,7 +91,15 @@ void operator<<= (
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_any_val, 1, ACE_TRY_ENV); // copy the value
+    TAO_OutputCDR stream;
+    stream << _tao_elem;
+
+    _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_any_val,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY
@@ -135,11 +143,23 @@ operator>> (TAO_InputCDR &strm, CORBA_ORB_ObjectIdList &_tao_sequence)
   return 0; // error
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV);
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+
+    CORBA_ORB_ObjectIdList *_tao_copy;
+    ACE_NEW (_tao_copy,
+             CORBA_ORB_ObjectIdList (*_tao_elem));
+
+    _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_copy,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY {}
@@ -163,10 +183,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *
       ACE_NEW_RETURN (_tao_elem, CORBA_ORB_ObjectIdList, 0);
       TAO_InputCDR stream (_tao_any._tao_get_cdr (),
                            _tao_any._tao_byte_order ());
-      if (stream.decode (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV)
-        == CORBA::TypeCode::TRAVERSE_CONTINUE)
+      if (stream >> *_tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 1, ACE_TRY_ENV);
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::ORB::_tc_ObjectIdList,
+            1,
+            _tao_elem,
+            ACE_TRY_ENV);
         ACE_TRY_CHECK;
         return 1;
       }
diff --git a/TAO/tao/ObjectIDList.h b/TAO/tao/ObjectIDList.h
index 514fdcba836..4f4040c5200 100644
--- a/TAO/tao/ObjectIDList.h
+++ b/TAO/tao/ObjectIDList.h
@@ -126,14 +126,9 @@ private:
 
 #endif /* end #if !defined */
 
-#ifndef __ACE_INLINE__
-
 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ORB_ObjectIdList &); //
 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ORB_ObjectIdList &);
 
-#endif /* __ACE_INLINE__ */
-
-
 #if defined (__ACE_INLINE__)
 #include "tao/ObjectIDList.i"
 #endif /* defined INLINE */
diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp
index 8f7c0a234fc..7fd3b87d13e 100644
--- a/TAO/tao/POAC.cpp
+++ b/TAO/tao/POAC.cpp
@@ -164,7 +164,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_t
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -240,7 +240,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -291,7 +291,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo
   {
     delete ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3217,7 +3217,7 @@ void operator<<= (
           _tao_any_val,
           ACE_TRY_ENV
         );
-      ACE_TRY_CHECK; 
+      ACE_TRY_CHECK;
     }
     else
     {
@@ -3300,7 +3300,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ObjectId
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3351,7 +3351,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Ob
   {
     delete ACE_const_cast (PortableServer::ObjectId *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3424,7 +3424,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ThreadPolicy_ptr _tao_el
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ThreadPolicy, 
+          PortableServer::_tc_ThreadPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -3561,7 +3561,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicy_ptr _tao_
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_LifespanPolicy, 
+          PortableServer::_tc_LifespanPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -3696,7 +3696,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicy_ptr _
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_IdUniquenessPolicy, 
+          PortableServer::_tc_IdUniquenessPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -3831,7 +3831,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicy_ptr _
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_IdAssignmentPolicy, 
+          PortableServer::_tc_IdAssignmentPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -3968,7 +3968,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicy
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ImplicitActivationPolicy, 
+          PortableServer::_tc_ImplicitActivationPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -4103,7 +4103,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicy_p
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ServantRetentionPolicy, 
+          PortableServer::_tc_ServantRetentionPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -4238,7 +4238,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicy_
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_RequestProcessingPolicy, 
+          PortableServer::_tc_RequestProcessingPolicy,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -4329,7 +4329,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterAlread
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -4405,7 +4405,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4456,7 +4456,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4483,7 +4483,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterInacti
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -4559,7 +4559,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4610,7 +4610,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4637,7 +4637,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterNonExi
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -4713,7 +4713,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4764,7 +4764,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4789,7 +4789,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::InvalidPolicy
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -4865,7 +4865,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Inv
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4916,7 +4916,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -4943,7 +4943,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::NoServant &_t
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5019,7 +5019,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::NoS
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5070,7 +5070,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5097,7 +5097,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlready
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5173,7 +5173,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5224,7 +5224,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5249,7 +5249,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActi
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5325,7 +5325,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5376,7 +5376,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5401,7 +5401,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantAlread
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5477,7 +5477,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5528,7 +5528,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5553,7 +5553,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantNotAct
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5629,7 +5629,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5680,7 +5680,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5705,7 +5705,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5781,7 +5781,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5832,7 +5832,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5857,7 +5857,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy &
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -5933,7 +5933,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -5984,7 +5984,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -6009,7 +6009,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::Current::NoContext
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -6085,7 +6085,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current:
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -6136,7 +6136,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Cu
   {
     delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -6153,7 +6153,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::Current_ptr _tao_elem)
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_Current, 
+          PortableServer::_tc_Current,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6234,7 +6234,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager_ptr _tao_elem
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_POAManager, 
+          PortableServer::_tc_POAManager,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6377,7 +6377,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POAManager::Adapte
       );
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -6453,7 +6453,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag
   {
     delete _tao_elem;
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -6504,7 +6504,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO
   {
     delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem);
     _tao_elem = 0;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -6523,7 +6523,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::AdapterActivator_ptr _ta
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_AdapterActivator, 
+          PortableServer::_tc_AdapterActivator,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6604,7 +6604,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantLocator_ptr _tao_
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ServantLocator, 
+          PortableServer::_tc_ServantLocator,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6685,7 +6685,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantManager_ptr _tao_
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ServantManager, 
+          PortableServer::_tc_ServantManager,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6766,7 +6766,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantActivator_ptr _ta
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_ServantActivator, 
+          PortableServer::_tc_ServantActivator,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6849,7 +6849,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA_ptr _tao_elem)
     if (stream << *_tao_obj_ptr)
     {
       _tao_any._tao_replace (
-          PortableServer::_tc_POA, 
+          PortableServer::_tc_POA,
           TAO_ENCAP_BYTE_ORDER,
           stream.begin (),
           1,
@@ -6918,4 +6918,3 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA_ptr
   _tao_elem = PortableServer::POA::_nil ();
   return 0;
 }
-
diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp
index 0fcd784cdac..83fc211a96b 100644
--- a/TAO/tao/POAS.cpp
+++ b/TAO/tao/POAS.cpp
@@ -133,58 +133,45 @@ void POA_PortableServer::ThreadPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::ThreadPolicy::_is_a_skel (
-                                                   CORBA::ServerRequest &_tao_server_request,
-                                                   void * _tao_object_reference,
-                                                   void * /*context*/,
-                                                   CORBA::Environment &ACE_TRY_ENV
-                                                   )
-{
-  static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_ThreadPolicy_is_a_paramdata};
-  POA_PortableServer::ThreadPolicy_ptr  _tao_impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_ThreadPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ThreadPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::ThreadPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_ThreadPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ThreadPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -429,58 +416,45 @@ void POA_PortableServer::LifespanPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::LifespanPolicy::_is_a_skel (
-                                                     CORBA::ServerRequest &_tao_server_request,
-                                                     void * _tao_object_reference,
-                                                     void * /*context*/,
-                                                     CORBA::Environment &ACE_TRY_ENV
-                                                     )
-{
-  static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_LifespanPolicy_is_a_paramdata};
-  POA_PortableServer::LifespanPolicy_ptr  _tao_impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_LifespanPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_LifespanPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::LifespanPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_LifespanPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_LifespanPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -722,58 +696,45 @@ void POA_PortableServer::IdUniquenessPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::IdUniquenessPolicy::_is_a_skel (
-                                                         CORBA::ServerRequest &_tao_server_request,
-                                                         void * _tao_object_reference,
-                                                         void * /*context*/,
-                                                         CORBA::Environment &ACE_TRY_ENV
-                                                         )
-{
-  static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_IdUniquenessPolicy_is_a_paramdata};
-  POA_PortableServer::IdUniquenessPolicy_ptr  _tao_impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdUniquenessPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdUniquenessPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::IdUniquenessPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_IdUniquenessPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdUniquenessPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -1018,58 +979,45 @@ void POA_PortableServer::IdAssignmentPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::IdAssignmentPolicy::_is_a_skel (
-                                                         CORBA::ServerRequest &_tao_server_request,
-                                                         void * _tao_object_reference,
-                                                         void * /*context*/,
-                                                         CORBA::Environment &ACE_TRY_ENV
-                                                         )
-{
-  static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_IdAssignmentPolicy_is_a_paramdata};
-  POA_PortableServer::IdAssignmentPolicy_ptr  _tao_impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdAssignmentPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdAssignmentPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::IdAssignmentPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_IdAssignmentPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_IdAssignmentPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -1315,58 +1263,45 @@ void POA_PortableServer::ImplicitActivationPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::ImplicitActivationPolicy::_is_a_skel (
-                                                               CORBA::ServerRequest &_tao_server_request,
-                                                               void * _tao_object_reference,
-                                                               void * /*context*/,
-                                                               CORBA::Environment &ACE_TRY_ENV
-                                                               )
-{
-  static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_ImplicitActivationPolicy_is_a_paramdata};
-  POA_PortableServer::ImplicitActivationPolicy_ptr  _tao_impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_ImplicitActivationPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ImplicitActivationPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::ImplicitActivationPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_ImplicitActivationPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ImplicitActivationPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -1610,58 +1545,45 @@ void POA_PortableServer::ServantRetentionPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::ServantRetentionPolicy::_is_a_skel (
-                                                             CORBA::ServerRequest &_tao_server_request,
-                                                             void * _tao_object_reference,
-                                                             void * /*context*/,
-                                                             CORBA::Environment &ACE_TRY_ENV
-                                                             )
-{
-  static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_ServantRetentionPolicy_is_a_paramdata};
-  POA_PortableServer::ServantRetentionPolicy_ptr  _tao_impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_ServantRetentionPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ServantRetentionPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::ServantRetentionPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_ServantRetentionPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_ServantRetentionPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
@@ -1905,58 +1827,45 @@ void POA_PortableServer::RequestProcessingPolicy::_get_value_skel (
 }
 
 void POA_PortableServer::RequestProcessingPolicy::_is_a_skel (
-                                                              CORBA::ServerRequest &_tao_server_request,
-                                                              void * _tao_object_reference,
-                                                              void * /*context*/,
-                                                              CORBA::Environment &ACE_TRY_ENV
-                                                              )
-{
-  static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_is_a_calldata =
-  {"_is_a", 1, 2, PortableServer_RequestProcessingPolicy_is_a_paramdata};
-  POA_PortableServer::RequestProcessingPolicy_ptr  _tao_impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &PortableServer_RequestProcessingPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+   CORBA::ServerRequest &_tao_server_request,
+   void * _tao_object_reference,
+   void * /*context*/,
+   CORBA::Environment &ACE_TRY_ENV
+   )
+{
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_RequestProcessingPolicy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_PortableServer::RequestProcessingPolicy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_calldata =
-  {"_non_existent", 1, 1, PortableServer_RequestProcessingPolicy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &PortableServer_RequestProcessingPolicy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
 
diff --git a/TAO/tao/PolicyS.cpp b/TAO/tao/PolicyS.cpp
index 3e022a5d9a1..dbd2a47d92f 100644
--- a/TAO/tao/PolicyS.cpp
+++ b/TAO/tao/PolicyS.cpp
@@ -182,52 +182,39 @@ void POA_CORBA::Policy::_is_a_skel (
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_Policy_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_Policy_is_a_calldata =
-  {"_is_a", 1, 2, CORBA_Policy_is_a_paramdata};
-  POA_CORBA::Policy_ptr  _tao_impl = (POA_CORBA::Policy_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &CORBA_Policy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_Policy_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_CORBA::Policy::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_Policy_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_Policy_non_existent_calldata =
-  {"_non_existent", 1, 1, CORBA_Policy_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_Policy_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void POA_CORBA::Policy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
diff --git a/TAO/tao/PollableS.cpp b/TAO/tao/PollableS.cpp
index 482ff6114fe..022540596c5 100644
--- a/TAO/tao/PollableS.cpp
+++ b/TAO/tao/PollableS.cpp
@@ -179,31 +179,21 @@ void POA_CORBA::Pollable::_is_a_skel (
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_Pollable_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_Pollable_is_a_calldata =
-  {"_is_a", 1, 2, CORBA_Pollable_is_a_paramdata};
-  POA_CORBA::Pollable_ptr  _tao_impl = (POA_CORBA::Pollable_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &CORBA_Pollable_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+ TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_Pollable_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 CORBA::Boolean POA_CORBA::Pollable::_is_a (
@@ -221,23 +211,20 @@ CORBA::Boolean POA_CORBA::Pollable::_is_a (
 
 void POA_CORBA::Pollable::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_Pollable_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_Pollable_non_existent_calldata =
-  {"_non_existent", 1, 1, CORBA_Pollable_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_Pollable_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void* POA_CORBA::Pollable::_downcast (
@@ -429,31 +416,21 @@ void POA_CORBA::DIIPollable::_is_a_skel (
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_DIIPollable_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_DIIPollable_is_a_calldata =
-  {"_is_a", 1, 2, CORBA_DIIPollable_is_a_paramdata};
-  POA_CORBA::DIIPollable_ptr  _tao_impl = (POA_CORBA::DIIPollable_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &CORBA_DIIPollable_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+ TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_DIIPollable_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 CORBA::Boolean POA_CORBA::DIIPollable::_is_a (
@@ -472,23 +449,20 @@ CORBA::Boolean POA_CORBA::DIIPollable::_is_a (
 
 void POA_CORBA::DIIPollable::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_DIIPollable_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_DIIPollable_non_existent_calldata =
-  {"_non_existent", 1, 1, CORBA_DIIPollable_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_DIIPollable_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void* POA_CORBA::DIIPollable::_downcast (
@@ -787,31 +761,21 @@ void POA_CORBA::PollableSet::_is_a_skel (
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_PollableSet_is_a_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0},
-    {CORBA::_tc_string, CORBA::ARG_IN, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_PollableSet_is_a_calldata =
-  {"_is_a", 1, 2, CORBA_PollableSet_is_a_paramdata};
-  POA_CORBA::PollableSet_ptr  _tao_impl = (POA_CORBA::PollableSet_ptr) _tao_object_reference;
-  CORBA::Boolean _tao_retval;
-  CORBA::String_var _tao_value;
-  _tao_server_request.demarshal (
-    ACE_TRY_ENV,
-    &CORBA_PollableSet_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+ TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = 0;
+  CORBA::String_var value;
+  if (!((_tao_in >> value.out ())))
+    ACE_THROW (CORBA::MARSHAL ());
+
+  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV);
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
   ACE_CHECK;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_PollableSet_is_a_calldata,
-    &_tao_retval,
-    &_tao_value.inout ()
-  );
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 CORBA::Boolean POA_CORBA::PollableSet::_is_a (
@@ -829,23 +793,20 @@ CORBA::Boolean POA_CORBA::PollableSet::_is_a (
 
 void POA_CORBA::PollableSet::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request,
-    void * /* _tao_object_reference */ ,
+    void * _tao_object_reference ,
     void * /*context*/,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  static const TAO_Param_Data_Skel CORBA_PollableSet_non_existent_paramdata [] =
-  {
-    {CORBA::_tc_boolean, 0, 0}
-  };
-  static const TAO_Call_Data_Skel CORBA_PollableSet_non_existent_calldata =
-  {"_non_existent", 1, 1, CORBA_PollableSet_non_existent_paramdata};
-  CORBA::Boolean _tao_retval = 0;
-  _tao_server_request.marshal (
-    ACE_TRY_ENV,
-    &CORBA_PollableSet_non_existent_calldata,
-    &_tao_retval
-  );
+  POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference;
+  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  _tao_server_request.init_reply (ACE_TRY_ENV);
+  ACE_CHECK;
+  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
+    ACE_THROW (CORBA::MARSHAL ());
 }
 
 void* POA_CORBA::PollableSet::_downcast (
diff --git a/TAO/tao/SHMIOP_Profile.cpp b/TAO/tao/SHMIOP_Profile.cpp
index 3dd9b9b8ce7..deef810e314 100644
--- a/TAO/tao/SHMIOP_Profile.cpp
+++ b/TAO/tao/SHMIOP_Profile.cpp
@@ -176,7 +176,7 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr)
       return -1;
     }
 
-    if (this->object_addr_.set (this->port_, 
+    if (this->object_addr_.set (this->port_,
                                 this->host_.in ()) == -1)
     {
       if (TAO_debug_level > 0)
@@ -306,7 +306,7 @@ TAO_SHMIOP_Profile::parse_string (const char *string,
 
   this->host_ = tmp._retn ();
 
-  if (this->object_addr_.set (this->port_, 
+  if (this->object_addr_.set (this->port_,
                               this->host_.in ()) == -1)
     {
       if (TAO_debug_level > 0)
@@ -406,7 +406,7 @@ TAO_SHMIOP_Profile::operator= (const TAO_SHMIOP_Profile &src)
   this->object_key_ = src.object_key_;
 
   this->object_addr_.set (src.object_addr_);
-  
+
   this->port_ = src.port_;
 
   this->host_ = src.host_;
diff --git a/TAO/tao/Server_Request.h b/TAO/tao/Server_Request.h
index 60878bd4b99..531932b4759 100644
--- a/TAO/tao/Server_Request.h
+++ b/TAO/tao/Server_Request.h
@@ -34,72 +34,6 @@
 class TAO_POA;
 class TAO_ORB_Core;
 
-class TAO_Param_Data_Skel
-{
-  // = TITLE
-  //   Description of a single parameter.
-  //
-  // = DESCRIPTION
-  //
-  //   If value_size is nonzero for OUT, INOUT, or RETURN parameters,
-  //   it's (a) an indicator that the ORB returns a pointer-to-value
-  //   for this parameter, and also (b) is the size of the top-level
-  //   of the value that's returned (e.g. ignoring nested sequence
-  //   buffers).  That is, it moves CPU cycles from runtime -- some
-  //   calls to tc->size() -- to compile time where they're
-  //   cheap/free.
-  //
-  //   It _must_ only be set for cases where the ORB allocates the
-  //   return value, which must then be ORB::free()d ... e.g. where
-  //   the value is a pointer to data such as a struct, sequence, or
-  //   union.  (The CORBA C++ mapping doesn't require that for all
-  //   "out" structs; only those of "variable size".)  If this value
-  //   is nonzero, the value passed to do_static_call() must be the address
-  //   of a pointer.
-public:
-  CORBA::TypeCode_ptr tc;
-  // Type of param.
-
-  CORBA::ULong mode;
-  // Its mode.
-
-  CORBA::Boolean own;
-  // whether we own it or not
-};
-
-class TAO_Call_Data_Skel
-{
-  // = TITLE
-  //   Descriptions of operations, as used by the stub interpreter.
-  //   Only interpretive marshaling/unmarshaling is used, and the
-  //   stubs don't know what particular on-the-wire protocol is being
-  //   used.
-  //
-  // = DESCRIPTION
-  //   When using C++ exceptions, many C++ compilers will require the
-  //   use of compiled code throw the exception.  As binary standards
-  //   for exception throwing evolve, it may become practical to
-  //   interpretively throw exceptions.
-public:
-  const char *opname;
-  // Operation name.
-
-  CORBA::Boolean is_roundtrip;
-  // !oneway
-
-  // When constructing tables of parameters, put them in the same
-  // order they appear in the IDL spec: return value, then parameters
-  // left to right.  Other orders may produce illegal IIOP protocol
-  // messages.
-
-  CORBA::ULong param_count;
-  // # parameters.
-
-  const TAO_Param_Data_Skel *params;
-  // Their descriptions.
-
-};
-
 class TAO_Export CORBA_ServerRequest
 {
   // = TITLE
@@ -192,17 +126,6 @@ public:
   virtual CORBA::ORB_ptr  orb (void) = 0;
   // get the underlying ORB
 
-  virtual void demarshal (CORBA_Environment &ACE_TRY_ENV,
-                          const TAO_Call_Data_Skel *info,
-                          ...) = 0;
-  // demarshal incoming parameters
-
-  virtual void marshal (CORBA_Environment &ACE_TRY_ENV,
-                        //                        CORBA_Environment &skel_env,
-                        const TAO_Call_Data_Skel *info,
-                        ...) = 0;
-  // marshal outgoing parameters
-
   virtual TAO_InputCDR &incoming (void) = 0;
   // Retrieve the incoming stream.
 
diff --git a/TAO/tao/Services.cpp b/TAO/tao/Services.cpp
index 9151bf96840..78e1f1f91e7 100644
--- a/TAO/tao/Services.cpp
+++ b/TAO/tao/Services.cpp
@@ -250,14 +250,22 @@ CORBA::ServiceInformation::_tao_seq_ServiceDetail::~_tao_seq_ServiceDetail (void
 
 #endif /* end #if !defined */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem)
 {
   CORBA::ServiceDetail *_any_val;
   ACE_NEW (_any_val, CORBA::ServiceDetail (_tao_elem));
   if (!_any_val) return;
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_ServiceDetail, _any_val, 1, ACE_TRY_ENV); // copy the value
+    _tao_any._tao_replace (CORBA::_tc_ServiceDetail,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _any_val,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY
@@ -271,7 +279,15 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceDetail *_tao_elem) // non
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV); // consume it
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+
+    _tao_any._tao_replace (CORBA::_tc_ServiceDetail,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_elem,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY {}
@@ -295,10 +311,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_
       ACE_NEW_RETURN (_tao_elem, CORBA::ServiceDetail, 0);
       TAO_InputCDR stream (_tao_any._tao_get_cdr (),
                            _tao_any._tao_byte_order ());
-      if (stream.decode (CORBA::_tc_ServiceDetail, _tao_elem, 0, ACE_TRY_ENV)
-        == CORBA::TypeCode::TRAVERSE_CONTINUE)
+      if (stream >> *_tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV);
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ServiceDetail,
+            1,
+            _tao_elem,
+            ACE_TRY_ENV);
         ACE_TRY_CHECK;
         return 1;
       }
@@ -322,9 +341,17 @@ void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceInformation &_tao_el
   CORBA::ServiceInformation *_any_val;
   ACE_NEW (_any_val, CORBA::ServiceInformation (_tao_elem));
   if (!_any_val) return;
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_ServiceInformation, _any_val, 1, ACE_TRY_ENV); // copy the value
+    _tao_any._tao_replace (CORBA::_tc_ServiceInformation,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _any_val,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY
@@ -338,7 +365,14 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceInformation *_tao_elem) //
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_any.replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV); // consume it
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+    _tao_any._tao_replace (CORBA::_tc_ServiceDetail,
+                           TAO_ENCAP_BYTE_ORDER,
+                           stream.begin (),
+                           1,
+                           _tao_elem,
+                           ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
   ACE_CATCHANY {}
@@ -362,10 +396,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio
       ACE_NEW_RETURN (_tao_elem, CORBA::ServiceInformation, 0);
       TAO_InputCDR stream (_tao_any._tao_get_cdr (),
                            _tao_any._tao_byte_order ());
-      if (stream.decode (CORBA::_tc_ServiceInformation, _tao_elem, 0, ACE_TRY_ENV)
-        == CORBA::TypeCode::TRAVERSE_CONTINUE)
+      if (stream >> *_tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV);
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ServiceInformation,
+            1,
+            _tao_elem,
+            ACE_TRY_ENV);
         ACE_TRY_CHECK;
         return 1;
       }
@@ -384,7 +421,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (
+CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
     const CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence
   )
@@ -411,7 +448,7 @@ ACE_INLINE CORBA::Boolean operator<< (
   return 0; // error
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence)
+CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
   if (strm >> _tao_seq_len)
diff --git a/TAO/tao/Services.h b/TAO/tao/Services.h
index d055ef7d807..c1815fb6b0d 100644
--- a/TAO/tao/Services.h
+++ b/TAO/tao/Services.h
@@ -518,29 +518,22 @@ void  operator<<= (CORBA::Any &, const CORBA_ServiceInformation &); // copying v
 void  operator<<= (CORBA::Any &, CORBA_ServiceInformation*); // noncopying version
 CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA_ServiceInformation *&);
 
-#ifndef __ACE_INLINE__
-
 CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail &); //
 CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceDetail &);
 CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail::_tao_seq_Octet &); //
 CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceDetail::_tao_seq_Octet &);
+
 CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation &);
- //
 CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &); //
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &);
 CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceOption &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &); //
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &);
 CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceDetail &);
 
-#endif /* __ACE_INLINE__ */
-
 #if defined (__ACE_INLINE__)
-
 #include "tao/Services.i"
 #endif /* defined INLINE */
 
-
-
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 #pragma warning(pop)
 #endif /* _MSC_VER */
diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp
index 9998f8333f4..82b58110a0c 100644
--- a/TAO/tao/Stub.cpp
+++ b/TAO/tao/Stub.cpp
@@ -31,41 +31,8 @@
 # include "tao/Stub.i"
 #endif /* ! __ACE_INLINE__ */
 
-#include "tao/Timeprobe.h"
-
 ACE_RCSID(tao, TAO_Stub, "$Id$")
 
-#if defined (ACE_ENABLE_TIMEPROBES)
-
-static const char *TAO_TAO_Stub_Timeprobe_Description[] =
-  {
-    "TAO_Stub::do_static_call - start",
-    "TAO_Stub::do_static_call - end",
-    "TAO_Stub::do_static_call - set_cancel",
-    "TAO_Stub::do_static_call - grab_orb_core",
-    "TAO_Stub::do_static_call - invocation_ctor",
-    "TAO_Stub::do_static_call - invocation_start",
-    "TAO_Stub::do_static_call - put_params"
-  };
-
-enum
-  {
-    // Timeprobe description table start key
-    TAO_STUB_OBJECT_DO_STATIC_CALL_START = 500,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_END,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START,
-    TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS
-  };
-
-// Setup Timeprobes
-ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_TAO_Stub_Timeprobe_Description,
-                                  TAO_STUB_OBJECT_DO_STATIC_CALL_START);
-
-#endif /* ACE_ENABLE_TIMEPROBES */
-
 TAO_Stub::TAO_Stub (char *repository_id,
                     const TAO_MProfile &profiles,
                     TAO_ORB_Core* orb_core)
@@ -297,287 +264,7 @@ private:
   int old_type_;
 };
 
-// "Stub interpreter" for static stubs.  IDL compiler (or human
-// equivalent thereof :-) should just dump a read-only description of
-// the call into "calldata" and do varargs calls to this routine,
-// which does all the work.
-
-void
-TAO_Stub::do_static_call (CORBA::Environment &ACE_TRY_ENV,
-                          const TAO_Call_Data *info,
-                          void** args)
-
-{
-  ACE_FUNCTION_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_START);
-
-  TAO_Synchronous_Cancellation_Required NOT_USED;
-
-  ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL);
-
-  ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE);
-
-  // Do a locate_request if necessary/wanted.
-  // Suspect that you will be forwarded, so be proactive!
-  // strategy for reducing overhead when you think a request will
-  // be forwarded.  No standard way now to know.
-  if (this->use_locate_request_ && this->first_locate_request_)
-    {
-      TAO_GIOP_Locate_Request_Invocation call (this,
-                                               this->orb_core_);
-
-      // Simply let these exceptions propagate up
-      // (if any of them occurs.)
-      call.start (ACE_TRY_ENV);
-      ACE_CHECK;
-
-      call.invoke (ACE_TRY_ENV);
-      ACE_CHECK;
-
-      this->first_locate_request_ = 0;
-    }
-
-  if (info->is_roundtrip)
-    {
-      TAO_GIOP_Twoway_Invocation call (this,
-                                       info->opname,
-                                       ACE_OS::strlen (info->opname),
-                                       this->orb_core_);
-
-      ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR);
-
-      // We may need to loop through here more than once if we're
-      // forwarded to some other object reference.
-      //
-      // NOTE: A quality-of-service policy may be useful to establish
-      // here, specifically one controlling how many times the call is
-      // reissued before failing the call on the assumption that
-      // something is broken.
-      //
-      // NOTE: something missing is a dynamic way to change the policy
-      // of whether to issue LocateRequest messages or not.  This code
-      // uses a simple, fixed policy: never use LocateRequest
-      // messages.
-      //
-      for (;;)
-        {
-          call.start (ACE_TRY_ENV);
-          ACE_CHECK;
-
-          CORBA::Short flag = 131;
-
-          call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                               ACE_TRY_ENV);
-          ACE_CHECK;
-
-          ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START);
-
-          // Make the call ... blocking for the response.
-          this->put_params (ACE_TRY_ENV, info, call, args);
-          ACE_CHECK;
-
-          ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS);
-
-          int status =
-            call.invoke (info->excepts,
-                         info->except_count,
-                         ACE_TRY_ENV);
-          ACE_CHECK;
-
-          if (status == TAO_INVOKE_RESTART)
-            continue;
 
-          if (status == TAO_INVOKE_EXCEPTION)
-            return; // Shouldn't happen
-
-          if (status != TAO_INVOKE_OK)
-            ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                       CORBA::COMPLETED_MAYBE));
-
-          // The only case left is status == TAO_INVOKE_OK, exit the
-          // loop.  We cannot retry because at this point we either
-          // got a reply or something with an status of
-          // COMPLETED_MAYBE, thus we cannot reissue the request if we
-          // are to satisfy the "at most once" semantics.
-          break;
-        }
-
-      // Now, get all the "return", "out", and "inout" parameters
-      // from the response message body ... return parameter is
-      // first, the rest are in the order defined in the IDL spec
-      // (which is also the order that DII users are required to
-      // use).
-
-      const TAO_Param_Data *pdp = info->params;
-      for (void** i = args;
-           i !=  args + info->param_count;
-           i++, pdp++)
-        {
-          void *ptr = *i;
-
-          // if it is an inout parameter, it would become
-          // necessary to first release the "in" memory
-          if (pdp->mode == PARAM_INOUT)
-            {
-              // @@ TODO - add others as we test each case
-              // (ASG) will do 03/22/98.
-              // @@ IMHO this should be handled in the stub
-              // (coryan)
-              CORBA::TCKind kind = pdp->tc->kind (ACE_TRY_ENV);
-              ACE_CHECK;
-
-              switch (kind)
-                {
-                  case CORBA::tk_string:
-                    CORBA::string_free (*(char **) ptr);
-                    *(char **)ptr = 0;
-                    break;
-                  case CORBA::tk_objref:
-                    CORBA::release (*(CORBA::Object_ptr *) ptr);
-                    break;
-                  case CORBA::tk_any:
-                    break;
-                  default:
-                    break;
-                }
-            }
-
-          if (pdp->mode == PARAM_RETURN
-              || pdp->mode == PARAM_OUT
-              || pdp->mode == PARAM_INOUT)
-            {
-              // The language mapping's memory allocation
-              // policy says that some data is heap-allocated.
-              // This interpreter is told about the relevant
-              // policy by whoever built the operation
-              // description (e.g. the IDL compiler) so it
-              // doesn't have to know the policy associated
-              // with a particular language binding
-              // (e.g. C/C++ differ, and C++ even has
-              // different policies for different kinds of
-              // structures).
-              if (pdp->value_size == 0)
-                {
-                  (void) call.inp_stream ().decode (pdp->tc,
-                                                    ptr,
-                                                    0,
-                                                    ACE_TRY_ENV);
-                  ACE_CHECK;
-                }
-              else
-                {
-                  // @@ (ASG) -  I think we must completely
-                  // get rid of this case because IDL compiler
-                  // generated stubs will use this function
-                  // and they better allocate all the memory.
-
-                  // assert (value_size == tc->size());
-                  ACE_NEW (*(void **)ptr,
-                           CORBA::Octet [pdp->value_size]);
-
-                  (void) call.inp_stream ().decode (pdp->tc,
-                                                    *(void**)ptr,
-                                                    0,
-                                                    ACE_TRY_ENV);
-                  ACE_CHECK;
-                }
-            }
-        }
-    } // if (two way)
-  else
-    {
-      TAO_GIOP_Oneway_Invocation call (this,
-                                       info->opname,
-                                       ACE_OS::strlen (info->opname),
-                                       this->orb_core_);
-
-      ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR);
-
-      for (;;)
-        {
-          call.start (ACE_TRY_ENV);
-          ACE_CHECK;
-
-          CORBA::Octet flag =
-            ACE_static_cast (CORBA::Octet,
-                             call.sync_scope ());
-
-          call.prepare_header (flag,
-                               ACE_TRY_ENV);
-          ACE_CHECK;
-
-          this->put_params (ACE_TRY_ENV,
-                            info,
-                            call,
-                            args);
-          ACE_CHECK;
-
-          ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS);
-
-          int status = call.invoke (ACE_TRY_ENV);
-          ACE_CHECK;
-
-          if (status == TAO_INVOKE_RESTART)
-            continue;
-
-          if (status == TAO_INVOKE_EXCEPTION)
-            return; // Shouldn't happen
-
-          if (status != TAO_INVOKE_OK)
-            ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                       CORBA::COMPLETED_MAYBE));
-
-          break;
-        }
-    }
-}
-
-void
-TAO_Stub::put_params (CORBA::Environment &ACE_TRY_ENV,
-                      const TAO_Call_Data *info,
-                      TAO_GIOP_Invocation &call,
-                      void** args)
-{
-  // Now, put all "in" and "inout" parameters into the request
-  // message body.
-  //
-  // Some "inout" data have an extra level of indirection,
-  // specified by the language mapping's memory allocation
-  // policies ... the indirection only shows up here when it's
-  // needed later for allocating "out" memory, otherwise there's
-  // just one indirection.
-
-  TAO_OutputCDR &cdr = call.out_stream ();
-
-  const TAO_Param_Data *pdp = info->params;
-  for (void** i = args;
-       i != args + info->param_count;
-       i++, pdp++)
-    {
-      void *ptr = *i;
-
-      if (pdp->mode == PARAM_IN)
-        {
-          (void) cdr.encode (pdp->tc,
-                             ptr,
-                             0,
-                             ACE_TRY_ENV);
-        }
-      else if (pdp->mode == PARAM_INOUT)
-        {
-          if (pdp->value_size == 0)
-            (void) cdr.encode (pdp->tc,
-                               ptr,
-                               0,
-                               ACE_TRY_ENV);
-          else
-            (void) cdr.encode (pdp->tc,
-                               *(void**)ptr,
-                               0,
-                               ACE_TRY_ENV);
-        }
-      ACE_CHECK;
-    }
-}
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h
index a6f55df3aca..c67b7445514 100644
--- a/TAO/tao/Stub.h
+++ b/TAO/tao/Stub.h
@@ -70,41 +70,6 @@ enum TAO_Param_Type
 
 class TAO_Profile;
 
-struct TAO_Param_Data
-{
-  // = TITLE
-  //   TAO_Param_Data
-  //
-  // = DESCRIPTION
-  //   Description of a single parameter.
-  //
-  //   If value_size is nonzero for OUT, INOUT, or RETURN parameters,
-  //   it's (a) an indicator that the ORB returns a pointer-to-value
-  //   for this parameter, and also (b) is the size of the top-level
-  //   of the value that's returned (e.g. ignoring nested sequence
-  //   buffers).  That is, it moves CPU cycles from runtime -- some
-  //   calls to tc->size() -- to compile time where they're
-  //   cheap/free.
-  //
-  //   It _must_ only be set for cases where the ORB allocates the
-  //   return value, which must then be ORB::free()d ... e.g. where
-  //   the value is a pointer to data such as a struct, sequence, or
-  //   union.  (The CORBA C++ mapping doesn't require that for all
-  //   "out" structs; only those of "variable size".)  If this value
-  //   is nonzero, the value passed to do_static_call() must be the address
-  //   of a pointer.
-
-  CORBA::TypeCode_ptr tc;
-  // TypeCode for the parameter
-
-  TAO_Param_Type mode;
-  // Its mode.
-
-  size_t value_size;
-  // zero or tc->size (). For SII, we always know its size since it is the IDL
-  // compiler which generates the stub code.
-};
-
 // Function pointer returning a pointer to CORBA::Exception. This is used to
 // describe the allocator for user-defined exceptions that are used internally
 // by the interpreter.
@@ -130,80 +95,6 @@ struct TAO_Exception_Data
   // the allocator for this exception
 };
 
-struct TAO_Call_Data
-{
-  // = TITLE
-  //   TAO_Call_Data
-  //
-  // = DESCRIPTION
-  //   Descriptions of operations, as used by the stub interpreter.
-  //   Only interpretive marshaling/unmarshaling is used, and the
-  //   stubs don't know what particular on-the-wire protocol is being
-  //   used.
-  //
-  //   When using C++ exceptions, many C++ compilers will require the
-  //   use of compiled code throw the exception.  As binary standards
-  //   for exception throwing evolve, it may become practical to
-  //   interpretively throw exceptions.
-
-  const char *opname;
-  // Operation name.
-
-  CORBA::Boolean is_roundtrip;
-  // !oneway
-
-  // When constructing tables of parameters, put them in the same
-  // order they appear in the IDL spec: return value, then parameters
-  // left to right.  Other orders may produce illegal protocol
-  // messages.
-
-  u_int param_count;
-  // # parameters.
-
-  const TAO_Param_Data *params;
-  // Their descriptions.
-
-  // The exceptions allowed by this operation can be listed in any
-  // order, and need not include the system exceptions which may be
-  // returned by OMG-IDL operations.  If an operation tries to return
-  // any exception not allowed by its type signature, this causes a a
-  // system exception to be reported.
-
-  u_int except_count;
-  // # exceptions.
-
-  //  CORBA::TypeCode_ptr *excepts;
-  TAO_Exception_Data *excepts;
-  // Their descriptions.
-};
-
-struct TAO_Skel_Entry
-{
-  // = TITLE
-  //   TAO_Skel_Entry
-  //
-  // = DESCRIPTION
-  //   Skeletons map "ServerRequest" generic signatures to the static
-  //   call signature required by the implementation's methods.  table
-  //   of these per implementation
-  //
-  //   There are several optimizations that'd be desirable for use by
-  //   "static skeletons", notably (a) passing of per-object data held
-  //   by the OA so that the method doesn't need to look it up itself,
-  //   (b) removing all mandatory heap allocation of data, and of
-  //   course (c) handling all the built-in ORB calls like "is_a" and
-  //   "get_implementation".  This code is currently set up only for
-  //   Dynamic Skeletons and bridging, for which none of those are
-  //   real issues.
-
-  const TAO_Call_Data *op_descriptor;
-  // pointer to the calldata structure that holds information about all the
-  // parameters
-
-  TAO_Skeleton impl_skeleton;
-  // skeleton corresponding to the operation
-};
-
 class TAO_Export TAO_Stub
 {
   // = TITLE
@@ -222,26 +113,6 @@ class TAO_Export TAO_Stub
   //   The stub and DII interpreter APIs are member functions of this
   //   type.
 public:
-  void do_static_call (CORBA_Environment &ACE_TRY_ENV,
-                       const TAO_Call_Data *info,
-                       void** args);
-  // The "stub interpreter" method parameters are:
-  //
-  //    - ACE_TRY_ENV ... used for exception reporting
-  //    - info ... describes the call
-  //    - args parameters follow
-  //
-  // The varargs parameters are pointers to data instances as
-  // described by info->params.  (If the value_size is nonzero, the
-  // data instance is itself a pointer.)  The order on the call stack
-  // must be exactly the order they're listed in info->params;
-  // normally this is the order the values are listed in the OMG-IDL
-  // operation specification.
-  //
-  // NOTE: This can be sped up by eliminating some parameter
-  // shuffling.  The stub and "do_static_call" parameters are all but the
-  // same, except that their order is different.
-
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
   void do_dynamic_call (const char *opname,
@@ -424,13 +295,6 @@ public:
   // temporary.
 
 protected:
-  void put_params (CORBA_Environment &ACE_TRY_ENV,
-                   const TAO_Call_Data *info,
-                   TAO_GIOP_Invocation &call,
-                   void** args);
-  // Helper method to factor out common code in static oneway
-  // vs. twoway invocations.
-
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
   void put_params (TAO_GIOP_Invocation &call,
diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp
index 03b27e5742b..85f7a9a5f4a 100644
--- a/TAO/tao/Typecode.cpp
+++ b/TAO/tao/Typecode.cpp
@@ -480,7 +480,7 @@ CORBA_TypeCode::skip_typecode (TAO_InputCDR &stream)
         case CORBA::tk_string:
         case CORBA::tk_wstring:
         case ~0u:
-          return stream.read_ulong (temp);
+          return (stream.read_ulong (temp) != 0);
 
           // The rest have "complex" parameter lists that are
           // encoded as bulk octets ... just skip them.
@@ -1587,10 +1587,6 @@ CORBA_TypeCode::private_member_count (CORBA::Environment &ACE_TRY_ENV) const
   ACE_NOTREACHED (return 0);
 }
 
-// NOTE special calling convention for stream.decode () when we're
-// potentially deencapsulating an indirected typecode: the "data2"
-// value indicates that this typecode is the parent.  See comments at
-// stream.decode () for further details.
 //
 // Applicable only to struct, union, and except
 //
@@ -1647,27 +1643,14 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot,
           {
             if (!stream.skip_string ())  // skip the name
               ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
-            CORBA::TypeCode::traverse_status status =
-              stream.decode (CORBA::_tc_TypeCode,
-                             // the typecode will be
-                             // retrieved at the i-th
-                             // location. The decode
-                             // routine will allocate the
-                             // storage to hold a
-                             // typecode
-                             &this->private_state_->
-                             tc_member_type_list_[i],
-                             this,
-                             // pass ourselves since we
-                             // will be the parent. This
-                             // is the case where the 3rd
-                             // parameter is used in a
-                             // decode method
-                             ACE_TRY_ENV);
-            ACE_CHECK_RETURN (0);
 
-            if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-              ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
+            CORBA::TypeCode_ptr& member_type =
+              this->private_state_->tc_member_type_list_[i];
+            CORBA_TypeCode::_tao_decode (this,
+                                         stream,
+                                         member_type,
+                                         ACE_TRY_ENV);
+            ACE_CHECK_RETURN (0);
           }
 
         this->private_state_->tc_member_type_list_known_ = 1;
@@ -1707,10 +1690,6 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot,
         else if (!stream.read_ulong (temp)     // default used
                  || !stream.read_ulong (temp)) // member count
           ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
-        // Always big enough because labels can only be of a
-        // few different types of which "long" has the
-        // largest size.
-        CORBA::Long scratch;
 
         // get the typecode for the discriminator
         tc = this->discriminator_type (ACE_TRY_ENV);
@@ -1722,7 +1701,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot,
           // the ith entry will have the typecode of the ith guy
           {
             CORBA::TypeCode::traverse_status status =
-              stream.decode (tc.in (), &scratch, this,  ACE_TRY_ENV);
+              stream.skip (tc.in (), ACE_TRY_ENV);
             // member label
             ACE_CHECK_RETURN (0);
 
@@ -1730,21 +1709,20 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot,
                 || !stream.skip_string ())  // skip the name
               ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
 
-            status =  stream.decode (CORBA::_tc_TypeCode,  // get the typecode
-                                     &private_state_->tc_member_type_list_[i],
-                                     this,
-                                     ACE_TRY_ENV);
+            CORBA::TypeCode_ptr& member_type =
+              this->private_state_->tc_member_type_list_[i];
+            CORBA_TypeCode::_tao_decode (this,
+                                         stream,
+                                         member_type,
+                                         ACE_TRY_ENV);
             ACE_CHECK_RETURN (0);
-
-            if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-              ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
           }
         this->private_state_->tc_member_type_list_known_ = 1;
 
         if (slot < mcount)
           return this->private_state_->tc_member_type_list_[slot];
         else
-          ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), (CORBA::TypeCode_ptr)0);
+          ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0);
       }
       ACE_NOTREACHED (break);
 
@@ -1908,10 +1886,6 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot,
           ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
         else
           {
-            CORBA::Long scratch; // always big enough because labels can
-            // only be of a few different types of
-            // which "long" has the largest size
-
             // get the typecode for the discriminator
             tc = this->discriminator_type (ACE_TRY_ENV);
             // compute the name for all the members and return the
@@ -1922,10 +1896,8 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot,
               {
                 // the ith entry will have the name of the ith member
                 CORBA::TypeCode::traverse_status status =
-                  stream.decode (tc.in (),
-                                 &scratch,
-                                 this,
-                                 ACE_TRY_ENV); // member label
+                  stream.skip (tc.in (),
+                               ACE_TRY_ENV); // member label
                 ACE_CHECK_RETURN (0);
 
                 if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
@@ -2092,12 +2064,15 @@ CORBA_TypeCode::private_discriminator_type (CORBA::Environment &ACE_TRY_ENV) con
   // skip ID and name, and then get the discriminant TC
 
   if (!stream.skip_string () // type ID, hidden
-      || !stream.skip_string () // typedef name
-      || stream.decode (CORBA::_tc_TypeCode,
-                        &this->private_state_->tc_discriminator_type_, this,
-                        ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE)
+      || !stream.skip_string ()) // typedef name
     ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
 
+  CORBA_TypeCode::_tao_decode (this,
+                               stream,
+                               this->private_state_->tc_discriminator_type_,
+                               ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+
   this->private_state_->tc_discriminator_type_known_ = 1;
   return this->private_state_->tc_discriminator_type_;
 }
@@ -2184,8 +2159,6 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const
 {
   TAO_InputCDR stream (this->buffer_+4, this->length_-4,
                        this->byte_order_);
-  CORBA::TypeCode::traverse_status status = CORBA::TypeCode::TRAVERSE_STOP;
-
   switch (kind_)
     {
     case CORBA::tk_sequence:
@@ -2198,18 +2171,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const
           return this->private_state_->tc_content_type_;
 
         // retrieve the content type
-        status = stream.decode (CORBA::_tc_TypeCode,
-                           &this->private_state_->tc_content_type_,
-                           this,  ACE_TRY_ENV);
+        CORBA_TypeCode::_tao_decode (this,
+                                     stream,
+                                     this->private_state_->tc_content_type_,
+                                     ACE_TRY_ENV);
         ACE_CHECK_RETURN (0);
 
-        if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) // element type
-          ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-        else
-          {
-            this->private_state_->tc_content_type_known_ = 1;
-            return this->private_state_->tc_content_type_;
-          }
+        this->private_state_->tc_content_type_known_ = 1;
+        return this->private_state_->tc_content_type_;
       }
       ACE_NOTREACHED (break);
 
@@ -2225,18 +2194,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const
             || !stream.skip_string ()) // name
           ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
 
-        status = stream.decode (CORBA::_tc_TypeCode,
-                                &this->private_state_->tc_content_type_, this,
-                                ACE_TRY_ENV);
+        CORBA_TypeCode::_tao_decode (this,
+                                     stream,
+                                     this->private_state_->tc_content_type_,
+                                     ACE_TRY_ENV);
         ACE_CHECK_RETURN (0);
 
-        if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-          ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-        else
-          {
-            this->private_state_->tc_content_type_known_ = 1;
-            return this->private_state_->tc_content_type_;
-          }
+        this->private_state_->tc_content_type_known_ = 1;
+        return this->private_state_->tc_content_type_;
       }
       /*NOTREACHED*/
 
@@ -2271,6 +2236,248 @@ CORBA_TypeCode::private_discrim_pad_size (CORBA::Environment &ACE_TRY_ENV)
  this->private_state_->tc_discrim_pad_size_ = discrim_size;
  return discrim_size;
 }
+
+// ****************************************************************
+
+void
+CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
+                             TAO_InputCDR &cdr,
+                             CORBA_TypeCode *&x,
+                             CORBA::Environment &ACE_TRY_ENV)
+{
+  x = 0;
+  CORBA::ULong kind;
+
+  if (!cdr.read_ulong (kind))
+    ACE_THROW (CORBA::BAD_TYPECODE ());
+
+  static CORBA::TypeCode_ptr tc_consts [CORBA::TC_KIND_COUNT] =
+  {
+    CORBA::_tc_null,
+    CORBA::_tc_void,
+    CORBA::_tc_short,
+    CORBA::_tc_long,
+    CORBA::_tc_ushort,
+
+    CORBA::_tc_ulong,
+    CORBA::_tc_float,
+    CORBA::_tc_double,
+    CORBA::_tc_boolean,
+    CORBA::_tc_char,
+
+    CORBA::_tc_octet,
+    CORBA::_tc_any,
+    CORBA::_tc_TypeCode,
+    CORBA::_tc_Principal,
+
+    0, // CORBA::_tc_Object ... type ID is CORBA_Object
+    0, // CORBA_tk_struct
+    0, // CORBA_tk_union
+    0, // CORBA_tk_enum
+    0, // CORBA::_tc_string ... unbounded
+    0, // CORBA_tk_sequence
+    0, // CORBA_tk_array
+    0, // CORBA_tk_alias
+    0, // CORBA_tk_except
+
+    CORBA::_tc_longlong,
+    CORBA::_tc_ulonglong,
+    CORBA::_tc_longdouble,
+    CORBA::_tc_wchar,
+    0           // CORBA::_tc_wstring ... unbounded
+  };
+
+  if (kind < CORBA::TC_KIND_COUNT && tc_consts [kind] != 0)
+    {
+      // Easy case, the CDR contains no more data, and we can simply
+      // duplicate one of the TypeCode constants...
+      x = CORBA::TypeCode::_duplicate (tc_consts [kind]);
+      return;
+    }
+
+  if (kind != ~0u && kind >= CORBA::TC_KIND_COUNT)
+    {
+      // Invalid kind.... cannot even determine what portion of the
+      // CDR corresponds to the typecode....
+      ACE_THROW (CORBA::BAD_TYPECODE ());
+    }
+
+  if (kind == ~0u)
+    {
+      // Get the long indicating the encapsulation offset,
+      // then set up indirection stream that's like "stream"
+      // but has space enough only for the typecode and the
+      // length for the encapsulated parameters.
+      //
+      // The offset must be negative
+      CORBA::Long offset;
+
+      if (!cdr.read_long (offset) || offset >= 0)
+        {
+          // Since indirected typecodes cannot occur at the
+          // topmost level, they can occur starting only at the
+          // second and subsequent levels. This means that a
+          // normal encoding of that typecode occurred somewhere
+          // before in the stream. As a result the offset field
+          // must always be negative. See the CORBA spec for details.
+          ACE_THROW (CORBA::BAD_TYPECODE ());
+        }
+
+      // Slava Galperin <galperin@teknowledge.com> clarifies
+      // this:
+      // CORBA Spec says:
+      //
+      // The encoding of such an indirection is as a
+      // TypeCode with a TCKind value that has the special
+      // value 2^32 -1 (0xffffffff, all ones). Such
+      // typecodes have a single (simple) parameter, which
+      // is the long offset (in units of octets) from the
+      // simple parameter. (This means that an offset of
+      // negative four (-4) is illegal because it will be
+      // self-indirecting.)
+      // (CORBA V2.2 CDR Transfer Syntax February 1998 page 13-17)
+      //
+      // This apparently assumes offset from the <em>
+      // beginning </em> of the simple parameter.
+      // [Right, because otherwise the value -8 would be
+      // illegal]
+      // Because at this point stream is positioned after
+      // the parameter, we need to account for that when
+      // constructing indir_stream by subtracting 4 (length
+      // of the offset parameter itself).
+
+      //                TAO_InputCDR indir_stream (*stream, 8, offset
+      //                - 4);
+      ACE_Message_Block *mb = (ACE_Message_Block *)cdr.start ();
+      TAO_InputCDR indir_stream (mb->rd_ptr () + offset - 4,
+                                 -1 * (offset - 4));
+
+      if (!indir_stream.good_bit ())
+        ACE_THROW (CORBA::BAD_TYPECODE ());
+
+      // Get "kind" and length of target typecode
+      //
+      // XXX this currently assumes the TCKind to which we
+      // indirect is the same byte order as the "parent"
+      // typecode -- not the right assumption; see how the
+      // TypeCode interpreter does it.
+
+      CORBA::ULong indir_kind = 0;
+      CORBA::ULong indir_len = 0;
+
+      if (!indir_stream.read_ulong (indir_kind)
+          || indir_kind >= CORBA::TC_KIND_COUNT // no double indirections
+          || !indir_stream.read_ulong (indir_len))
+        ACE_THROW (CORBA::BAD_TYPECODE ());
+
+      // Now construct indirected typecode.  This shares the
+      // typecode octets with the "parent" typecode,
+      // increasing the amount of memory sharing and
+      // reducing the cost of getting typecodes.
+      ACE_NEW (x,
+               CORBA::TypeCode ((CORBA::TCKind) indir_kind,
+                                indir_len,
+                                indir_stream.rd_ptr(),
+                                0,
+                                0,
+                                // @@ TODO
+                                // Here we lose the parent
+                                // typecode...
+                                ACE_const_cast(CORBA_TypeCode*,parent)));
+      return;
+    }
+
+  // The other cases....
+  switch (kind)
+    {
+    default:
+      ACE_THROW (CORBA::INTERNAL ());
+
+      // Some have "simple" parameter lists ... some of these
+      // also have preallocated constants that could be used.
+    case CORBA::tk_string:
+    case CORBA::tk_wstring:
+      {
+        CORBA::ULong bound;
+
+        if (!cdr.read_ulong (bound))
+          ACE_THROW (CORBA::BAD_TYPECODE ());
+
+        if (bound == 0)
+          {
+            // unbounded string. Let us reuse the ORB owned
+            // _tc_string or _tc_wstring
+            if (kind == CORBA::tk_string)
+              x = CORBA::TypeCode::_duplicate (CORBA::_tc_string);
+            else
+              x = CORBA::TypeCode::_duplicate (CORBA::_tc_wstring);
+          }
+        else
+          {
+            // bounded string. Create a TypeCode. If it is does not
+            // have a parent, then the application must free it.
+
+            // allocate a new TypeCode
+
+            // This may produce a memory leak, because
+            // callers are sloppy about removing these
+            // objects.
+            CORBA::Long _oc_bounded_string [] =
+            {TAO_ENCAP_BYTE_ORDER, 0};
+            // Bounded string. Save the bounds
+            _oc_bounded_string [1] = (CORBA::Long) bound;
+            ACE_NEW (x,
+                     CORBA::TypeCode (ACE_static_cast(CORBA::TCKind, kind),
+                                      8,
+                                      ACE_reinterpret_cast(char*,_oc_bounded_string),
+                                      0,
+                                      sizeof (CORBA::String_var),
+                                      0));
+          }
+      }
+      break;
+
+    // The rest have "complex" parameter lists that are
+    // encoded as bulk octets ...
+    case CORBA::tk_objref:
+    case CORBA::tk_struct:
+    case CORBA::tk_union:
+    case CORBA::tk_enum:
+    case CORBA::tk_sequence:
+    case CORBA::tk_array:
+    case CORBA::tk_alias:
+    case CORBA::tk_except:
+      {
+        CORBA::ULong length;
+
+        // get the encapsulation length
+        if (!cdr.read_ulong (length))
+          ACE_THROW (CORBA::BAD_TYPECODE ());
+
+        // If the length is greater that the containing CDR stream
+        // that is an error...
+        if (length > cdr.length ())
+          ACE_THROW (CORBA::BAD_TYPECODE ());
+
+        // create a new typecode
+        ACE_NEW (x,
+                 CORBA::TypeCode ((CORBA::TCKind) kind,
+                                  length,
+                                  cdr.rd_ptr (),
+                                  0,
+                                  0,
+                                  ACE_const_cast (CORBA_TypeCode*,parent)));
+        // skip length number of bytes in the stream, otherwise we may
+        // leave the stream in an undefined state
+        (void) cdr.skip_bytes (length);
+      }
+      break;
+    } // end of switch
+}
+
+// ****************************************************************
+
+
 // ************ The following are deprecated ****************
 
 // say how many parameters this typecode has; normally a fixed number,
@@ -2439,28 +2646,67 @@ CORBA::TypeCode::private_alignment (CORBA::Environment &ACE_TRY_ENV)
 CORBA::Boolean
 operator<< (TAO_OutputCDR& cdr, const CORBA::TypeCode *x)
 {
-  ACE_TRY_NEW_ENV
-    {
-      // @@ This function should *not* use the interpreter, there must
-      // be a way to do this with just CDR operations!!!!
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_TYPECODE::instance ()->encode (0,
-                                                   &x,
-                                                   0,
-                                                   &cdr,
-                                                   ACE_TRY_ENV);
-      ACE_TRY_CHECK;
+  CORBA::ULong kind =
+    x->kind_;
 
-      if (status == CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 1;
-      // else return 0 at the end of the function
-    }
-  ACE_CATCH (CORBA_Exception, ex)
+  if (!cdr.write_ulong (kind))
+    return 0;
+
+  switch (kind)
     {
+    default:
+      break;
+
+      // Indirected typecodes can't occur at "top level" like
+      // this, only nested inside others!
+    case ~0u:
+      if (TAO_debug_level > 0)
+        ACE_DEBUG ((LM_DEBUG,
+                    "indirected typecode at top level!\n"));
       return 0;
+      break;
+
+      // A few have "simple" parameter lists
+    case CORBA::tk_string:
+    case CORBA::tk_wstring:
+      {
+        ACE_TRY_NEW_ENV
+          {
+            CORBA::ULong length =
+              x->length (ACE_TRY_ENV);
+
+            if (!cdr.write_ulong (length))
+              return 0;
+          }
+        ACE_CATCHANY
+          {
+            return 0;
+          }
+        ACE_ENDTRY;
+      }
+      break;
+
+      // The rest have "complex" parameter lists that are
+      // already encoded as bulk octets ... put length, then
+      // octets.
+    case CORBA::tk_objref:
+    case CORBA::tk_struct:
+    case CORBA::tk_union:
+    case CORBA::tk_enum:
+    case CORBA::tk_sequence:
+    case CORBA::tk_array:
+    case CORBA::tk_alias:
+    case CORBA::tk_except:
+      {
+        if (!cdr.write_ulong (x->length_)
+            || !cdr.write_octet_array ((CORBA::Octet*)x->buffer_,
+                                       x->length_))
+          return 0;
+      }
+      break;
     }
-  ACE_ENDTRY;
-  return 0;
+
+  return 1;
 }
 
 CORBA::Boolean
@@ -2468,23 +2714,14 @@ operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x)
 {
   ACE_TRY_NEW_ENV
     {
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_TYPECODE::instance ()->decode (0,
-                                                   &x,
-                                                   0,
-                                                   &cdr,
-                                                   ACE_TRY_ENV);
+      CORBA_TypeCode::_tao_decode (0, cdr, x, ACE_TRY_ENV);
       ACE_TRY_CHECK;
-
-      if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 0;
     }
-  ACE_CATCH (CORBA_Exception, ex)
+  ACE_CATCHANY
     {
       return 0;
     }
   ACE_ENDTRY;
-
   return 1;
 }
 
diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h
index 15656c95464..07d2957f949 100644
--- a/TAO/tao/Typecode.h
+++ b/TAO/tao/Typecode.h
@@ -245,6 +245,13 @@ public:
   // Deprecated, CORBA 1.2, not fully usable. Returns the number of
   // parameters that the typecode takes.
 
+  static void _tao_decode (const CORBA_TypeCode *parent,
+                           TAO_InputCDR &cdr,
+                           CORBA_TypeCode *&child,
+                           CORBA::Environment &ACE_TRY_ENV);
+  // CDR decoding: the >> operator is not enough because we must also
+  // respect the parent/child relationship among TypeCodes.
+
   // private:
   //
   // = The guts of the typecode implementation class
diff --git a/TAO/tao/UIOP_Profile.cpp b/TAO/tao/UIOP_Profile.cpp
index b01ac0b4189..ea3aebb26a1 100644
--- a/TAO/tao/UIOP_Profile.cpp
+++ b/TAO/tao/UIOP_Profile.cpp
@@ -23,7 +23,7 @@ static const char prefix_[] = "uiop";
 
 const char TAO_UIOP_Profile::object_key_delimiter_ = '|';
 
-char 
+char
 TAO_UIOP_Profile::object_key_delimiter (void) const
 {
   return TAO_UIOP_Profile::object_key_delimiter_;
@@ -315,7 +315,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr)
 
   if (minor <= TAO_DEF_GIOP_MINOR)
     this->version_.minor = minor;
-  
+
   char *rendezvous = 0;
 
   // Get rendezvous_point
@@ -324,7 +324,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr)
       ACE_DEBUG ((LM_DEBUG, "error decoding UIOP rendezvous_point"));
       return -1;
     }
-  
+
   if (this->object_addr_.set (rendezvous) == -1)
     {
       if (TAO_debug_level > 0)
diff --git a/TAO/tao/append.cpp b/TAO/tao/append.cpp
index 050ff0d5d71..7b62bfdbef2 100644
--- a/TAO/tao/append.cpp
+++ b/TAO/tao/append.cpp
@@ -104,27 +104,20 @@ TAO_Marshal_Any::append (CORBA::TypeCode_ptr,
   // Typecode of the element that makes the Any.
   CORBA::TypeCode_var elem_tc;
 
-  // Status of append operation.
-  // Decode the typecode description for the element so that we can append the
-  // data appropriately
+  if (!(*src >> elem_tc.inout ()))
+    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                      CORBA::COMPLETED_MAYBE),
+                      CORBA::TypeCode::TRAVERSE_STOP);
+
+  if (!(*dest << elem_tc.in ()))
+    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                      CORBA::COMPLETED_MAYBE),
+                      CORBA::TypeCode::TRAVERSE_STOP);
+
+  // append the data
   CORBA::TypeCode::traverse_status retval =
-    src->decode (CORBA::_tc_TypeCode,
-                 &elem_tc.inout (),
-                 0,
-                 ACE_TRY_ENV);
+    dest->append (elem_tc.in (), src, ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-  if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-    {
-      // encode the typecode
-      retval = dest->encode (CORBA::_tc_TypeCode, &elem_tc, 0, ACE_TRY_ENV);
-      ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-      if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-        {
-          // append the data
-          retval = dest->append (elem_tc.in (), src, ACE_TRY_ENV);
-          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-        }
-    }
 
   if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE)
     {
@@ -358,163 +351,221 @@ TAO_Marshal_Struct::append (CORBA::TypeCode_ptr  tc,
 
 // Encode unions.
 CORBA::TypeCode::traverse_status
-TAO_Marshal_Union::append (CORBA::TypeCode_ptr  tc,
+TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc,
                            TAO_InputCDR *src,
                            TAO_OutputCDR *dest,
                            CORBA::Environment &ACE_TRY_ENV)
 {
-  CORBA::TypeCode::traverse_status retval =
-    CORBA::TypeCode::TRAVERSE_CONTINUE;
+  CORBA::TypeCode_ptr discrim_tc =
+    tc->discriminator_type (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-  CORBA::TypeCode_ptr discrim_tc;
-  CORBA::TypeCode_var member_tc;
-  CORBA::Any_ptr member_label;
-  CORBA::ULongLong discrim_val;
-  CORBA::ULong member_count;
-  CORBA::Long  default_index;
-  CORBA::ULong i;
-  CORBA::TypeCode_ptr default_tc = 0;
-  CORBA::Boolean discrim_matched = 0;
-
-  // get the discriminator type
-  discrim_tc = tc->discriminator_type (ACE_TRY_ENV);
+  CORBA::ULong kind =
+    discrim_tc->kind (ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-  // decode the discriminator value
-  retval = src->decode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV);
+  // Save the discriminator value in a temporary variable...
+  CORBA::Short short_v;
+  CORBA::UShort ushort_v;
+  CORBA::Long long_v;
+  CORBA::ULong ulong_v;
+  CORBA::ULong enum_v;
+  CORBA::Char char_v;
+  CORBA::WChar wchar_v;
+  CORBA::Boolean boolean_v;
+
+  switch (kind)
+    {
+    case CORBA::tk_short:
+      {
+        if (!src->read_short (short_v)
+            || !dest->write_short (short_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_ushort:
+      {
+        if (!src->read_ushort (ushort_v)
+            || !dest->write_ushort (ushort_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_long:
+      {
+        if (!src->read_long (long_v)
+            || !dest->write_long (long_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_ulong:
+      {
+        if (!src->read_ulong (ulong_v)
+            || !dest->write_ulong (ulong_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_enum:
+      {
+        if (!src->read_ulong (enum_v)
+            || !dest->write_ulong (enum_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_char:
+      {
+        if (!src->read_char (char_v)
+            || !dest->write_char (char_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_wchar:
+      {
+        if (!src->read_wchar (wchar_v)
+            || !dest->write_wchar (wchar_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_boolean:
+      {
+        if (!src->read_boolean (boolean_v)
+            || !dest->write_boolean (boolean_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    default:
+      return CORBA::TypeCode::TRAVERSE_STOP;
+    }
+
+  CORBA::ULong member_count =
+    tc->member_count (ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-  if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
+
+  CORBA::ULong current_member = ~0UL;
+  CORBA::ULong default_member = ~0UL;
+  for (CORBA::ULong i = 0;
+       i != member_count && current_member == ~0UL;
+       ++i)
     {
-      // write the discriminant back to the dest
-      retval = dest->encode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV);
+      CORBA::Any *any =
+        tc->member_label (i, ACE_TRY_ENV);
       ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-      if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-        {
-          // now get ready to marshal the actual union value
-          default_index = tc->default_index (ACE_TRY_ENV);
-          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-          member_count = tc->member_count (ACE_TRY_ENV);
+      CORBA::Octet o;
+      if ((*any >>= CORBA::Any::to_octet (o)) && o == 0)
+        {
+          CORBA::ULong default_index =
+            tc->default_index (ACE_TRY_ENV);
           ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-          // check which label value matches with the discriminator
-          // value. Accordingly, marshal the corresponding
-          // member_type. If none match, check if default exists
-          // and marshal accordingly. Otherwise it is an error.
+          if (i != default_index)
+            ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
+                              CORBA::TypeCode::TRAVERSE_STOP);
+          // Found the default branch, save its position and continue
+          // trying to find the current value...
+          default_member = i;
+          continue;
+        }
 
-          for (i = 0; member_count-- != 0; i++)
-            {
-              member_label = tc->member_label (i, ACE_TRY_ENV);
-              ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-
-              CORBA::TypeCode_var type = member_label->type ();
-              // do the matching
-              switch (type->kind (ACE_TRY_ENV))
-                {
-                case CORBA::tk_short:
-                  {
-                    CORBA::Short s;
-                    *member_label >>= s;
-                    if (s == *(CORBA::Short *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_ushort:
-                  {
-                    CORBA::UShort s;
-                    *member_label >>= s;
-                    if (s == *(CORBA::UShort *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_long:
-                  {
-                    CORBA::Long l;
-                    *member_label >>= l;
-                    if (l == *(CORBA::Long *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_ulong:
-                  {
-                    CORBA::ULong l;
-                    *member_label >>= l;
-                    if (l == *(CORBA::ULong *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_enum:
-                  {
-                    CORBA::Long l;
-                    TAO_InputCDR stream (member_label->_tao_get_cdr (),
-                                         member_label->_tao_byte_order ());
-                    (void)stream.decode (discrim_tc, &l, 0, ACE_TRY_ENV);
-                    if (l == *(CORBA::Long *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_char:
-                  {
-                    CORBA::Char c;
-                    *member_label >>= CORBA::Any::to_char (c);
-                    if (c == *(CORBA::Char *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_wchar:
-                  {
-                    CORBA::WChar wc;
-                    *member_label >>= CORBA::Any::to_wchar (wc);
-                    if (wc == *(CORBA::WChar *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                case CORBA::tk_boolean:
-                  {
-                    CORBA::Boolean b;
-                    *member_label >>= CORBA::Any::to_boolean (b);
-                    if (b == *(CORBA::Boolean *) &discrim_val)
-                      discrim_matched = 1;
-                  }
-                  break;
-                default:
-                  ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
-                                    CORBA::TypeCode::TRAVERSE_STOP);
-                }// end of switch
-
-              // get the member typecode
-              member_tc = tc->member_type (i, ACE_TRY_ENV);
-              ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-
-              if (default_index >= 0 && default_index-- == 0)
-                // have we reached the default label?, if so,
-                // save a handle to the typecode for the default
-                default_tc = member_tc.in ();
-              if (discrim_matched)
-                {
-                  // marshal according to the matched typecode
-                  return dest->append (member_tc.in (), src, ACE_TRY_ENV);
-                }
-            } // end of for loop
-          // we are here only if there was no match
-          if (default_tc)
-            {
-              return dest->append (default_tc, src, ACE_TRY_ENV);
-            }
-          else
-            return CORBA::TypeCode::TRAVERSE_CONTINUE;
+      switch (kind)
+        {
+        case CORBA::tk_short:
+          {
+            CORBA::Short d;
+            if ((*any >>= d) && d == short_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_ushort:
+          {
+            CORBA::UShort d;
+            if ((*any >>= d) && d == ushort_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_long:
+          {
+            CORBA::Long d;
+            if ((*any >>= d) && d == long_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_ulong:
+          {
+            CORBA::ULong d;
+            if ((*any >>= d) && d == ulong_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_enum:
+          {
+            CORBA::ULong d;
+            // @@ Will this work????
+            if ((*any >>= d) && d == enum_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_char:
+          {
+            CORBA::Char d;
+            if ((*any >>= CORBA::Any::to_char (d)) && d == char_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_wchar:
+          {
+            CORBA::WChar d;
+            if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_boolean:
+          {
+            CORBA::Boolean d;
+            if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v)
+              current_member = i;
+          }
+          break;
+
+        default:
+          return CORBA::TypeCode::TRAVERSE_STOP;
         }
-      else
+    }
+
+  if (current_member == ~0UL)
+    {
+      // Cannot find the current member, check if there is a
+      // default...
+      if (default_member != ~0UL)
         {
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                            CORBA::COMPLETED_MAYBE),
-                            CORBA::TypeCode::TRAVERSE_STOP);
+          // Good, use the default to append...
+          CORBA::TypeCode_ptr member_tc =
+            tc->member_type (default_member, ACE_TRY_ENV);
+          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+          return dest->append (member_tc, src, ACE_TRY_ENV);
         }
+      return CORBA::TypeCode::TRAVERSE_STOP;
     }
 
-  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                    CORBA::COMPLETED_MAYBE),
-                    CORBA::TypeCode::TRAVERSE_STOP);
+  // If we found the member successfully then just use that one...
+  CORBA::TypeCode_ptr member_tc =
+    tc->member_type (current_member, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+  return dest->append (member_tc, src, ACE_TRY_ENV);
 }
 
 // decode string
diff --git a/TAO/tao/skip.cpp b/TAO/tao/skip.cpp
index de8d3194ef1..77222f77387 100644
--- a/TAO/tao/skip.cpp
+++ b/TAO/tao/skip.cpp
@@ -103,19 +103,10 @@ TAO_Marshal_Any::skip (CORBA::TypeCode_ptr,
   TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context);
 
   // Status of encode operation.
-  CORBA::TypeCode::traverse_status retval =
-    stream->decode (CORBA::_tc_TypeCode,
-                    &elem_tc.inout (),
-                    0,
-                    ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+  if (!(*stream >> elem_tc.inout ()))
+    return CORBA::TypeCode::TRAVERSE_STOP;
 
-  if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
-    {
-      retval = stream->skip (elem_tc.in (), ACE_TRY_ENV);
-      ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
-    }
-  return retval;
+  return stream->skip (elem_tc.in (), ACE_TRY_ENV);
 }
 
 CORBA::TypeCode::traverse_status
@@ -356,145 +347,211 @@ TAO_Marshal_Union::skip (CORBA::TypeCode_ptr  tc,
                          void *context,
                          CORBA::Environment &ACE_TRY_ENV)
 {
-  // Context is the CDR stream.
-  TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context);
-
-  CORBA::TypeCode::traverse_status retval =
-    CORBA::TypeCode::TRAVERSE_CONTINUE;
+  TAO_InputCDR *src =
+    ACE_reinterpret_cast (TAO_InputCDR*, context);
 
-  CORBA::TypeCode_var discrim_tc;
-  CORBA::TypeCode_var member_tc;
-  CORBA::Any_ptr member_label;
-  CORBA::ULongLong discrim_val;
-  CORBA::ULong member_count;
-  CORBA::Long  default_index;
-  CORBA::ULong i;
-  CORBA::TypeCode_ptr default_tc = 0;
-  CORBA::Boolean discrim_matched = 0;
-
-  // get the discriminator type which will enable us to skip the discriminator
-  // value
-  discrim_tc = tc->discriminator_type (ACE_TRY_ENV);
+  CORBA::TypeCode_ptr discrim_tc =
+    tc->discriminator_type (ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-  // decode the discriminator value
-  retval = stream->decode (discrim_tc.in (), &discrim_val, 0, ACE_TRY_ENV);
+  CORBA::ULong kind =
+    discrim_tc->kind (ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-  if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE)
+  // Save the discriminator value in a temporary variable...
+  CORBA::Short short_v;
+  CORBA::UShort ushort_v;
+  CORBA::Long long_v;
+  CORBA::ULong ulong_v;
+  CORBA::ULong enum_v;
+  CORBA::Char char_v;
+  CORBA::WChar wchar_v;
+  CORBA::Boolean boolean_v;
+
+  switch (kind)
     {
-      // now get ready to skip the actual union value
-      default_index = tc->default_index (ACE_TRY_ENV);
-      ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+    case CORBA::tk_short:
+      {
+        if (!src->read_short (short_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-      member_count = tc->member_count (ACE_TRY_ENV);
-      ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+    case CORBA::tk_ushort:
+      {
+        if (!src->read_ushort (ushort_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-      // check which label value matches with the discriminator
-      // value. Accordingly, marshal the corresponding
-      // member_type. If none match, check if default exists
-      // and marshal accordingly. Otherwise it is an error.
+    case CORBA::tk_long:
+      {
+        if (!src->read_long (long_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-      for (i = 0; i < member_count; i++)
-        {
-          member_label = tc->member_label (i, ACE_TRY_ENV);
-          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+    case CORBA::tk_ulong:
+      {
+        if (!src->read_ulong (ulong_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-          // do the matching
-          CORBA::TypeCode_var type = member_label->type ();
-          CORBA::ULong kind = type->kind (ACE_TRY_ENV);
-          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+    case CORBA::tk_enum:
+      {
+        if (!src->read_ulong (enum_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-          switch (kind)
-            {
-            case CORBA::tk_short:
-              {
-                CORBA::Short s;
-                *member_label >>= s;
-                if (s == *(CORBA::Short *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_ushort:
-              {
-                CORBA::UShort s;
-                *member_label >>= s;
-                if (s == *(CORBA::UShort *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_long:
-              {
-                CORBA::Long l;
-                *member_label >>= l;
-                if (l == *(CORBA::Long *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_ulong:
-              {
-                CORBA::ULong l;
-                *member_label >>= l;
-                if (l == *(CORBA::ULong *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_enum:
-              {
-                CORBA::ULong ul;
-                TAO_InputCDR stream (member_label->_tao_get_cdr (),
-                                     member_label->_tao_byte_order ());
-                (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV);
-                if (ul == *(CORBA::ULong *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_char:
-              {
-                CORBA::Char c;
-                *member_label >>= CORBA::Any::to_char (c);
-                if (c == *(CORBA::Char *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            case CORBA::tk_wchar:
-              CORBA::WChar wc;
-              *member_label >>= CORBA::Any::to_wchar (wc);
-              if (wc == *(CORBA::WChar *) &discrim_val)
-                discrim_matched = 1;
-              break;
-            case CORBA::tk_boolean:
-              {
-                CORBA::Boolean b;
-                *member_label >>= CORBA::Any::to_boolean (b);
-                if (b == *(CORBA::Boolean *) &discrim_val)
-                  discrim_matched = 1;
-              }
-              break;
-            default:
-              ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
-                                CORBA::TypeCode::TRAVERSE_STOP);
-            }// end of switch
+    case CORBA::tk_char:
+      {
+        if (!src->read_char (char_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_wchar:
+      {
+        if (!src->read_wchar (wchar_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
+
+    case CORBA::tk_boolean:
+      {
+        if (!src->read_boolean (boolean_v))
+          return CORBA::TypeCode::TRAVERSE_STOP;
+      }
+      break;
 
-          // get the member typecode
-          member_tc = tc->member_type (i, ACE_TRY_ENV);
+    default:
+      return CORBA::TypeCode::TRAVERSE_STOP;
+    }
+
+  CORBA::ULong member_count =
+    tc->member_count (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+
+  CORBA::ULong current_member = ~0UL;
+  CORBA::ULong default_member = ~0UL;
+  for (CORBA::ULong i = 0;
+       i != member_count && current_member == ~0UL;
+       ++i)
+    {
+      CORBA::Any *any =
+        tc->member_label (i, ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+
+      CORBA::Octet o;
+      if ((*any >>= CORBA::Any::to_octet (o)) && o == 0)
+        {
+          CORBA::ULong default_index =
+            tc->default_index (ACE_TRY_ENV);
           ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
-          // have we reached the default label, if so save a handle to
-          // the typecode for the default
+          if (i != default_index)
+            ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
+                              CORBA::TypeCode::TRAVERSE_STOP);
+          // Found the default branch, save its position and continue
+          // trying to find the current value...
+          default_member = i;
+          continue;
+        }
 
-          if (default_index >= 0 && default_index-- == 0)
-            default_tc = member_tc.in ();
-          if (discrim_matched)
-            {
-              // marshal according to the matched typecode
-              return stream->skip (member_tc.in (), ACE_TRY_ENV);
-            }
+      switch (kind)
+        {
+        case CORBA::tk_short:
+          {
+            CORBA::Short d;
+            if ((*any >>= d) && d == short_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_ushort:
+          {
+            CORBA::UShort d;
+            if ((*any >>= d) && d == ushort_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_long:
+          {
+            CORBA::Long d;
+            if ((*any >>= d) && d == long_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_ulong:
+          {
+            CORBA::ULong d;
+            if ((*any >>= d) && d == ulong_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_enum:
+          {
+            CORBA::ULong d;
+            // @@ Will this work????
+            if ((*any >>= d) && d == enum_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_char:
+          {
+            CORBA::Char d;
+            if ((*any >>= CORBA::Any::to_char (d)) && d == char_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_wchar:
+          {
+            CORBA::WChar d;
+            if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v)
+              current_member = i;
+          }
+          break;
+
+        case CORBA::tk_boolean:
+          {
+            CORBA::Boolean d;
+            if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v)
+              current_member = i;
+          }
+          break;
+
+        default:
+          return CORBA::TypeCode::TRAVERSE_STOP;
+        }
+    }
+
+  if (current_member == ~0UL)
+    {
+      // Cannot find the current member, check if there is a
+      // default...
+      if (default_member != ~0UL)
+        {
+          // Good, use the default to append...
+          CORBA::TypeCode_ptr member_tc =
+            tc->member_type (default_member, ACE_TRY_ENV);
+          ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+          return src->skip (member_tc, ACE_TRY_ENV);
         }
-      if (default_tc != 0)
-        return stream->skip (default_tc, ACE_TRY_ENV);
+      return CORBA::TypeCode::TRAVERSE_STOP;
     }
-  return retval;
+
+  // If we found the member successfully then just use that one...
+  CORBA::TypeCode_ptr member_tc =
+    tc->member_type (current_member, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
+  return src->skip (member_tc, ACE_TRY_ENV);
 }
 
 // decode string
diff --git a/TAO/tests/Param_Test/Makefile b/TAO/tests/Param_Test/Makefile
index 6bb792ca728..512adb688c2 100644
--- a/TAO/tests/Param_Test/Makefile
+++ b/TAO/tests/Param_Test/Makefile
@@ -67,12 +67,18 @@ CLI_FILES =	param_testCli	\
 		multdim_array	\
 		complex_any
 
+ANYOP_FILES =	param_testCli	\
+		anyop
+
+
 PARAM_TEST_SVR_OBJS = $(addsuffix .o,$(SVR_FILES))
 PARAM_TEST_CLT_OBJS = $(addsuffix .o,$(CLI_FILES))
+PARAM_TEST_ANYOP_OBJS = $(addsuffix .o,$(ANYOP_FILES))
 SRC	= $(addsuffix .cpp,$(SVR_FILES)) \
-	  $(addsuffix .cpp,$(CLI_FILES))
+	  $(addsuffix .cpp,$(CLI_FILES)) \
+	  $(addsuffix .cpp,$(ANYOP_FILES))
 
-BIN = server client
+BIN = server client anyop
 
 #----------------------------------------------------------------------------
 #	Include macros and targets
@@ -111,6 +117,9 @@ server:	$(addprefix $(VDIR),$(PARAM_TEST_SVR_OBJS))
 client:	$(addprefix $(VDIR),$(PARAM_TEST_CLT_OBJS))
 	$(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK)
 
+anyop: $(addprefix $(VDIR),$(PARAM_TEST_ANYOP_OBJS))
+	$(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK)
+
 realclean: clean
 	-$(RM) param_testCli.* param_testSer.* param_testSer_T.*
 
@@ -124,6 +133,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -140,8 +150,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -156,6 +169,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -278,14 +300,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -389,12 +403,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i
 
 .obj/param_testSer.o .obj/param_testSer.so .shobj/param_testSer.o .shobj/param_testSer.so: param_testSer.cpp param_testSer.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -411,8 +427,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -427,6 +446,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -549,14 +577,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -660,14 +680,16 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \
- param_testSer.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i param_testSer_T.h param_testSer_T.i \
+ param_testSer_T.cpp param_testSer.i
 
-.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp $(ACE_ROOT)/ace/Get_Opt.h \
+.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp \
+ $(ACE_ROOT)/ace/Get_Opt.h \
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -678,16 +700,19 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Log_Priority.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/ACE.i \
- $(ACE_ROOT)/ace/Get_Opt.i param_test_i.h \
- param_testSer.h param_testCli.h \
+ $(ACE_ROOT)/ace/Get_Opt.i \
+ param_test_i.h param_testSer.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(TAO_ROOT)/tao/corbafwd.h \
  $(ACE_ROOT)/ace/CDR_Stream.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -702,6 +727,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -824,14 +858,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -935,14 +961,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \
- param_testSer.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i param_testSer_T.h param_testSer_T.i \
+ param_testSer_T.cpp param_testSer.i
 
 .obj/param_test_i.o .obj/param_test_i.so .shobj/param_test_i.o .shobj/param_test_i.so: param_test_i.cpp \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -959,8 +986,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -975,6 +1005,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -1097,14 +1136,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -1208,14 +1239,16 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_test_i.h \
- param_testSer.h param_testCli.h param_testCli.i param_testSer_T.h \
- param_testSer_T.i param_testSer_T.cpp param_testSer.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_test_i.h param_testSer.h param_testCli.h param_testCli.i \
+ param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \
+ param_testSer.i
 
 .obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -1232,8 +1265,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -1248,6 +1284,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -1370,14 +1415,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -1481,12 +1518,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i
 
 .obj/param_testCli.o .obj/param_testCli.so .shobj/param_testCli.o .shobj/param_testCli.so: param_testCli.cpp param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -1503,8 +1542,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -1519,6 +1561,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -1641,14 +1692,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -1752,7 +1795,8 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i
 
 .obj/driver.o .obj/driver.so .shobj/driver.o .shobj/driver.so: driver.cpp driver.h options.h \
  $(ACE_ROOT)/ace/Singleton.h \
@@ -1760,6 +1804,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -1796,6 +1841,10 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -2023,21 +2072,21 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.h \
- param_testCli.i results.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.h param_testCli.i results.h \
  $(ACE_ROOT)/ace/Profile_Timer.h \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/High_Res_Timer.h \
  $(ACE_ROOT)/ace/High_Res_Timer.i \
- $(ACE_ROOT)/ace/Profile_Timer.i client.h \
- client.cpp tests.h any.h bd_long_seq.h bd_short_seq.h bd_str_seq.h \
- bd_wstr_seq.h bd_string.h bd_wstring.h bd_struct_seq.h bd_array_seq.h \
- fixed_array.h fixed_struct.h nested_struct.h recursive_struct.h \
- helper.h objref_struct.h objref.h short.h ulonglong.h typecode.h \
- ub_any_seq.h ub_long_seq.h ub_objref_seq.h ub_short_seq.h \
- ub_str_seq.h ub_wstr_seq.h ub_string.h ub_wstring.h ub_struct_seq.h \
- ub_array_seq.h var_array.h var_struct.h except.h big_union.h \
- recursive_union.h complex_any.h \
+ $(ACE_ROOT)/ace/Profile_Timer.i \
+ client.h client.cpp tests.h any.h bd_long_seq.h bd_short_seq.h \
+ bd_str_seq.h bd_wstr_seq.h bd_string.h bd_wstring.h bd_struct_seq.h \
+ bd_array_seq.h fixed_array.h fixed_struct.h nested_struct.h \
+ recursive_struct.h helper.h objref_struct.h objref.h short.h \
+ ulonglong.h typecode.h ub_any_seq.h ub_long_seq.h ub_objref_seq.h \
+ ub_short_seq.h ub_str_seq.h ub_wstr_seq.h ub_string.h ub_wstring.h \
+ ub_struct_seq.h ub_array_seq.h var_array.h var_struct.h except.h \
+ big_union.h recursive_union.h complex_any.h multdim_array.h \
  $(ACE_ROOT)/ace/Get_Opt.h \
  $(ACE_ROOT)/ace/Get_Opt.i
 
@@ -2047,6 +2096,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -2083,6 +2133,10 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -2310,19 +2364,21 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i results.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ results.h \
  $(ACE_ROOT)/ace/Profile_Timer.h \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/High_Res_Timer.h \
  $(ACE_ROOT)/ace/High_Res_Timer.i \
- $(ACE_ROOT)/ace/Profile_Timer.i client.h \
- param_testCli.h param_testCli.i client.cpp
+ $(ACE_ROOT)/ace/Profile_Timer.i \
+ client.h param_testCli.h param_testCli.i client.cpp
 
 .obj/options.o .obj/options.so .shobj/options.o .shobj/options.so: options.cpp \
  $(ACE_ROOT)/ace/Read_Buffer.h \
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -2335,8 +2391,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -2351,6 +2410,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -2370,14 +2438,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Read_Buffer.i \
  $(ACE_ROOT)/ace/Get_Opt.h \
  $(ACE_ROOT)/ace/Get_Opt.i options.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/corba.h \
  $(TAO_ROOT)/tao/corbafwd.h \
  $(ACE_ROOT)/ace/CDR_Stream.h \
@@ -2598,13 +2658,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
  $(ACE_ROOT)/ace/Trace.h \
  $(ACE_ROOT)/ace/OS.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
- $(ACE_ROOT)/ace/Log_Record.i results.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ results.h \
  $(TAO_ROOT)/tao/corba.h \
  $(TAO_ROOT)/tao/corbafwd.h \
  $(ACE_ROOT)/ace/CDR_Stream.h \
@@ -2613,8 +2675,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -2629,6 +2694,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -2751,14 +2825,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -2873,6 +2939,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -2889,8 +2956,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -2905,6 +2975,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -3027,14 +3106,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -3138,12 +3209,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i
 
 .obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -3160,8 +3233,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -3176,6 +3252,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -3298,14 +3383,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -3409,12 +3486,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i
 
 .obj/any.o .obj/any.so .shobj/any.o .shobj/any.so: any.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -3431,8 +3510,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -3447,6 +3529,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -3569,14 +3660,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -3680,13 +3763,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- any.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i any.h
 
 .obj/bd_long_seq.o .obj/bd_long_seq.so .shobj/bd_long_seq.o .shobj/bd_long_seq.so: bd_long_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -3703,8 +3787,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -3719,6 +3806,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -3841,14 +3937,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -3952,13 +4040,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_long_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_long_seq.h
 
 .obj/bd_short_seq.o .obj/bd_short_seq.so .shobj/bd_short_seq.o .shobj/bd_short_seq.so: bd_short_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -3975,8 +4064,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -3991,6 +4083,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -4113,14 +4214,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -4224,13 +4317,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_short_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_short_seq.h
 
 .obj/bd_str_seq.o .obj/bd_str_seq.so .shobj/bd_str_seq.o .shobj/bd_str_seq.so: bd_str_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -4247,8 +4341,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -4263,6 +4360,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -4385,14 +4491,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -4496,13 +4594,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_str_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_str_seq.h
 
 .obj/bd_wstr_seq.o .obj/bd_wstr_seq.so .shobj/bd_wstr_seq.o .shobj/bd_wstr_seq.so: bd_wstr_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -4519,8 +4618,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -4535,6 +4637,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -4657,14 +4768,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -4768,13 +4871,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_wstr_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_wstr_seq.h
 
 .obj/bd_string.o .obj/bd_string.so .shobj/bd_string.o .shobj/bd_string.so: bd_string.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -4791,8 +4895,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -4807,6 +4914,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -4929,14 +5045,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -5040,13 +5148,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_string.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_string.h
 
 .obj/bd_wstring.o .obj/bd_wstring.so .shobj/bd_wstring.o .shobj/bd_wstring.so: bd_wstring.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -5063,8 +5172,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -5079,6 +5191,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -5201,14 +5322,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -5312,13 +5425,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_wstring.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_wstring.h
 
 .obj/bd_struct_seq.o .obj/bd_struct_seq.so .shobj/bd_struct_seq.o .shobj/bd_struct_seq.so: bd_struct_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -5335,8 +5449,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -5351,6 +5468,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -5473,14 +5599,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -5584,13 +5702,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_struct_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_struct_seq.h
 
 .obj/bd_array_seq.o .obj/bd_array_seq.so .shobj/bd_array_seq.o .shobj/bd_array_seq.so: bd_array_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -5607,8 +5726,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -5623,6 +5745,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -5745,14 +5876,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -5856,13 +5979,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- bd_array_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i bd_array_seq.h
 
 .obj/fixed_array.o .obj/fixed_array.so .shobj/fixed_array.o .shobj/fixed_array.so: fixed_array.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -5879,8 +6003,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -5895,6 +6022,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -6017,14 +6153,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -6128,13 +6256,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- fixed_array.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i fixed_array.h
 
 .obj/fixed_struct.o .obj/fixed_struct.so .shobj/fixed_struct.o .shobj/fixed_struct.so: fixed_struct.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -6151,8 +6280,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -6167,6 +6299,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -6289,14 +6430,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -6400,13 +6533,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- fixed_struct.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i fixed_struct.h
 
 .obj/nested_struct.o .obj/nested_struct.so .shobj/nested_struct.o .shobj/nested_struct.so: nested_struct.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -6423,8 +6557,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -6439,6 +6576,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -6561,14 +6707,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -6672,13 +6810,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- nested_struct.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i nested_struct.h
 
 .obj/objref_struct.o .obj/objref_struct.so .shobj/objref_struct.o .shobj/objref_struct.so: objref_struct.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -6695,8 +6834,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -6711,6 +6853,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -6833,14 +6984,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -6944,13 +7087,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- objref_struct.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i objref_struct.h
 
 .obj/objref.o .obj/objref.so .shobj/objref.o .shobj/objref.so: objref.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -6967,8 +7111,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -6983,6 +7130,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -7105,14 +7261,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -7216,13 +7364,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- objref.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i objref.h
 
 .obj/short.o .obj/short.so .shobj/short.o .shobj/short.so: short.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -7239,8 +7388,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -7255,6 +7407,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -7377,14 +7538,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -7488,13 +7641,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- short.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i short.h
 
 .obj/ulonglong.o .obj/ulonglong.so .shobj/ulonglong.o .shobj/ulonglong.so: ulonglong.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -7511,8 +7665,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -7527,6 +7684,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -7649,14 +7815,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -7760,13 +7918,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ulonglong.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ulonglong.h
 
 .obj/typecode.o .obj/typecode.so .shobj/typecode.o .shobj/typecode.so: typecode.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -7783,8 +7942,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -7799,6 +7961,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -7921,14 +8092,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -8032,13 +8195,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- typecode.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i typecode.h
 
 .obj/ub_any_seq.o .obj/ub_any_seq.so .shobj/ub_any_seq.o .shobj/ub_any_seq.so: ub_any_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -8055,8 +8219,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -8071,6 +8238,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -8193,14 +8369,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -8304,13 +8472,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_any_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_any_seq.h
 
 .obj/ub_long_seq.o .obj/ub_long_seq.so .shobj/ub_long_seq.o .shobj/ub_long_seq.so: ub_long_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -8327,8 +8496,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -8343,6 +8515,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -8465,14 +8646,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -8576,13 +8749,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_long_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_long_seq.h
 
 .obj/ub_objref_seq.o .obj/ub_objref_seq.so .shobj/ub_objref_seq.o .shobj/ub_objref_seq.so: ub_objref_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -8599,8 +8773,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -8615,6 +8792,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -8737,14 +8923,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -8848,13 +9026,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_objref_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_objref_seq.h
 
 .obj/ub_short_seq.o .obj/ub_short_seq.so .shobj/ub_short_seq.o .shobj/ub_short_seq.so: ub_short_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -8871,8 +9050,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -8887,6 +9069,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -9009,14 +9200,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -9120,13 +9303,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_short_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_short_seq.h
 
 .obj/ub_str_seq.o .obj/ub_str_seq.so .shobj/ub_str_seq.o .shobj/ub_str_seq.so: ub_str_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -9143,8 +9327,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -9159,6 +9346,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -9281,14 +9477,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -9392,13 +9580,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_str_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_str_seq.h
 
 .obj/ub_wstr_seq.o .obj/ub_wstr_seq.so .shobj/ub_wstr_seq.o .shobj/ub_wstr_seq.so: ub_wstr_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -9415,8 +9604,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -9431,6 +9623,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -9553,14 +9754,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -9664,13 +9857,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_wstr_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_wstr_seq.h
 
 .obj/ub_string.o .obj/ub_string.so .shobj/ub_string.o .shobj/ub_string.so: ub_string.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -9687,8 +9881,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -9703,6 +9900,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -9825,14 +10031,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -9936,13 +10134,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_string.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_string.h
 
 .obj/ub_wstring.o .obj/ub_wstring.so .shobj/ub_wstring.o .shobj/ub_wstring.so: ub_wstring.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -9959,8 +10158,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -9975,6 +10177,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -10097,14 +10308,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -10208,13 +10411,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_wstring.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_wstring.h
 
 .obj/ub_struct_seq.o .obj/ub_struct_seq.so .shobj/ub_struct_seq.o .shobj/ub_struct_seq.so: ub_struct_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -10231,8 +10435,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -10247,6 +10454,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -10369,14 +10585,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -10480,13 +10688,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_struct_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_struct_seq.h
 
 .obj/ub_array_seq.o .obj/ub_array_seq.so .shobj/ub_array_seq.o .shobj/ub_array_seq.so: ub_array_seq.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -10503,8 +10712,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -10519,6 +10731,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -10641,14 +10862,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -10752,13 +10965,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- ub_array_seq.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i ub_array_seq.h
 
 .obj/var_array.o .obj/var_array.so .shobj/var_array.o .shobj/var_array.so: var_array.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -10775,8 +10989,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -10791,6 +11008,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -10913,14 +11139,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -11024,13 +11242,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- var_array.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i var_array.h
 
 .obj/var_struct.o .obj/var_struct.so .shobj/var_struct.o .shobj/var_struct.so: var_struct.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -11047,8 +11266,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -11063,6 +11285,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -11185,14 +11416,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -11296,13 +11519,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- var_struct.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i var_struct.h
 
 .obj/recursive_struct.o .obj/recursive_struct.so .shobj/recursive_struct.o .shobj/recursive_struct.so: recursive_struct.cpp recursive_struct.h \
- param_testCli.h $(TAO_ROOT)/tao/corba.h \
+ param_testCli.h \
+ $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -11319,8 +11544,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -11335,6 +11563,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -11457,14 +11694,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -11568,13 +11797,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- helper.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i helper.h
 
 .obj/except.o .obj/except.so .shobj/except.o .shobj/except.so: except.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -11591,8 +11821,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -11607,6 +11840,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -11729,14 +11971,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -11840,13 +12074,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- except.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i except.h
 
 .obj/big_union.o .obj/big_union.so .shobj/big_union.o .shobj/big_union.so: big_union.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -11863,8 +12098,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -11879,6 +12117,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -12001,14 +12248,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -12112,13 +12351,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- big_union.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i big_union.h
 
 .obj/recursive_union.o .obj/recursive_union.so .shobj/recursive_union.o .shobj/recursive_union.so: recursive_union.cpp recursive_union.h \
- param_testCli.h $(TAO_ROOT)/tao/corba.h \
+ param_testCli.h \
+ $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -12135,8 +12376,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -12151,6 +12395,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -12273,7 +12526,152 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
+ $(TAO_ROOT)/tao/POA.h \
+ $(TAO_ROOT)/tao/Object_Adapter.h \
+ $(TAO_ROOT)/tao/Key_Adapters.h \
+ $(ACE_ROOT)/ace/Map.h \
+ $(ACE_ROOT)/ace/Map.i \
+ $(ACE_ROOT)/ace/Map_T.h \
+ $(ACE_ROOT)/ace/Pair.h \
+ $(ACE_ROOT)/ace/Pair.i \
+ $(ACE_ROOT)/ace/Pair_T.h \
+ $(ACE_ROOT)/ace/Pair_T.i \
+ $(ACE_ROOT)/ace/Pair_T.cpp \
+ $(ACE_ROOT)/ace/Map_Manager.h \
+ $(ACE_ROOT)/ace/Map_Manager.i \
+ $(ACE_ROOT)/ace/Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Active_Map_Manager.h \
+ $(ACE_ROOT)/ace/Active_Map_Manager.i \
+ $(ACE_ROOT)/ace/Active_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Active_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \
+ $(ACE_ROOT)/ace/Map_T.i \
+ $(ACE_ROOT)/ace/Map_T.cpp \
+ $(TAO_ROOT)/tao/Key_Adapters.i \
+ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/poa_macros.h \
+ $(TAO_ROOT)/tao/POAS.h \
+ $(TAO_ROOT)/tao/POA_CORBA.h \
+ $(TAO_ROOT)/tao/DynAnyC.h \
+ $(TAO_ROOT)/tao/DynAnyC.i \
+ $(TAO_ROOT)/tao/DomainC.h \
+ $(TAO_ROOT)/tao/DomainC.i \
+ $(TAO_ROOT)/tao/POAS.i \
+ $(TAO_ROOT)/tao/Active_Object_Map.h \
+ $(TAO_ROOT)/tao/Active_Object_Map.i \
+ $(TAO_ROOT)/tao/Object_Adapter.i \
+ $(TAO_ROOT)/tao/POAManager.h \
+ $(TAO_ROOT)/tao/POAManager.i \
+ $(TAO_ROOT)/tao/ImplRepoC.h \
+ $(TAO_ROOT)/tao/Operation_Table.h \
+ $(TAO_ROOT)/tao/Stub.h \
+ $(TAO_ROOT)/tao/Pluggable.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.i \
+ $(ACE_ROOT)/ace/Message_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Synch_Options.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/Strategies_T.i \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Strategies.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(TAO_ROOT)/tao/Pluggable.i \
+ $(TAO_ROOT)/tao/MProfile.h \
+ $(TAO_ROOT)/tao/Profile.h \
+ $(TAO_ROOT)/tao/Tagged_Components.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.i \
+ $(TAO_ROOT)/tao/Tagged_Components.i \
+ $(TAO_ROOT)/tao/Profile.i \
+ $(TAO_ROOT)/tao/MProfile.i \
+ $(TAO_ROOT)/tao/Stub.i \
+ $(TAO_ROOT)/tao/ORB_Core.h \
+ $(TAO_ROOT)/tao/Policy_Manager.h \
+ $(TAO_ROOT)/tao/Policy_Manager.i \
+ $(TAO_ROOT)/tao/Resource_Factory.h \
+ $(TAO_ROOT)/tao/Protocol_Factory.h \
+ $(TAO_ROOT)/tao/params.h \
+ $(TAO_ROOT)/tao/params.i \
+ $(TAO_ROOT)/tao/ORB_Core.i \
+ $(ACE_ROOT)/ace/Dynamic_Service.h \
+ $(ACE_ROOT)/ace/Dynamic_Service.cpp \
+ $(TAO_ROOT)/tao/Invocation.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.i \
+ $(TAO_ROOT)/tao/TAOC.h \
+ $(TAO_ROOT)/tao/TAOC.i \
+ $(TAO_ROOT)/tao/Invocation.i \
+ $(TAO_ROOT)/tao/ImplRepoC.i \
+ $(TAO_ROOT)/tao/POA.i \
+ $(TAO_ROOT)/tao/debug.h \
+ $(TAO_ROOT)/tao/Client_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \
+ $(TAO_ROOT)/tao/DynAny_i.h \
+ $(TAO_ROOT)/tao/Union.h \
+ $(TAO_ROOT)/tao/ValueBase.h \
+ $(TAO_ROOT)/tao/ValueBase.i \
+ $(TAO_ROOT)/tao/ValueFactory.h \
+ $(TAO_ROOT)/tao/ValueFactory.i \
+ $(TAO_ROOT)/tao/ObjectIDList.h \
+ $(TAO_ROOT)/tao/ObjectIDList.i \
+ $(TAO_ROOT)/tao/WrongTransactionC.h \
+ $(TAO_ROOT)/tao/InterfaceC.h \
+ $(TAO_ROOT)/tao/BoundsC.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i helper.h
+
+.obj/multdim_array.o .obj/multdim_array.so .shobj/multdim_array.o .shobj/multdim_array.so: multdim_array.cpp helper.h param_testCli.h \
+ $(TAO_ROOT)/tao/corba.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(TAO_ROOT)/tao/corbafwd.h \
+ $(ACE_ROOT)/ace/CDR_Stream.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
  $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp \
  $(ACE_ROOT)/ace/Object_Manager.h \
@@ -12281,6 +12679,130 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Managed_Object.h \
  $(ACE_ROOT)/ace/Managed_Object.i \
  $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/CDR_Stream.i \
+ $(TAO_ROOT)/tao/try_macros.h \
+ $(TAO_ROOT)/tao/orbconf.h \
+ $(ACE_ROOT)/ace/CORBA_macros.h \
+ $(TAO_ROOT)/tao/corbafwd.i \
+ $(TAO_ROOT)/tao/Environment.h \
+ $(TAO_ROOT)/tao/Environment.i \
+ $(TAO_ROOT)/tao/ORB.h \
+ $(TAO_ROOT)/tao/Exception.h \
+ $(TAO_ROOT)/tao/Exception.i \
+ $(TAO_ROOT)/tao/IOR_LookupTable.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(TAO_ROOT)/tao/Services.h \
+ $(TAO_ROOT)/tao/Sequence.h \
+ $(TAO_ROOT)/tao/Managed_Types.h \
+ $(TAO_ROOT)/tao/Managed_Types.i \
+ $(TAO_ROOT)/tao/Sequence.i \
+ $(TAO_ROOT)/tao/Sequence_T.h \
+ $(TAO_ROOT)/tao/Sequence_T.i \
+ $(TAO_ROOT)/tao/Sequence_T.cpp \
+ $(TAO_ROOT)/tao/varout.h \
+ $(TAO_ROOT)/tao/Object.h \
+ $(TAO_ROOT)/tao/Object.i \
+ $(TAO_ROOT)/tao/varout.i \
+ $(TAO_ROOT)/tao/varout.cpp \
+ $(TAO_ROOT)/tao/Services.i \
+ $(TAO_ROOT)/tao/IORManipulation.h \
+ $(TAO_ROOT)/tao/IORS.h \
+ $(TAO_ROOT)/tao/IORC.h \
+ $(TAO_ROOT)/tao/CDR.h \
+ $(TAO_ROOT)/tao/Typecode.h \
+ $(TAO_ROOT)/tao/Typecode.i \
+ $(TAO_ROOT)/tao/CDR.i \
+ $(TAO_ROOT)/tao/IORC.i \
+ $(TAO_ROOT)/tao/Servant_Base.h \
+ $(TAO_ROOT)/tao/POAC.h \
+ $(TAO_ROOT)/tao/PolicyC.h \
+ $(TAO_ROOT)/tao/CurrentC.h \
+ $(TAO_ROOT)/tao/CurrentC.i \
+ $(TAO_ROOT)/tao/PolicyC.i \
+ $(TAO_ROOT)/tao/POAC.i \
+ $(TAO_ROOT)/tao/Servant_Base.i \
+ $(TAO_ROOT)/tao/IORS.i \
+ $(TAO_ROOT)/tao/Interceptor.h \
+ $(TAO_ROOT)/tao/InterceptorS.h \
+ $(TAO_ROOT)/tao/InterceptorC.h \
+ $(TAO_ROOT)/tao/IOPC.h \
+ $(TAO_ROOT)/tao/IOPC.i \
+ $(TAO_ROOT)/tao/Any.h \
+ $(TAO_ROOT)/tao/Any.i \
+ $(TAO_ROOT)/tao/InterceptorC.i \
+ $(TAO_ROOT)/tao/Interceptor.i \
+ $(TAO_ROOT)/tao/ORB.i \
+ $(TAO_ROOT)/tao/NVList.h \
+ $(TAO_ROOT)/tao/NVList.i \
+ $(TAO_ROOT)/tao/Principal.h \
+ $(TAO_ROOT)/tao/Principal.i \
+ $(TAO_ROOT)/tao/Request.h \
+ $(TAO_ROOT)/tao/Context.h \
+ $(TAO_ROOT)/tao/Context.i \
+ $(TAO_ROOT)/tao/MessagingC.h \
+ $(TAO_ROOT)/tao/TimeBaseC.h \
+ $(TAO_ROOT)/tao/TimeBaseC.i \
+ $(TAO_ROOT)/tao/PollableC.h \
+ $(TAO_ROOT)/tao/MessagingC.i \
+ $(TAO_ROOT)/tao/Request.i \
+ $(TAO_ROOT)/tao/Server_Request.h \
+ $(TAO_ROOT)/tao/Object_KeyC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.i \
+ $(TAO_ROOT)/tao/GIOP.h \
+ $(TAO_ROOT)/tao/GIOP.i \
+ $(TAO_ROOT)/tao/Server_Request.i \
+ $(TAO_ROOT)/tao/Marshal.h \
+ $(TAO_ROOT)/tao/Marshal.i \
+ $(TAO_ROOT)/tao/singletons.h \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -12384,15 +12906,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- helper.h
-
-.obj/multdim_array.o .obj/multdim_array.so .shobj/multdim_array.o .shobj/multdim_array.so: multdim_array.cpp
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i multdim_array.h
 
 .obj/complex_any.o .obj/complex_any.so .shobj/complex_any.o .shobj/complex_any.so: complex_any.cpp helper.h param_testCli.h \
  $(TAO_ROOT)/tao/corba.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/Min_Max.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -12409,8 +12930,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc_Base.h \
- $(ACE_ROOT)/ace/Malloc.i \
- $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -12425,6 +12949,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -12547,14 +13080,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/Marshal.h \
  $(TAO_ROOT)/tao/Marshal.i \
  $(TAO_ROOT)/tao/singletons.h \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(TAO_ROOT)/tao/POA.h \
  $(TAO_ROOT)/tao/Object_Adapter.h \
  $(TAO_ROOT)/tao/Key_Adapters.h \
@@ -12658,7 +13183,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8
  $(TAO_ROOT)/tao/WrongTransactionC.h \
  $(TAO_ROOT)/tao/InterfaceC.h \
  $(TAO_ROOT)/tao/BoundsC.h \
- $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \
- complex_any.h
+ $(TAO_ROOT)/tao/BoundsC.i \
+ param_testCli.i complex_any.h
 
 # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/TAO/tests/Param_Test/any.cpp b/TAO/tests/Param_Test/any.cpp
index c709002f44b..d6fc87c19e1 100644
--- a/TAO/tests/Param_Test/any.cpp
+++ b/TAO/tests/Param_Test/any.cpp
@@ -49,7 +49,30 @@ Test_Any::opname (void) const
 void
 Test_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("o1") <<= this->in_;
+  req->add_inout_arg ("o2") <<= this->inout_;
+  req->add_out_arg ("o3") = CORBA::Any (CORBA::_tc_any);
+
+  req->set_return_type (CORBA::_tc_any);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  const CORBA::Any *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new CORBA::Any (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = CORBA::Any (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new CORBA::Any (*tmp);
 }
 
 #if 0 /* any_table isn't currently used */
@@ -104,8 +127,8 @@ Test_Any::reset_parameters (void)
                       "Param_Test: ANY_SHORT subtest\n"));
         CORBA::Short s;
         s = gen->gen_short ();
-	      if (TAO_debug_level > 0)
-	        ACE_DEBUG ((LM_DEBUG, "setting short = %d\n", s));
+              if (TAO_debug_level > 0)
+                ACE_DEBUG ((LM_DEBUG, "setting short = %d\n", s));
         this->in_ <<= s;
         this->inout_ <<= s;
       }
@@ -117,8 +140,8 @@ Test_Any::reset_parameters (void)
           ACE_DEBUG ((LM_DEBUG,
                       "Param_Test: ANY_STRING subtest\n"));
         char *str = gen->gen_string ();
-	      if (TAO_debug_level > 0)
-	        ACE_DEBUG ((LM_DEBUG, "setting string = %s\n", str));
+              if (TAO_debug_level > 0)
+                ACE_DEBUG ((LM_DEBUG, "setting string = %s\n", str));
         this->in_ <<= str;
         this->inout_ <<= str;
         CORBA::string_free (str);
@@ -239,67 +262,6 @@ Test_Any::run_sii_test (Param_Test_ptr objref,
   return 0;
 }
 
-int
-Test_Any::add_args (CORBA::NVList_ptr param_list,
-                    CORBA::NVList_ptr retval,
-                    CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (CORBA::_tc_any,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_any,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_any,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("o1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("o2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("o3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_any,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Any::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Any::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/any.h b/TAO/tests/Param_Test/any.h
index ee3d68d7fc4..6b792a408fb 100644
--- a/TAO/tests/Param_Test/any.h
+++ b/TAO/tests/Param_Test/any.h
@@ -50,11 +50,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/anyop.cpp b/TAO/tests/Param_Test/anyop.cpp
new file mode 100644
index 00000000000..d059d7eddec
--- /dev/null
+++ b/TAO/tests/Param_Test/anyop.cpp
@@ -0,0 +1,224 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//   TAO/tests/Param_Test
+//
+// = FILENAME
+//   anyop.cpp
+//
+// = DESCRIPTION
+//
+// = AUTHORS
+//   Carlos O'Ryan
+//
+// ============================================================================
+
+#include "param_testCli.h"
+#include "tao/corba.h"
+#include "ace/Get_Opt.h"
+
+
+ACE_RCSID(Param_Test, anyop, "$Id$")
+
+int
+main (int argc, char *argv[])
+{
+  int n = 1024;
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb = CORBA::ORB_init (argc,
+                                            argv,
+                                            0,
+                                            ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      ACE_Get_Opt get_opt (argc, argv, "dn:l:");
+      int opt;
+
+      while ((opt = get_opt ()) != EOF)
+        {
+          switch (opt)
+            {
+            case 'd':
+              TAO_debug_level++;
+              break;
+            case 'n':
+              n = ACE_OS::atoi (get_opt.optarg);
+              break;
+            case '?':
+            default:
+              ACE_DEBUG ((LM_DEBUG,
+                          "Usage: %s "
+                          "-d debug"
+                          "-n <num> "
+                          "\n",
+                          argv[0]));
+              return -1;
+            }
+        }
+
+      for (int i = 0; i != n; ++i)
+        {
+          CORBA::Any any;
+
+#if 0
+          // @@ TODO @@ This one crashes in deep_free!!!
+          {
+            Param_Test::Var_Array var_array;
+            any <<= Param_Test::Var_Array_forany (var_array);
+
+            Param_Test::Var_Array_forany forany;
+            if (!(any >>= forany))
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for Param_Test::Var_Array\n"));
+              }
+            Param_Test::Var_Array_var var =
+              Param_Test::Var_Array_dup (forany.in ());
+            any <<= Param_Test::Var_Array_forany (var.inout ());
+            if (!(any >>= forany))
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for Param_Test::Var_Array[2]\n"));
+              }
+          }
+#endif /* 0 */
+
+          {
+            CORBA::Object_var obj =
+              orb->string_to_object ("iioploc://localhost:12345/TheKey",
+                                     ACE_TRY_ENV);
+            ACE_TRY_CHECK;
+
+            Coffee_var coffee =
+              Coffee::_unchecked_narrow (obj.in (),
+                                         ACE_TRY_ENV);
+            ACE_TRY_CHECK;
+
+            any <<= coffee.in ();
+
+            Coffee_ptr o;
+            if (!(any >>= o))
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Cannot extract Coffee (oh the horror)\n"));
+              }
+            CORBA::Boolean equiv =
+              coffee->_is_equivalent (o, ACE_TRY_ENV);
+            ACE_TRY_CHECK;
+            if (!equiv)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Mismatched Coffee extraction\n"));
+              }
+
+            CORBA::Object_ptr other;
+            if (!(any >>= CORBA::Any::to_object (other)))
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Cannot extract Coffee as Object\n"));
+              }
+          }
+
+          {
+            CORBA::Short i = 123;
+            any <<= i;
+
+            CORBA::Short o;
+            if (!(any >>= o)
+                || i != o)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for CORBA::Short (%d,%d)\n",
+                            i, o));
+              }
+          }
+
+          {
+            CORBA::Long i = 123;
+            any <<= i;
+
+            CORBA::Long o;
+            if (!(any >>= o)
+                || i != o)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for CORBA::Long (%d,%d)\n",
+                            i, o));
+              }
+          }
+
+          {
+            CORBA::ULongLong i = 123;
+            any <<= i;
+
+            CORBA::ULongLong o;
+            if (!(any >>= o)
+                || i != o)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for CORBA::ULongLong (%Q,%Q)\n",
+                            i, o));
+              }
+          }
+
+          {
+            CORBA::Double i = 123;
+            any <<= i;
+
+            CORBA::Double o;
+            if (!(any >>= o)
+                || i != o)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for CORBA::Double (%f,%f)\n",
+                            i, o));
+              }
+          }
+
+          {
+            CORBA::Any i;
+            i <<= CORBA::Short (123);
+            any <<= i;
+
+            const CORBA::Any *o;
+            CORBA::Short oo;
+
+            if (!(any >>= o)
+                || !(*o >>= oo)
+                || 123 != oo)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for CORBA::Any (%d)\n",
+                            oo));
+              }
+          }
+
+          {
+            char *i = "123";
+            any <<= i;
+
+            char * o;
+            if (!(any >>= o)
+                || ACE_OS::strcmp (i, o) != 0)
+              {
+                ACE_DEBUG ((LM_DEBUG,
+                            "Failure for char* (%s,%s)\n",
+                            i, o));
+              }
+          }
+
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Basic_Types");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/tests/Param_Test/bd_array_seq.cpp b/TAO/tests/Param_Test/bd_array_seq.cpp
index adf020a221d..c19db80d81b 100644
--- a/TAO/tests/Param_Test/bd_array_seq.cpp
+++ b/TAO/tests/Param_Test/bd_array_seq.cpp
@@ -51,7 +51,29 @@ void
 Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req,
                                              CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+  req->set_return_type (Param_Test::_tc_Bounded_ArraySeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Bounded_ArraySeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_ArraySeq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_ArraySeq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_ArraySeq (*tmp);
 }
 
 int
@@ -108,7 +130,7 @@ Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref,
     {
       Param_Test::Bounded_ArraySeq_out out (this->out_.out ());
 
-      this->ret_ = 
+      this->ret_ =
         objref->test_bounded_array_sequence (this->in_,
                                              this->inout_.inout (),
                                              out,
@@ -127,67 +149,6 @@ Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_Array_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                       CORBA::NVList_ptr retval,
-                                       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_ArraySeq,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_ArraySeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_ArraySeq,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_ArraySeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_Array_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_Array_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_array_seq.h b/TAO/tests/Param_Test/bd_array_seq.h
index 03db2e81c8a..411cf0ec1e1 100644
--- a/TAO/tests/Param_Test/bd_array_seq.h
+++ b/TAO/tests/Param_Test/bd_array_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +57,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/bd_long_seq.cpp b/TAO/tests/Param_Test/bd_long_seq.cpp
index 6ba7a04d4ad..7f2e51a4f96 100644
--- a/TAO/tests/Param_Test/bd_long_seq.cpp
+++ b/TAO/tests/Param_Test/bd_long_seq.cpp
@@ -50,7 +50,29 @@ void
 Test_Bounded_Long_Sequence::dii_req_invoke (CORBA::Request *req,
                                             CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+  req->set_return_type (Param_Test::_tc_Bounded_Long_Seq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  const Param_Test::Bounded_Long_Seq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_Long_Seq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_Long_Seq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_Long_Seq (*tmp);
 }
 
 int
@@ -108,67 +130,6 @@ Test_Bounded_Long_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_Long_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                       CORBA::NVList_ptr retval,
-                                       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_Long_Seq,
-                        (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_Long_Seq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_Long_Seq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_Long_Seq,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_Long_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_Long_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_long_seq.h b/TAO/tests/Param_Test/bd_long_seq.h
index 306da6e4a23..5dda51d2268 100644
--- a/TAO/tests/Param_Test/bd_long_seq.h
+++ b/TAO/tests/Param_Test/bd_long_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/bd_short_seq.cpp b/TAO/tests/Param_Test/bd_short_seq.cpp
index 8412b139fdc..b46047ad57e 100644
--- a/TAO/tests/Param_Test/bd_short_seq.cpp
+++ b/TAO/tests/Param_Test/bd_short_seq.cpp
@@ -47,10 +47,32 @@ Test_Bounded_Short_Sequence::opname (void) const
 }
 
 void
-Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req, 
+Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req,
                                              CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+  req->set_return_type (Param_Test::_tc_Bounded_Short_Seq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Bounded_Short_Seq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_Short_Seq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_Short_Seq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_Short_Seq (*tmp);
 }
 
 int
@@ -111,67 +133,6 @@ Test_Bounded_Short_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_Short_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                       CORBA::NVList_ptr retval,
-                                       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_Short_Seq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_Short_Seq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_Short_Seq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_Short_Seq,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_Short_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_Short_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_short_seq.h b/TAO/tests/Param_Test/bd_short_seq.h
index 2198fa319fa..5efe29e22a6 100644
--- a/TAO/tests/Param_Test/bd_short_seq.h
+++ b/TAO/tests/Param_Test/bd_short_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/bd_str_seq.cpp b/TAO/tests/Param_Test/bd_str_seq.cpp
index 20cd5679d16..bd9aae472bd 100644
--- a/TAO/tests/Param_Test/bd_str_seq.cpp
+++ b/TAO/tests/Param_Test/bd_str_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req,
                                               CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Bounded_StrSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  const Param_Test::Bounded_StrSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_StrSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_StrSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_StrSeq (*tmp);
 }
 
 int
@@ -113,67 +136,6 @@ Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_String_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                        CORBA::NVList_ptr retval,
-                                        CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_StrSeq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_StrSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_StrSeq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_StrSeq,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_String_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_String_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_str_seq.h b/TAO/tests/Param_Test/bd_str_seq.h
index ea82ac8d55a..48b60f9366b 100644
--- a/TAO/tests/Param_Test/bd_str_seq.h
+++ b/TAO/tests/Param_Test/bd_str_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/bd_string.cpp b/TAO/tests/Param_Test/bd_string.cpp
index c0a650a427d..b4028178f57 100644
--- a/TAO/tests/Param_Test/bd_string.cpp
+++ b/TAO/tests/Param_Test/bd_string.cpp
@@ -58,12 +58,35 @@ void
 Test_Bounded_String::dii_req_invoke (CORBA::Request *req,
                                      CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= CORBA::Any::from_string (this->in_, 128);
+  req->add_inout_arg ("s2") <<= CORBA::Any::from_string (this->inout_, 128);
+  req->add_out_arg ("s3") <<= CORBA::Any::from_string (this->out_, 128);
+
+  req->set_return_type (Param_Test::_tc_short_string);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  char *tmp;
+  req->return_value () >>= CORBA::Any::to_string (tmp, 128);
+  this->ret_ = CORBA::string_dup (tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= CORBA::Any::to_string (tmp, 128);
+  this->inout_ = CORBA::string_dup (tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= CORBA::Any::to_string (tmp, 128);
+  this->out_ = CORBA::string_dup (tmp);
 }
 
 int
 Test_Bounded_String::init_parameters (Param_Test_ptr,
-				                              CORBA::Environment &)
+                                                              CORBA::Environment &)
 {
   Generator *gen = GENERATOR::instance (); // value generator
 
@@ -99,7 +122,7 @@ Test_Bounded_String::reset_parameters (void)
 
 int
 Test_Bounded_String::run_sii_test (Param_Test_ptr objref,
-				   CORBA::Environment &ACE_TRY_ENV)
+                                   CORBA::Environment &ACE_TRY_ENV)
 {
   ACE_TRY
     {
@@ -123,68 +146,6 @@ Test_Bounded_String::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_String::add_args (CORBA::NVList_ptr param_list,
-			       CORBA::NVList_ptr retval,
-			       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // create the parameters
-      CORBA::Any in_arg (CORBA::_tc_string,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_string,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_string,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_string,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_String::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_String::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_string.h b/TAO/tests/Param_Test/bd_string.h
index faf9bfd0fad..46291917900 100644
--- a/TAO/tests/Param_Test/bd_string.h
+++ b/TAO/tests/Param_Test/bd_string.h
@@ -37,15 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
-  int add_args (CORBA::Request_ptr &req,
-                CORBA::Environment &env);
-  // add args to NVList using << operator
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/bd_struct_seq.cpp b/TAO/tests/Param_Test/bd_struct_seq.cpp
index b2252973f3c..af50383b84f 100644
--- a/TAO/tests/Param_Test/bd_struct_seq.cpp
+++ b/TAO/tests/Param_Test/bd_struct_seq.cpp
@@ -53,7 +53,29 @@ void
 Test_Bounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req,
                                               CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+  req->set_return_type (Param_Test::_tc_Bounded_StructSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Bounded_StructSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_StructSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_StructSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_StructSeq (*tmp);
 }
 
 int
@@ -109,67 +131,6 @@ Test_Bounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_Struct_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                        CORBA::NVList_ptr retval,
-                                        CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_StructSeq,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_StructSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_StructSeq,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_StructSeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_Struct_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_Struct_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_struct_seq.h b/TAO/tests/Param_Test/bd_struct_seq.h
index 9119a46c90b..a8ce07bd760 100644
--- a/TAO/tests/Param_Test/bd_struct_seq.h
+++ b/TAO/tests/Param_Test/bd_struct_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/bd_wstr_seq.cpp b/TAO/tests/Param_Test/bd_wstr_seq.cpp
index efd7a311f39..cd1a3072b0d 100644
--- a/TAO/tests/Param_Test/bd_wstr_seq.cpp
+++ b/TAO/tests/Param_Test/bd_wstr_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req,
                                                CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Bounded_WStrSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  const Param_Test::Bounded_WStrSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Bounded_WStrSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Bounded_WStrSeq (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Bounded_WStrSeq (*tmp);
 }
 
 int
@@ -116,67 +139,6 @@ Test_Bounded_WString_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Bounded_WString_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                         CORBA::NVList_ptr retval,
-                                         CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Bounded_WStrSeq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Bounded_WStrSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Bounded_WStrSeq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("ws1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Bounded_WStrSeq,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_WString_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Bounded_WString_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/bd_wstr_seq.h b/TAO/tests/Param_Test/bd_wstr_seq.h
index 43c0f4f5e9b..108d53a4057 100644
--- a/TAO/tests/Param_Test/bd_wstr_seq.h
+++ b/TAO/tests/Param_Test/bd_wstr_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +57,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/bd_wstring.cpp b/TAO/tests/Param_Test/bd_wstring.cpp
index fd954cf1825..ec9cbe4eabb 100644
--- a/TAO/tests/Param_Test/bd_wstring.cpp
+++ b/TAO/tests/Param_Test/bd_wstring.cpp
@@ -2,213 +2,174 @@
 
 // ============================================================================
 //
-// = LIBRARY
-//    TAO/tests/Param_Test
+// = Library
+//    Tao/Tests/Param_Test
 //
-// = FILENAME
-//    bd_wstring.cpp
+// = Filename
+//    Bd_Wstring.Cpp
 //
-// = DESCRIPTION
-//    tests bounded wide strings
+// = Description
+//    Tests Bounded Wide Strings
 //
-// = AUTHORS
+// = Authors
 //      Jeff Parsons
 //
 // ============================================================================
 
-#include "helper.h"
-#include "bd_wstring.h"
+#Include "Helper.H"
+#Include "Bd_Wstring.H"
 
-ACE_RCSID(Param_Test, bd_wstring, "$Id$")
+Ace_Rcsid(Param_Test, Bd_Wstring, "$id: Bd_Wstring.Cpp,V 1.3 1999/09/17 17:03:22 Parsons Exp $")
 
 // ************************************************************************
-//               Test_Bounded_WString
+//               Test_Bounded_Wstring
 // ************************************************************************
 
-Test_Bounded_WString::Test_Bounded_WString (void)
-  : opname_ (CORBA::string_dup ("test_bounded_wstring")),
-    in_ (0),
-    inout_ (0),
-    out_ (0),
-    ret_ (0)
+Test_Bounded_Wstring::Test_Bounded_Wstring (Void)
+  : Opname_ (Corba::String_Dup ("Test_Bounded_Wstring")),
+    In_ (0),
+    Inout_ (0),
+    Out_ (0),
+    Ret_ (0)
 {
 }
 
-Test_Bounded_WString::~Test_Bounded_WString (void)
+Test_Bounded_Wstring::~Test_Bounded_Wstring (Void)
 {
-  CORBA::string_free (this->opname_);
-  CORBA::wstring_free (this->in_);
-  CORBA::wstring_free (this->inout_);
-  CORBA::wstring_free (this->out_);
-  CORBA::wstring_free (this->ret_);
-  this->opname_ = 0;
-  this->in_ = 0;
-  this->inout_ = 0;
-  this->out_ = 0;
-  this->ret_ = 0;
+  Corba::String_Free (This->Opname_);
+  Corba::Wstring_Free (This->In_);
+  Corba::Wstring_Free (This->Inout_);
+  Corba::Wstring_Free (This->Out_);
+  Corba::Wstring_Free (This->Ret_);
+  This->Opname_ = 0;
+  This->In_ = 0;
+  This->Inout_ = 0;
+  This->Out_ = 0;
+  This->Ret_ = 0;
 }
 
-const char *
-Test_Bounded_WString::opname (void) const
+Const Char *
+Test_Bounded_Wstring::Opname (Void) Const
 {
-  return this->opname_;
+  Return This->Opname_;
 }
 
-void
-Test_Bounded_WString::dii_req_invoke (CORBA::Request *req,
-                                      CORBA::Environment &ACE_TRY_ENV)
+Void
+Test_Bounded_Wstring::Dii_Req_Invoke (Corba::Request *Req,
+                                      Corba::Environment &Ace_Try_Env)
 {
-  req->invoke (ACE_TRY_ENV);
+  Req->Add_In_Arg ("S1") <<= Corba::Any::From_Wstring (This->In_, 128);
+  Req->Add_Inout_Arg ("S2") <<= Corba::Any::From_Wstring (This->Inout_, 128);
+  Req->Add_Out_Arg ("S3") <<= Corba::Any::From_Wstring (This->Out_, 128);
+
+  Req->Set_Return_Type (Param_Test::_Tc_Short_Wstring);
+
+  Req->Invoke (Ace_Try_Env);
+  Ace_Check;
+
+  Corba::Wchar *Tmp;
+  Req->Return_Value () >>= Corba::Any::To_Wstring (Tmp, 128);
+  This->Ret_ = Corba::Wstring_Dup (Tmp);
+
+  Corba::Namedvalue_Ptr Arg2 =
+    Req->Arguments ()->Item (1, Ace_Try_Env);
+  Ace_Check;
+  *Arg2->Value () >>= Corba::Any::To_Wstring (Tmp, 128);
+  This->Inout_ = Corba::Wstring_Dup (Tmp);
+
+  Corba::Namedvalue_Ptr Arg3 =
+    Req->Arguments ()->Item (2, Ace_Try_Env);
+  Ace_Check;
+  *Arg3->Value () >>= Corba::Any::To_Wstring (Tmp, 128);
+  This->Out_ = Corba::Wstring_Dup (Tmp);
 }
 
-int
-Test_Bounded_WString::init_parameters (Param_Test_ptr,
-				                               CORBA::Environment &)
+Int
+Test_Bounded_Wstring::Init_Parameters (Param_Test_Ptr,
+                                                               Corba::Environment &)
 {
-  Generator *gen = GENERATOR::instance (); // value generator
-
-  // release any previously occupied values
-  CORBA::wstring_free (this->in_);
-  CORBA::wstring_free (this->inout_);
-  CORBA::wstring_free (this->out_);
-  CORBA::wstring_free (this->ret_);
-  this->in_ = 0;
-  this->inout_ = 0;
-  this->out_ = 0;
-  this->ret_ = 0;
-
-  this->in_ = gen->gen_wstring (32);
-  this->inout_ = CORBA::wstring_dup (this->in_);
-  return 0;
+  Generator *Gen = Generator::Instance (); // Value Generator
+
+  // Release Any Previously Occupied Values
+  Corba::Wstring_Free (This->In_);
+  Corba::Wstring_Free (This->Inout_);
+  Corba::Wstring_Free (This->Out_);
+  Corba::Wstring_Free (This->Ret_);
+  This->In_ = 0;
+  This->Inout_ = 0;
+  This->Out_ = 0;
+  This->Ret_ = 0;
+
+  This->In_ = Gen->Gen_Wstring (32);
+  This->Inout_ = Corba::Wstring_Dup (This->In_);
+  Return 0;
 }
 
-int
-Test_Bounded_WString::reset_parameters (void)
+Int
+Test_Bounded_Wstring::Reset_Parameters (Void)
 {
-  // release any previously occupied values
-  CORBA::wstring_free (this->inout_);
-  CORBA::wstring_free (this->out_);
-  CORBA::wstring_free (this->ret_);
-  this->inout_ = 0;
-  this->out_ = 0;
-  this->ret_ = 0;
-
-  this->inout_ = CORBA::wstring_dup (this->in_);
-  return 0;
+  // Release Any Previously Occupied Values
+  Corba::Wstring_Free (This->Inout_);
+  Corba::Wstring_Free (This->Out_);
+  Corba::Wstring_Free (This->Ret_);
+  This->Inout_ = 0;
+  This->Out_ = 0;
+  This->Ret_ = 0;
+
+  This->Inout_ = Corba::Wstring_Dup (This->In_);
+  Return 0;
 }
 
-int
-Test_Bounded_WString::run_sii_test (Param_Test_ptr objref,
-				                            CORBA::Environment &ACE_TRY_ENV)
+Int
+Test_Bounded_Wstring::Run_Sii_Test (Param_Test_Ptr Objref,
+                                                            Corba::Environment &Ace_Try_Env)
 {
-  ACE_TRY
+  Ace_Try
     {
-      CORBA::WString_out str_out (this->out_);
+      Corba::Wstring_Out Str_Out (This->Out_);
 
-      this->ret_ = objref->test_bounded_wstring (this->in_,
-                                                 this->inout_,
-                                                 str_out,
-                                                 ACE_TRY_ENV);
-      ACE_TRY_CHECK;
+      This->Ret_ = Objref->Test_Bounded_Wstring (This->In_,
+                                                 This->Inout_,
+                                                 Str_Out,
+                                                 Ace_Try_Env);
+      Ace_Try_Check;
 
-      return 0;
+      Return 0;
     }
-  ACE_CATCHANY
+  Ace_Catchany
     {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_WString::run_sii_test\n");
+      Ace_Print_Exception (Ace_Any_Exception,
+                           "Test_Bounded_Wstring::Run_Sii_Test\N");
 
     }
-  ACE_ENDTRY;
-  return -1;
+  Ace_Endtry;
+  Return -1;
 }
 
-int
-Test_Bounded_WString::add_args (CORBA::NVList_ptr param_list,
-			                          CORBA::NVList_ptr retval,
-			                          CORBA::Environment &ACE_TRY_ENV)
+Corba::Boolean
+Test_Bounded_Wstring::Check_Validity (Void)
 {
-  ACE_TRY
-    {
-      // create the parameters
-      CORBA::Any in_arg (CORBA::_tc_wstring,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_wstring,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_wstring,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("ws1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_wstring,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Bounded_WString::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
-CORBA::Boolean
-Test_Bounded_WString::check_validity (void)
-{
-  CORBA::ULong len = ACE_OS::wslen (this->in_);
+  Corba::Ulong Len = Ace_Os::Wslen (This->In_);
 
-  if (!ACE_OS::wscmp (this->in_, this->out_) &&
-      !ACE_OS::wscmp (this->in_, this->ret_) &&
-      ACE_OS::wslen (this->inout_) == 2*len &&
-      !ACE_OS::wsncmp (this->in_, this->inout_, len) &&
-      !ACE_OS::wsncmp (this->in_, &this->inout_[len], len))
-    return 1;
+  If (!Ace_Os::Wscmp (This->In_, This->Out_) &&
+      !Ace_Os::Wscmp (This->In_, This->Ret_) &&
+      Ace_Os::Wslen (This->Inout_) == 2*Len &&
+      !Ace_Os::Wsncmp (This->In_, This->Inout_, Len) &&
+      !Ace_Os::Wsncmp (This->In_, &This->Inout_[Len], Len))
+    Return 1;
 
-  return 0; // otherwise
+  Return 0; // Otherwise
 }
 
-CORBA::Boolean
-Test_Bounded_WString::check_validity (CORBA::Request_ptr)
+Corba::Boolean
+Test_Bounded_Wstring::Check_Validity (Corba::Request_Ptr)
 {
-  // No need to retrieve anything because, for all the args and
-  // the return, we provided the memory and we own it.
-  return this->check_validity ();
+  // No Need To Retrieve Anything Because, For All The Args And
+  // The Return, We Provided The Memory And We Own It.
+  Return This->Check_Validity ();
 }
 
-void
-Test_Bounded_WString::print_values (void)
+Void
+Test_Bounded_Wstring::Print_Values (Void)
 {
 }
diff --git a/TAO/tests/Param_Test/bd_wstring.h b/TAO/tests/Param_Test/bd_wstring.h
index 65b22fdc5f9..8e864ce6f32 100644
--- a/TAO/tests/Param_Test/bd_wstring.h
+++ b/TAO/tests/Param_Test/bd_wstring.h
@@ -37,15 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
-  int add_args (CORBA::Request_ptr &req,
-                CORBA::Environment &env);
-  // add args to NVList using << operator
-
   const char *opname (void) const;
   // return operation name
 
@@ -65,7 +56,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/big_union.cpp b/TAO/tests/Param_Test/big_union.cpp
index ee26fe2d964..72ffa97fd58 100644
--- a/TAO/tests/Param_Test/big_union.cpp
+++ b/TAO/tests/Param_Test/big_union.cpp
@@ -48,7 +48,30 @@ void
 Test_Big_Union::dii_req_invoke (CORBA::Request *req,
                                 CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Big_Union);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Big_Union *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Big_Union (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = *tmp;
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Big_Union (*tmp);
 }
 
 int
@@ -224,67 +247,6 @@ Test_Big_Union::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Big_Union::add_args (CORBA::NVList_ptr param_list,
-                          CORBA::NVList_ptr retval,
-                          CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Big_Union,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Big_Union,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Big_Union,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("u1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("u2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("u3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Big_Union,
-                               &this->ret_.inout (),
-                               0,
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Big_Union::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Big_Union::check_validity (void)
 {
@@ -311,7 +273,7 @@ Test_Big_Union::check_validity (void)
                 || in_array[i] != out_array[i]
                 || in_array[i] != ret_array[i])
               {
-                ACE_DEBUG ((LM_DEBUG, 
+                ACE_DEBUG ((LM_DEBUG,
                             "mismatch of arrays\n"));
                 return 0;
               }
diff --git a/TAO/tests/Param_Test/big_union.h b/TAO/tests/Param_Test/big_union.h
index 408fb7086d7..e92b00b0046 100644
--- a/TAO/tests/Param_Test/big_union.h
+++ b/TAO/tests/Param_Test/big_union.h
@@ -41,11 +41,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/client.cpp b/TAO/tests/Param_Test/client.cpp
index d0600e98bd3..aab49207afa 100644
--- a/TAO/tests/Param_Test/client.cpp
+++ b/TAO/tests/Param_Test/client.cpp
@@ -64,7 +64,7 @@ Param_Test_Client<T>::run_sii_test (void)
   // Declare the Env
   ACE_DECLARE_NEW_CORBA_ENV;
   // Initialize parameters for the test.
-  int check = this->test_object_->init_parameters (this->param_test_, 
+  int check = this->test_object_->init_parameters (this->param_test_,
                                                    ACE_TRY_ENV);
   ACE_CHECK_RETURN (-1);
 
@@ -73,7 +73,7 @@ Param_Test_Client<T>::run_sii_test (void)
       ACE_ERROR_RETURN ((LM_ERROR,
                          "(%N:%l) client.cpp - run_sii_test:"
                          "init_parameters failed for opname - %s",
-                         opname), 
+                         opname),
                         -1);
     }
 
@@ -91,7 +91,7 @@ Param_Test_Client<T>::run_sii_test (void)
           this->results_.start_timer ();
 
           // make the call
-          this->test_object_->run_sii_test (this->param_test_, 
+          this->test_object_->run_sii_test (this->param_test_,
                                             ACE_TRY_ENV);
           ACE_TRY_CHECK;
 
@@ -142,14 +142,14 @@ Param_Test_Client<T>::run_sii_test (void)
   if (this->results_.error_count () != 0)
     {
       ACE_DEBUG ((LM_DEBUG,
-		  "********** Error running %s SII *********\n",
-		  opname));
+                  "********** Error running %s SII *********\n",
+                  opname));
     }
   else
     {
       ACE_DEBUG ((LM_DEBUG,
-		  "********** Finished running %s SII *********\n",
-		  opname));
+                  "********** Finished running %s SII *********\n",
+                  opname));
     }
   return this->results_.error_count ()? -1:0;
 }
@@ -172,7 +172,7 @@ Param_Test_Client<T>::run_dii_test (void)
   // Environment variable
   ACE_DECLARE_NEW_CORBA_ENV;
   // initialize parameters for the test
-  int check = this->test_object_->init_parameters (this->param_test_, 
+  int check = this->test_object_->init_parameters (this->param_test_,
                                                    ACE_TRY_ENV);
   ACE_CHECK_RETURN (-1);
 
@@ -181,7 +181,7 @@ Param_Test_Client<T>::run_dii_test (void)
       ACE_ERROR_RETURN ((LM_ERROR,
                          "(%N:%l) client.cpp - run_dii_test:"
                          "init_parameters failed for opname - %s",
-                         opname), 
+                         opname),
                         -1);
     }
 
@@ -194,50 +194,20 @@ Param_Test_Client<T>::run_dii_test (void)
       // time required to create and populate the NVList
       this->results_.start_timer ();
 
-      // first create the argument list (length 0 because args are *added*)
-      CORBA::NVList_ptr nvlist;
-
-      this->orb_->create_list (0, nvlist);
-
-      // then the result holder (length 1 because value is *replaced*)
-      CORBA::NVList_var retval;
-      this->orb_->create_list (1, 
-                               retval.out ());
-
       // create the request
       CORBA::Request_var req;
 
       ACE_TRY
         {
-          // add arguments and typecode for return valueto the NVList
-          this->test_object_->add_args (nvlist,
-					                              retval.in (),
-					                              ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-
-          CORBA::NamedValue_ptr result =
-            CORBA::NamedValue::_duplicate (retval->item (0, 
-                                                         ACE_TRY_ENV));
-          ACE_TRY_CHECK;
-
-          this->param_test_->_create_request (CORBA_Context::_nil (),
-                                              opname,
-                                              nvlist,
-                                              result,
-                                              req.out (),
-                                              0, //CORBA::OUT_LIST_MEMORY,
-                                              ACE_TRY_ENV);
-          // The OUT_LIST_MEMORY is to be used when the ORB assumes that
-          // we will provide the top-level storage. With 0, the returned
-          // values for ret, inout, and out parameters are all owned by
-          // the ORB and hence we must not free them explicitly.
+          req = this->param_test_->_request (opname,
+                                             ACE_TRY_ENV);
           ACE_TRY_CHECK;
 
           if (opt->debug ())
             ACE_DEBUG ((LM_DEBUG, "\n****** Before call values *****\n"));
 
           // Make the invocation, verify the result.
-          this->test_object_->dii_req_invoke (req.in (), 
+          this->test_object_->dii_req_invoke (req.in (),
                                               ACE_TRY_ENV);
           ACE_TRY_CHECK;
         }
@@ -282,14 +252,14 @@ Param_Test_Client<T>::run_dii_test (void)
   if (this->results_.error_count () != 0)
     {
       ACE_DEBUG ((LM_DEBUG,
-		  "********** Error running %s DII *********\n",
-		  opname));
+                  "********** Error running %s DII *********\n",
+                  opname));
     }
   else
     {
       ACE_DEBUG ((LM_DEBUG,
-		  "********** Finished running %s DII *********\n",
-		  opname));
+                  "********** Finished running %s DII *********\n",
+                  opname));
     }
   return this->results_.error_count () ? -1 : 0;
 }
diff --git a/TAO/tests/Param_Test/complex_any.cpp b/TAO/tests/Param_Test/complex_any.cpp
index a9d531be88b..300d0da1e36 100644
--- a/TAO/tests/Param_Test/complex_any.cpp
+++ b/TAO/tests/Param_Test/complex_any.cpp
@@ -53,7 +53,30 @@ void
 Test_Complex_Any::dii_req_invoke (CORBA::Request *req,
                                   CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= CORBA::Any (CORBA::_tc_any);
+
+  req->set_return_type (CORBA::_tc_any);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  const CORBA::Any *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new CORBA::Any (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = CORBA::Any (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new CORBA::Any (*tmp);
 }
 
 int
@@ -162,67 +185,6 @@ Test_Complex_Any::run_sii_test (Param_Test_ptr objref,
   return 0;
 }
 
-int
-Test_Complex_Any::add_args (CORBA::NVList_ptr param_list,
-                            CORBA::NVList_ptr retval,
-                            CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (CORBA::_tc_any,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_any,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_any,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("ca1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ca2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ca3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_any,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Complex_Any::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Complex_Any::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/complex_any.h b/TAO/tests/Param_Test/complex_any.h
index 562a3bb1d23..026d441ab22 100644
--- a/TAO/tests/Param_Test/complex_any.h
+++ b/TAO/tests/Param_Test/complex_any.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/except.cpp b/TAO/tests/Param_Test/except.cpp
index 09d7cd82cc8..b2832867328 100644
--- a/TAO/tests/Param_Test/except.cpp
+++ b/TAO/tests/Param_Test/except.cpp
@@ -49,8 +49,26 @@ Test_Exception::dii_req_invoke (CORBA::Request *req,
 {
   ACE_TRY
     {
+      req->add_in_arg ("s1") <<= this->in_;
+      req->add_inout_arg ("s2") <<= this->inout_;
+      req->add_out_arg ("s3") <<= this->out_;
+
+      req->set_return_type (CORBA::_tc_long);
+
       req->invoke (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
+      req->return_value () >>= this->ret_;
+
+      CORBA::NamedValue_ptr o2 =
+        req->arguments ()->item (1, ACE_TRY_ENV);
+      ACE_CHECK;
+      *o2->value () >>= this->inout_;
+
+      CORBA::NamedValue_ptr o3 =
+        req->arguments ()->item (2, ACE_TRY_ENV);
+      ACE_CHECK;
+      *o3->value () >>= this->out_;
     }
   ACE_CATCH (CORBA::UnknownUserException, user_ex)
     {
@@ -180,69 +198,6 @@ Test_Exception::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Exception::add_args (CORBA::NVList_ptr param_list,
-                          CORBA::NVList_ptr retval,
-                          CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // we provide top level memory to the ORB to retrieve the data
-      CORBA::Any in_arg (CORBA::_tc_ulong,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_ulong,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_ulong,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value. Let the ORB allocate storage. We simply tell the ORB
-      // what type we are expecting.
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_ulong,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Exception::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Exception::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/except.h b/TAO/tests/Param_Test/except.h
index 8b28c39e956..fb85e1d71cc 100644
--- a/TAO/tests/Param_Test/except.h
+++ b/TAO/tests/Param_Test/except.h
@@ -34,10 +34,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/fixed_array.cpp b/TAO/tests/Param_Test/fixed_array.cpp
index 3a96fc3c5c7..cad9afe1d72 100644
--- a/TAO/tests/Param_Test/fixed_array.cpp
+++ b/TAO/tests/Param_Test/fixed_array.cpp
@@ -47,7 +47,30 @@ void
 Test_Fixed_Array::dii_req_invoke (CORBA::Request *req,
                                   CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= Param_Test::Fixed_Array_forany (this->in_);
+  req->add_inout_arg ("s2") <<= Param_Test::Fixed_Array_forany (this->inout_);
+  req->add_out_arg ("s3") <<= Param_Test::Fixed_Array_forany (this->out_);
+  req->set_return_type (Param_Test::_tc_Fixed_Array);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Fixed_Array_forany forany;
+  req->return_value () >>= forany;
+  Param_Test::Fixed_Array_copy (this->ret_, forany.in ());
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= forany;
+  Param_Test::Fixed_Array_copy (this->inout_, forany.in ());
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  Param_Test::Fixed_Array_forany out_any (this->out_);
+  *arg3->value () >>= forany;
+  Param_Test::Fixed_Array_copy (this->out_, forany.in ());
 }
 
 int
@@ -107,69 +130,6 @@ Test_Fixed_Array::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Fixed_Array::add_args (CORBA::NVList_ptr param_list,
-                            CORBA::NVList_ptr retval,
-                            CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // We provide the top level memory
-      // the Any does not own any of these
-      CORBA::Any in_arg (Param_Test::_tc_Fixed_Array,
-                         this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Fixed_Array,
-                            this->inout_,
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Fixed_Array,
-                          this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("l1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("l2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("l3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Fixed_Array,
-                               this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Fixed_Array::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Fixed_Array::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/fixed_array.h b/TAO/tests/Param_Test/fixed_array.h
index 578d320c9b9..51cb8d1753d 100644
--- a/TAO/tests/Param_Test/fixed_array.h
+++ b/TAO/tests/Param_Test/fixed_array.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/fixed_struct.cpp b/TAO/tests/Param_Test/fixed_struct.cpp
index 3e234de1955..d185f868fe0 100644
--- a/TAO/tests/Param_Test/fixed_struct.cpp
+++ b/TAO/tests/Param_Test/fixed_struct.cpp
@@ -46,7 +46,29 @@ void
 Test_Fixed_Struct::dii_req_invoke (CORBA::Request *req,
                                    CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_;
+  req->set_return_type (Param_Test::_tc_Fixed_Struct);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Fixed_Struct *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = *tmp;
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = *tmp;
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = *tmp;
 }
 
 int
@@ -107,69 +129,6 @@ Test_Fixed_Struct::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Fixed_Struct::add_args (CORBA::NVList_ptr param_list,
-                             CORBA::NVList_ptr retval,
-                             CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // We provide the top level memory
-      // the Any does not own any of these
-      CORBA::Any in_arg (Param_Test::_tc_Fixed_Struct,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Fixed_Struct,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Fixed_Struct,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value type
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Fixed_Struct,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Fixed_Struct::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Fixed_Struct::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/fixed_struct.h b/TAO/tests/Param_Test/fixed_struct.h
index b4091e90fba..81ec824b4a7 100644
--- a/TAO/tests/Param_Test/fixed_struct.h
+++ b/TAO/tests/Param_Test/fixed_struct.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/multdim_array.cpp b/TAO/tests/Param_Test/multdim_array.cpp
index c90a63531fd..f51c80240a9 100644
--- a/TAO/tests/Param_Test/multdim_array.cpp
+++ b/TAO/tests/Param_Test/multdim_array.cpp
@@ -49,7 +49,31 @@ void
 Test_Multdim_Array::dii_req_invoke (CORBA::Request *req,
                                     CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= Param_Test::Multdim_Array_forany (this->in_.inout ());
+  req->add_inout_arg ("s2") <<= Param_Test::Multdim_Array_forany (this->inout_.inout ());
+  req->add_out_arg ("s3") <<= Param_Test::Multdim_Array_forany (this->out_.inout ());
+
+  req->set_return_type (Param_Test::_tc_Multdim_Array);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+
+  Param_Test::Multdim_Array_forany forany;
+  req->return_value () >>= forany;
+  Param_Test::Multdim_Array_copy (this->ret_, forany.in ());
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= forany;
+  Param_Test::Multdim_Array_copy (this->inout_, forany.in ());
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= forany;
+  Param_Test::Multdim_Array_copy (this->out_, forany.in ());
 }
 
 int
@@ -116,57 +140,14 @@ Test_Multdim_Array::run_sii_test (Param_Test_ptr objref,
   return (ACE_TRY_ENV.exception () ? -1:0);
 }
 
-int
-Test_Multdim_Array::add_args (CORBA::NVList_ptr param_list,
-                              CORBA::NVList_ptr retval,
-                              CORBA::Environment &ACE_TRY_ENV)
-{
-  // We provide the top level memory
-  // the Any does not own any of these
-  CORBA::Any in_arg (Param_Test::_tc_Multdim_Array,
-                     this->in_.inout (),
-                     0);
-
-  CORBA::Any inout_arg (Param_Test::_tc_Multdim_Array,
-                        this->inout_.inout (),
-                        0);
-
-  CORBA::Any out_arg (Param_Test::_tc_Multdim_Array,
-                      this->out_.inout (),
-                      0);
-
-  // add parameters
-  param_list->add_value ("l1",
-                         in_arg,
-                         CORBA::ARG_IN,
-                         ACE_TRY_ENV);
-
-  param_list->add_value ("l2",
-                         inout_arg,
-                         CORBA::ARG_INOUT,
-                         ACE_TRY_ENV);
-
-  param_list->add_value ("l3",
-                         out_arg,
-                         CORBA::ARG_OUT,
-                         ACE_TRY_ENV);
-
-  // add return value type
-  retval->item (0, ACE_TRY_ENV)->value ()->replace (Param_Test::_tc_Multdim_Array,
-                                                    this->ret_.inout (),
-                                                    0, // does not own
-                                                    ACE_TRY_ENV);
-  return 0;
-}
-
 CORBA::Boolean
 Test_Multdim_Array::check_validity (void)
 {
-  if (this->compare (this->in_.in (), 
+  if (this->compare (this->in_.in (),
                      this->inout_.in ()) &&
-      this->compare (this->in_.in (), 
+      this->compare (this->in_.in (),
                      this->out_.in ()) &&
-      this->compare (this->in_.in (), 
+      this->compare (this->in_.in (),
                      this->ret_.in ()))
     return 1;
   else
@@ -225,4 +206,3 @@ Test_Multdim_Array::print (const Param_Test::Multdim_Array_slice *a)
         }
     }
 }
-
diff --git a/TAO/tests/Param_Test/multdim_array.h b/TAO/tests/Param_Test/multdim_array.h
index 9e68775b7bf..2f8afdce885 100644
--- a/TAO/tests/Param_Test/multdim_array.h
+++ b/TAO/tests/Param_Test/multdim_array.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/nested_struct.cpp b/TAO/tests/Param_Test/nested_struct.cpp
index 5cbf4765aa4..b4560efd053 100644
--- a/TAO/tests/Param_Test/nested_struct.cpp
+++ b/TAO/tests/Param_Test/nested_struct.cpp
@@ -50,7 +50,29 @@ Test_Nested_Struct::opname (void) const
 void
 Test_Nested_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+  req->set_return_type (Param_Test::_tc_Nested_Struct);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Nested_Struct *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Nested_Struct (*tmp);
+
+  CORBA::NamedValue_ptr arg2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg2->value () >>= tmp;
+  this->inout_ = new Param_Test::Nested_Struct (*tmp);
+
+  CORBA::NamedValue_ptr arg3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *arg3->value () >>= tmp;
+  this->out_ = new Param_Test::Nested_Struct (*tmp);
 }
 
 int
@@ -112,67 +134,6 @@ Test_Nested_Struct::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Nested_Struct::add_args (CORBA::NVList_ptr param_list,
-			      CORBA::NVList_ptr retval,
-			      CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Nested_Struct,
-                         (void *) &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Nested_Struct,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Nested_Struct,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Nested_Struct,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Nested_Struct::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Nested_Struct::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/nested_struct.h b/TAO/tests/Param_Test/nested_struct.h
index 47e6d2a8e43..cbd260906ab 100644
--- a/TAO/tests/Param_Test/nested_struct.h
+++ b/TAO/tests/Param_Test/nested_struct.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/objref.cpp b/TAO/tests/Param_Test/objref.cpp
index 65b20584a33..63702fdb4da 100644
--- a/TAO/tests/Param_Test/objref.cpp
+++ b/TAO/tests/Param_Test/objref.cpp
@@ -55,7 +55,30 @@ void
 Test_ObjRef::dii_req_invoke (CORBA::Request *req,
                              CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (_tc_Coffee);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Coffee_ptr tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = Coffee::_duplicate (tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = Coffee::_duplicate (tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = Coffee::_duplicate (tmp);
 }
 
 static const char *Coffee_Flavor [] = {
@@ -182,67 +205,6 @@ Test_ObjRef::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_ObjRef::add_args (CORBA::NVList_ptr param_list,
-		       CORBA::NVList_ptr retval,
-		       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (_tc_Coffee,
-                         this->in_courier,
-                         0);
-
-      CORBA::Any inout_arg (_tc_Coffee,
-                            this->inout_courier,
-                            0);
-
-      CORBA::Any out_arg (_tc_Coffee,
-                          this->out_courier,
-                          0);
-
-      // Add parameters.
-      param_list->add_value ("o1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("o2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("o3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // Add return value.
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (_tc_Coffee,
-                               this->ret_courier,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_ObjRef::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_ObjRef::check_validity (void)
 {
@@ -258,6 +220,11 @@ Test_ObjRef::check_validity (void)
 
   ACE_TRY
     {
+      if (CORBA::is_nil (this->in_.in ())
+          || CORBA::is_nil (this->inout_.in ())
+          || CORBA::is_nil (this->out_.in ())
+          || CORBA::is_nil (this->ret_.in ()))
+        return 0;
       Coffee::Desc_var in_desc =
         this->in_->description (ACE_TRY_ENV);
       ACE_TRY_CHECK;
@@ -309,15 +276,15 @@ Test_ObjRef::check_validity (CORBA::Request_ptr /*req*/)
 
   ACE_TRY
     {
-      this->inout_ = Coffee::_narrow (*this->inout_courier, 
+      this->inout_ = Coffee::_narrow (*this->inout_courier,
                                       ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      this->out_ = Coffee::_narrow (*this->out_courier, 
+      this->out_ = Coffee::_narrow (*this->out_courier,
                                     ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      this->ret_ = Coffee::_narrow (*this->ret_courier, 
+      this->ret_ = Coffee::_narrow (*this->ret_courier,
                                     ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
diff --git a/TAO/tests/Param_Test/objref.h b/TAO/tests/Param_Test/objref.h
index 0798248ab0d..6cdfd531099 100644
--- a/TAO/tests/Param_Test/objref.h
+++ b/TAO/tests/Param_Test/objref.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/objref_struct.cpp b/TAO/tests/Param_Test/objref_struct.cpp
index c8298fad079..eee5a67d08f 100644
--- a/TAO/tests/Param_Test/objref_struct.cpp
+++ b/TAO/tests/Param_Test/objref_struct.cpp
@@ -51,12 +51,35 @@ void
 Test_Objref_Struct::dii_req_invoke (CORBA::Request *req,
                                     CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Objref_Struct);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Objref_Struct *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Objref_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Objref_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Objref_Struct (*tmp);
 }
 
 int
 Test_Objref_Struct::init_parameters (Param_Test_ptr objref,
-				                             CORBA::Environment &ACE_TRY_ENV)
+                                                             CORBA::Environment &ACE_TRY_ENV)
 {
   ACE_TRY
     {
@@ -71,7 +94,7 @@ Test_Objref_Struct::init_parameters (Param_Test_ptr objref,
       Coffee::Desc d;
       d.name = gen->gen_string ();
 
-      this->in_.y->description (d, 
+      this->in_.y->description (d,
                                 ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
@@ -122,68 +145,6 @@ Test_Objref_Struct::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Objref_Struct::add_args (CORBA::NVList_ptr param_list,
-                              CORBA::NVList_ptr retval,
-                              CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Objref_Struct,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Objref_Struct,
-                            &this->inout_.inout (), // .out () causes crash
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Objref_Struct,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Objref_Struct,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                                ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Objref_Struct::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return 0;
-}
-
-
 CORBA::Boolean
 Test_Objref_Struct::check_validity (void)
 {
@@ -195,7 +156,7 @@ Test_Objref_Struct::check_validity (void)
   ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
-    { 
+    {
       if (CORBA::is_nil (this->in_.y.in ())
           || CORBA::is_nil (this->out_->y.in ())
           || CORBA::is_nil (this->ret_->y.in ())
@@ -203,7 +164,7 @@ Test_Objref_Struct::check_validity (void)
         {
           return 0;
         }
- 
+
       Coffee::Desc_var s_in = this->in_.y->description (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
diff --git a/TAO/tests/Param_Test/objref_struct.h b/TAO/tests/Param_Test/objref_struct.h
index 3c2f0bed205..5ded88f67c5 100644
--- a/TAO/tests/Param_Test/objref_struct.h
+++ b/TAO/tests/Param_Test/objref_struct.h
@@ -38,10 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/param_test.idl b/TAO/tests/Param_Test/param_test.idl
index ca21de43115..ce69c42eae8 100644
--- a/TAO/tests/Param_Test/param_test.idl
+++ b/TAO/tests/Param_Test/param_test.idl
@@ -106,8 +106,8 @@ interface Param_Test
   typedef sequence<Step> PathSpec;
 
   PathSpec test_unbounded_struct_sequence (in PathSpec s1,
-					   inout PathSpec s2,
-					   out PathSpec s3);
+                                           inout PathSpec s2,
+                                           out PathSpec s3);
   typedef sequence<short> Short_Seq;
 
   Short_Seq test_short_sequence (in Short_Seq s1,
@@ -215,8 +215,8 @@ interface Param_Test
   Coffee test_objref (in Coffee o1, inout Coffee o2, out Coffee o3);
 
   // test typecodes
-  CORBA::TypeCode test_typecode (in CORBA::TypeCode t1, 
-                                 inout CORBA::TypeCode t2, 
+  CORBA::TypeCode test_typecode (in CORBA::TypeCode t1,
+                                 inout CORBA::TypeCode t2,
                                  out CORBA::TypeCode t3);
 
   // Anys. We try to pump in all kinds of data types thru these Anys
@@ -268,8 +268,8 @@ interface Param_Test
   exception BadBoy {
   };
   unsigned long test_exception (in unsigned long s1,
-				inout unsigned long s2,
-				out unsigned long s3)
+                                inout unsigned long s2,
+                                out unsigned long s3)
     raises (Ooops);
 
   union Big_Union switch (short)
@@ -324,8 +324,8 @@ interface Param_Test
       short level9_short;
     };
 
-  any test_complex_any (in any ca1, 
-                        inout any ca2, 
+  any test_complex_any (in any ca1,
+                        inout any ca2,
                         out any ca3);
 
   // Recursive structs. Contains a sequence of itself.
diff --git a/TAO/tests/Param_Test/recursive_struct.cpp b/TAO/tests/Param_Test/recursive_struct.cpp
index 641975a6281..3f868f8aefb 100644
--- a/TAO/tests/Param_Test/recursive_struct.cpp
+++ b/TAO/tests/Param_Test/recursive_struct.cpp
@@ -50,7 +50,30 @@ void
 Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req,
                                        CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Recursive_Struct);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Recursive_Struct *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Recursive_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Recursive_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Recursive_Struct (*tmp);
 }
 
 int
@@ -118,68 +141,6 @@ Test_Recursive_Struct::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Recursive_Struct::add_args (CORBA::NVList_ptr param_list,
-			                           CORBA::NVList_ptr retval,
-			                           CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Recursive_Struct,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Recursive_Struct,
-                            &this->inout_.inout (), // .out () causes crash
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Recursive_Struct,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("rs1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("rs2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("rs3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Recursive_Struct,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Recursive_Struct::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
-
 CORBA::Boolean
 Test_Recursive_Struct::check_validity (void)
 {
@@ -233,7 +194,7 @@ Test_Recursive_Struct::deep_init (Param_Test::Recursive_Struct &rs,
 {
   rs.x = gen->gen_long ();
 
-  if (level == 1) 
+  if (level == 1)
   // No more recursion.
     {
       rs.children.length (0);
@@ -262,7 +223,7 @@ CORBA::Boolean
 Test_Recursive_Struct::deep_check (const Param_Test::Recursive_Struct &in_struct,
                                    const Param_Test::Recursive_Struct &test_struct)
 {
-  // Do the CORBA::Long members match? 
+  // Do the CORBA::Long members match?
   if (in_struct.x != test_struct.x)
     {
       ACE_DEBUG ((LM_DEBUG,
@@ -284,7 +245,7 @@ Test_Recursive_Struct::deep_check (const Param_Test::Recursive_Struct &in_struct
   // Otherwise recurse.
   for (CORBA::ULong i = 0; i < in_struct.children.length (); i++)
     {
-      if (!this->deep_check (in_struct.children[i], 
+      if (!this->deep_check (in_struct.children[i],
                              test_struct.children[i]))
         {
           ACE_DEBUG ((LM_DEBUG,
diff --git a/TAO/tests/Param_Test/recursive_struct.h b/TAO/tests/Param_Test/recursive_struct.h
index 0ba2ba048e8..cb84b23be28 100644
--- a/TAO/tests/Param_Test/recursive_struct.h
+++ b/TAO/tests/Param_Test/recursive_struct.h
@@ -39,10 +39,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +58,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/recursive_union.cpp b/TAO/tests/Param_Test/recursive_union.cpp
index 991949e697d..bb0310d84ff 100644
--- a/TAO/tests/Param_Test/recursive_union.cpp
+++ b/TAO/tests/Param_Test/recursive_union.cpp
@@ -50,7 +50,30 @@ void
 Test_Recursive_Union::dii_req_invoke (CORBA::Request *req,
                                       CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Recursive_Union);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Recursive_Union *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Recursive_Union (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Recursive_Union (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->inout_ = new Param_Test::Recursive_Union (*tmp);
 }
 
 int
@@ -76,7 +99,7 @@ Test_Recursive_Union::reset_parameters (void)
   Generator *gen = GENERATOR::instance ();
 
   // Set the depth of recursion.
-  CORBA::ULong depth = 
+  CORBA::ULong depth =
     (CORBA::ULong) (gen->gen_long () % MAX_DEPTH) + 1;
 
   // Create a nested union to put in inout_.
@@ -120,68 +143,6 @@ Test_Recursive_Union::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Recursive_Union::add_args (CORBA::NVList_ptr param_list,
-			                          CORBA::NVList_ptr retval,
-			                          CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Recursive_Union,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Recursive_Union,
-                            &this->inout_.inout (), // .out () causes crash
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Recursive_Union,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("ru1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ru2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ru3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Recursive_Union,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Recursive_Union::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
-
 CORBA::Boolean
 Test_Recursive_Union::check_validity (void)
 {
@@ -233,10 +194,10 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru,
                                  Generator *gen,
                                  CORBA::ULong level)
 {
-  if (level == 1) 
+  if (level == 1)
   // No more recursion, just insert a nested_rec_union.
     {
-      CORBA::ULong nested_depth = 
+      CORBA::ULong nested_depth =
         (CORBA::ULong) (gen->gen_long () % MAX_DEPTH) + 1;
 
       Param_Test::nested_rec_union nru;
@@ -256,7 +217,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru,
   else
     {
       // Generate a member sequence.
-      CORBA::ULong len = 
+      CORBA::ULong len =
         (CORBA::ULong) (gen->gen_long () % MAX_SEQ_LENGTH) + 1;
 
       // This line is TAO-specific, but some compilers we support
@@ -321,7 +282,7 @@ CORBA::Boolean
 Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union,
                                   const Param_Test::Recursive_Union &test_union)
 {
-  // Do the discriminators match? 
+  // Do the discriminators match?
   if (in_union._d () != test_union._d ())
     {
       ACE_DEBUG ((LM_DEBUG,
@@ -336,7 +297,7 @@ Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union,
       case 0:
         {
           // Do the sequence lengths match?
-          if (in_union.rec_member ().length () != 
+          if (in_union.rec_member ().length () !=
                 test_union.rec_member ().length ())
             {
               ACE_DEBUG ((LM_DEBUG,
@@ -347,7 +308,7 @@ Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union,
 
           for (CORBA::ULong i = 0; i < in_union.rec_member ().length (); i++)
             {
-              if (!this->deep_check (in_union.rec_member ()[i], 
+              if (!this->deep_check (in_union.rec_member ()[i],
                                      test_union.rec_member ()[i]))
                 {
                   ACE_DEBUG ((LM_DEBUG,
@@ -390,7 +351,7 @@ Test_Recursive_Union::deep_check_nested (const Param_Test::nested_rec_union &in,
   switch (in._d ())
     {
       // Active member is the long integer.
-      case 0:        
+      case 0:
         // Do the nested_rec_union member values match?
         if (in.value () != test.value ())
           {
@@ -417,7 +378,7 @@ Test_Recursive_Union::deep_check_nested (const Param_Test::nested_rec_union &in,
 
           for (CORBA::ULong i = 0; i < in.nested_rec_member ().length (); i++)
             {
-              if (!this->deep_check_nested (in.nested_rec_member ()[i], 
+              if (!this->deep_check_nested (in.nested_rec_member ()[i],
                                             test.nested_rec_member ()[i]))
                 {
                   ACE_DEBUG ((LM_DEBUG,
diff --git a/TAO/tests/Param_Test/recursive_union.h b/TAO/tests/Param_Test/recursive_union.h
index 0b371d5489b..3dad5de6eaf 100644
--- a/TAO/tests/Param_Test/recursive_union.h
+++ b/TAO/tests/Param_Test/recursive_union.h
@@ -39,10 +39,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +58,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/short.cpp b/TAO/tests/Param_Test/short.cpp
index 704cf53718c..f8d8bd3a5f0 100644
--- a/TAO/tests/Param_Test/short.cpp
+++ b/TAO/tests/Param_Test/short.cpp
@@ -46,7 +46,26 @@ void
 Test_Short::dii_req_invoke (CORBA::Request *req,
                             CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_;
+
+  req->set_return_type (CORBA::_tc_short);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  req->return_value () >>= this->ret_;
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= this->inout_;
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= this->out_;
 }
 
 int
@@ -93,69 +112,6 @@ Test_Short::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Short::add_args (CORBA::NVList_ptr param_list,
-                      CORBA::NVList_ptr retval,
-                      CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // we provide top level memory to the ORB to retrieve the data
-      CORBA::Any in_arg (CORBA::_tc_short,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_short,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_short,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value. Let the ORB allocate storage. We simply tell the ORB
-      // what type we are expecting.
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_short,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Short::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Short::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/short.h b/TAO/tests/Param_Test/short.h
index d512befbc31..285bd3ec428 100644
--- a/TAO/tests/Param_Test/short.h
+++ b/TAO/tests/Param_Test/short.h
@@ -37,15 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-/*
-  int add_args (CORBA::Request_ptr &req,
-                CORBA::Environment &env);
-  // add args to DII request using << operator
-*/
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/typecode.cpp b/TAO/tests/Param_Test/typecode.cpp
index f4e491f5a99..7c725f46137 100644
--- a/TAO/tests/Param_Test/typecode.cpp
+++ b/TAO/tests/Param_Test/typecode.cpp
@@ -46,7 +46,30 @@ void
 Test_TypeCode::dii_req_invoke (CORBA::Request *req,
                                CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (CORBA::_tc_TypeCode);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  CORBA::TypeCode_ptr tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = CORBA::TypeCode::_duplicate (tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = CORBA::TypeCode::_duplicate (tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = CORBA::TypeCode::_duplicate (tmp);
 }
 
 int
@@ -67,8 +90,8 @@ Test_TypeCode::init_parameters (Param_Test_ptr,
     };
 
   Generator *gen = GENERATOR::instance (); // value generator
-  CORBA::ULong index =
-    (CORBA::ULong) (gen->gen_long () % sizeof(tc_table)/sizeof(CORBA::TypeCode_ptr));
+  static CORBA::ULong index = 0;
+  // (CORBA::ULong) (gen->gen_long () % sizeof(tc_table)/sizeof(tc_table[0]));
 
   this->tc_holder_ = CORBA::TypeCode::_duplicate (tc_table [index]);
   this->in_ = this->tc_holder_;
@@ -78,6 +101,10 @@ Test_TypeCode::init_parameters (Param_Test_ptr,
   this->out_ = CORBA::TypeCode::_duplicate (CORBA::_tc_null);
   this->ret_ = CORBA::TypeCode::_duplicate (CORBA::_tc_null);
 
+  index++;
+  if (index >= sizeof(tc_table)/sizeof(tc_table[0]))
+    index = 0;
+
   return 0;
 }
 
@@ -95,6 +122,8 @@ Test_TypeCode::run_sii_test (Param_Test_ptr objref,
 {
   ACE_TRY
     {
+      this->init_parameters (objref, ACE_TRY_ENV);
+
       CORBA::TypeCode_out out (this->out_);
 
       this->ret_ = objref->test_typecode (this->in_.in (),
@@ -115,67 +144,6 @@ Test_TypeCode::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_TypeCode::add_args (CORBA::NVList_ptr param_list,
-			 CORBA::NVList_ptr retval,
-			 CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (CORBA::_tc_TypeCode,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_TypeCode,
-                             &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_TypeCode,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_TypeCode,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_TypeCode::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_TypeCode::check_validity (void)
 {
@@ -185,15 +153,15 @@ Test_TypeCode::check_validity (void)
     {
       CORBA::Boolean one, two, three;
 
-      one = this->in_.in ()->equal (this->inout_.in (), 
+      one = this->in_.in ()->equal (this->inout_.in (),
                                     ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      two = this->in_.in ()->equal (this->out_.in (), 
+      two = this->in_.in ()->equal (this->out_.in (),
                                     ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      three = this->in_.in ()->equal (this->ret_.in (), 
+      three = this->in_.in ()->equal (this->ret_.in (),
                                       ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
diff --git a/TAO/tests/Param_Test/typecode.h b/TAO/tests/Param_Test/typecode.h
index 06933e73d48..cde6cfb1c2a 100644
--- a/TAO/tests/Param_Test/typecode.h
+++ b/TAO/tests/Param_Test/typecode.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_any_seq.cpp b/TAO/tests/Param_Test/ub_any_seq.cpp
index 3d8f4dcebf6..dd76733f011 100644
--- a/TAO/tests/Param_Test/ub_any_seq.cpp
+++ b/TAO/tests/Param_Test/ub_any_seq.cpp
@@ -53,7 +53,30 @@ void
 Test_AnySeq::dii_req_invoke (CORBA::Request *req,
                              CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_AnySeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::AnySeq* tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::AnySeq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::AnySeq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::AnySeq (*tmp);
 }
 
 int
@@ -198,66 +221,6 @@ Test_AnySeq::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_AnySeq::add_args (CORBA::NVList_ptr param_list,
-                       CORBA::NVList_ptr retval,
-                       CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_AnySeq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_AnySeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_AnySeq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_AnySeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_AnySeq::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_AnySeq::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_any_seq.h b/TAO/tests/Param_Test/ub_any_seq.h
index 4d65e04e0d5..832921be5d0 100644
--- a/TAO/tests/Param_Test/ub_any_seq.h
+++ b/TAO/tests/Param_Test/ub_any_seq.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_array_seq.cpp b/TAO/tests/Param_Test/ub_array_seq.cpp
index 82296fc1fd9..c21ca596b33 100644
--- a/TAO/tests/Param_Test/ub_array_seq.cpp
+++ b/TAO/tests/Param_Test/ub_array_seq.cpp
@@ -49,7 +49,30 @@ void
 Test_Array_Sequence::dii_req_invoke (CORBA::Request *req,
                                      CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_ArraySeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::ArraySeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::ArraySeq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::ArraySeq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::ArraySeq (*tmp);
 }
 
 int
@@ -95,7 +118,7 @@ int
 Test_Array_Sequence::reset_parameters (void)
 {
   // Delete the previous ones.
-  this->inout_ = new Param_Test::ArraySeq; 
+  this->inout_ = new Param_Test::ArraySeq;
   this->out_ = new Param_Test::ArraySeq;
   this->ret_ = new Param_Test::ArraySeq;
   return 0;
@@ -127,66 +150,6 @@ Test_Array_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Array_Sequence::add_args (CORBA::NVList_ptr param_list,
-                               CORBA::NVList_ptr retval,
-                               CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_ArraySeq,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_ArraySeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_ArraySeq,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_ArraySeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Array_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Array_Sequence::check_validity (void)
 {
@@ -284,5 +247,3 @@ Test_Array_Sequence::print_sequence (const Param_Test::ArraySeq &s)
         }
     }
 }
-
-
diff --git a/TAO/tests/Param_Test/ub_array_seq.h b/TAO/tests/Param_Test/ub_array_seq.h
index 1d8b0457136..0f7a0060dbf 100644
--- a/TAO/tests/Param_Test/ub_array_seq.h
+++ b/TAO/tests/Param_Test/ub_array_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +57,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/ub_long_seq.cpp b/TAO/tests/Param_Test/ub_long_seq.cpp
index 318e56a6e9e..01ac31fc98b 100644
--- a/TAO/tests/Param_Test/ub_long_seq.cpp
+++ b/TAO/tests/Param_Test/ub_long_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_Long_Sequence::dii_req_invoke (CORBA::Request *req,
                                     CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Long_Seq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Long_Seq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = Param_Test::Long_Seq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = Param_Test::Long_Seq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = Param_Test::Long_Seq (*tmp);
 }
 
 int
@@ -109,66 +132,6 @@ Test_Long_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Long_Sequence::add_args (CORBA::NVList_ptr param_list,
-                               CORBA::NVList_ptr retval,
-                               CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Long_Seq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Long_Seq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Long_Seq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Long_Seq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Long_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Long_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_long_seq.h b/TAO/tests/Param_Test/ub_long_seq.h
index 1dfab9de0c0..0a57a526d38 100644
--- a/TAO/tests/Param_Test/ub_long_seq.h
+++ b/TAO/tests/Param_Test/ub_long_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_objref_seq.cpp b/TAO/tests/Param_Test/ub_objref_seq.cpp
index de46b035af2..7c540d19e52 100644
--- a/TAO/tests/Param_Test/ub_objref_seq.cpp
+++ b/TAO/tests/Param_Test/ub_objref_seq.cpp
@@ -60,7 +60,30 @@ void
 Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req,
                                       CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Coffee_Mix);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Coffee_Mix *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Coffee_Mix (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Coffee_Mix (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Coffee_Mix (*tmp);
 }
 
 int
@@ -145,66 +168,6 @@ Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_ObjRef_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                CORBA::NVList_ptr retval,
-                                CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Coffee_Mix,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Coffee_Mix,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Coffee_Mix,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Coffee_Mix,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Objref_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_ObjRef_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_objref_seq.h b/TAO/tests/Param_Test/ub_objref_seq.h
index e660e0aaaf2..b1736c89fd7 100644
--- a/TAO/tests/Param_Test/ub_objref_seq.h
+++ b/TAO/tests/Param_Test/ub_objref_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_short_seq.cpp b/TAO/tests/Param_Test/ub_short_seq.cpp
index 30c50ed6870..515336bbd94 100644
--- a/TAO/tests/Param_Test/ub_short_seq.cpp
+++ b/TAO/tests/Param_Test/ub_short_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_Short_Sequence::dii_req_invoke (CORBA::Request *req,
                                      CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Short_Seq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Short_Seq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Short_Seq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Short_Seq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Short_Seq (*tmp);
 }
 
 int
@@ -111,66 +134,6 @@ Test_Short_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Short_Sequence::add_args (CORBA::NVList_ptr param_list,
-                               CORBA::NVList_ptr retval,
-                               CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Short_Seq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Short_Seq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Short_Seq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Short_Seq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Short_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Short_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_short_seq.h b/TAO/tests/Param_Test/ub_short_seq.h
index b9ad0469149..9aa38e21a8e 100644
--- a/TAO/tests/Param_Test/ub_short_seq.h
+++ b/TAO/tests/Param_Test/ub_short_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_str_seq.cpp b/TAO/tests/Param_Test/ub_str_seq.cpp
index c64107fb3bc..301a40ce27c 100644
--- a/TAO/tests/Param_Test/ub_str_seq.cpp
+++ b/TAO/tests/Param_Test/ub_str_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_String_Sequence::dii_req_invoke (CORBA::Request *req,
                                       CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_StrSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::StrSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::StrSeq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::StrSeq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::StrSeq (*tmp);
 }
 
 int
@@ -115,66 +138,6 @@ Test_String_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_String_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                CORBA::NVList_ptr retval,
-                                CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_StrSeq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_StrSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_StrSeq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_StrSeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_String_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_String_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_str_seq.h b/TAO/tests/Param_Test/ub_str_seq.h
index 97972a1cdec..24f438c84b7 100644
--- a/TAO/tests/Param_Test/ub_str_seq.h
+++ b/TAO/tests/Param_Test/ub_str_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_string.cpp b/TAO/tests/Param_Test/ub_string.cpp
index ad9e101c020..7227810e0ed 100644
--- a/TAO/tests/Param_Test/ub_string.cpp
+++ b/TAO/tests/Param_Test/ub_string.cpp
@@ -58,7 +58,30 @@ void
 Test_Unbounded_String::dii_req_invoke (CORBA::Request *req,
                                        CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_;
+
+  req->set_return_type (CORBA::_tc_string);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  char *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = CORBA::string_dup (tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = CORBA::string_dup (tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = CORBA::string_dup (tmp);
 }
 
 int
@@ -124,66 +147,6 @@ Test_Unbounded_String::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Unbounded_String::add_args (CORBA::NVList_ptr param_list,
-				 CORBA::NVList_ptr retval,
-				 CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (CORBA::_tc_string,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_string,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_string,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_string,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_String_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Unbounded_String::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_string.h b/TAO/tests/Param_Test/ub_string.h
index 7a5ffc45210..f20176a3e98 100644
--- a/TAO/tests/Param_Test/ub_string.h
+++ b/TAO/tests/Param_Test/ub_string.h
@@ -37,15 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-/*
-  int add_args (CORBA::Request_ptr &req,
-                CORBA::Environment &env);
-  // add args to DII request using << operator
-*/
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_struct_seq.cpp b/TAO/tests/Param_Test/ub_struct_seq.cpp
index 6c25e5863a6..0b6cbc779e7 100644
--- a/TAO/tests/Param_Test/ub_struct_seq.cpp
+++ b/TAO/tests/Param_Test/ub_struct_seq.cpp
@@ -51,7 +51,30 @@ void
 Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req,
                                       CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_StructSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::StructSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::StructSeq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::StructSeq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::StructSeq (*tmp);
 }
 
 int
@@ -112,66 +135,6 @@ Test_Struct_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Struct_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                CORBA::NVList_ptr retval,
-                                CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_StructSeq,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_StructSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_StructSeq,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_StructSeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Struct_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Struct_Sequence::check_validity (void)
 {
@@ -295,7 +258,30 @@ void
 Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req,
                                                 CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_PathSpec);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::PathSpec *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::PathSpec (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::PathSpec (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::PathSpec (*tmp);
 }
 
 int
@@ -345,47 +331,6 @@ Test_Unbounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref,
   return 0;
 }
 
-int
-Test_Unbounded_Struct_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                          CORBA::NVList_ptr retval,
-                                          CORBA::Environment &ACE_TRY_ENV)
-{
-  CORBA::Any in_arg (Param_Test::_tc_PathSpec,
-                     &this->in_,
-                     0);
-
-  CORBA::Any inout_arg (Param_Test::_tc_PathSpec,
-                        &this->inout_.inout (),
-                        0);
-
-  CORBA::Any out_arg (Param_Test::_tc_PathSpec,
-                      &this->out_.inout (),
-                      0);
-
-  // add parameters
-  param_list->add_value ("s1",
-                         in_arg,
-                         CORBA::ARG_IN,
-                         ACE_TRY_ENV);
-
-  param_list->add_value ("s2",
-                         inout_arg,
-                         CORBA::ARG_INOUT,
-                         ACE_TRY_ENV);
-
-  param_list->add_value ("s3",
-                         out_arg,
-                         CORBA::ARG_OUT,
-                         ACE_TRY_ENV);
-
-  // add return value type
-  retval->item (0, ACE_TRY_ENV)->value ()->replace (Param_Test::_tc_PathSpec,
-                                            &this->ret_.inout (),
-                                            0,
-                                            ACE_TRY_ENV);
-  return 0;
-}
-
 CORBA::Boolean
 Test_Unbounded_Struct_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_struct_seq.h b/TAO/tests/Param_Test/ub_struct_seq.h
index eeca962f963..465b6b5574d 100644
--- a/TAO/tests/Param_Test/ub_struct_seq.h
+++ b/TAO/tests/Param_Test/ub_struct_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
@@ -106,11 +101,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/ub_wstr_seq.cpp b/TAO/tests/Param_Test/ub_wstr_seq.cpp
index 51a279263be..d30f7caf3e9 100644
--- a/TAO/tests/Param_Test/ub_wstr_seq.cpp
+++ b/TAO/tests/Param_Test/ub_wstr_seq.cpp
@@ -50,7 +50,30 @@ void
 Test_WString_Sequence::dii_req_invoke (CORBA::Request *req,
                                        CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_.in ();
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_WStrSeq);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::WStrSeq *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::WStrSeq (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::WStrSeq (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::WStrSeq (*tmp);
 }
 
 int
@@ -117,66 +140,6 @@ Test_WString_Sequence::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_WString_Sequence::add_args (CORBA::NVList_ptr param_list,
-                                 CORBA::NVList_ptr retval,
-                                 CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_WStrSeq,
-                         (void *) &this->in_.in (),
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_WStrSeq,
-                            &this->inout_.inout (),
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_WStrSeq,
-                          &this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("ws1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_WStrSeq,
-                               &this->ret_.inout (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_WString_Sequence::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_WString_Sequence::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_wstr_seq.h b/TAO/tests/Param_Test/ub_wstr_seq.h
index d91fd0380d2..fee0572fb65 100644
--- a/TAO/tests/Param_Test/ub_wstr_seq.h
+++ b/TAO/tests/Param_Test/ub_wstr_seq.h
@@ -38,11 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
@@ -62,7 +57,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/ub_wstring.cpp b/TAO/tests/Param_Test/ub_wstring.cpp
index 73b9f6fde18..100a2f9f691 100644
--- a/TAO/tests/Param_Test/ub_wstring.cpp
+++ b/TAO/tests/Param_Test/ub_wstring.cpp
@@ -58,7 +58,30 @@ void
 Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req,
                                         CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_;
+
+  req->set_return_type (CORBA::_tc_wstring);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  CORBA::WChar *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = CORBA::wstring_dup (tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = CORBA::wstring_dup (tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = CORBA::wstring_dup (tmp);
 }
 
 int
@@ -123,68 +146,6 @@ Test_Unbounded_WString::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Unbounded_WString::add_args (CORBA::NVList_ptr param_list,
-				                          CORBA::NVList_ptr retval,
-				                          CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // create the parameters
-      CORBA::Any in_arg (CORBA::_tc_wstring,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_wstring,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_wstring,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("ws1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("ws3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_wstring,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Unbounded_WString::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Unbounded_WString::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ub_wstring.h b/TAO/tests/Param_Test/ub_wstring.h
index 7b7c37d27a0..e2509254885 100644
--- a/TAO/tests/Param_Test/ub_wstring.h
+++ b/TAO/tests/Param_Test/ub_wstring.h
@@ -37,15 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-/*
-  int add_args (CORBA::Request_ptr &req,
-                CORBA::Environment &env);
-  // add args to DII request using << operator
-*/
   const char *opname (void) const;
   // return operation name
 
@@ -65,7 +56,7 @@ public:
   void print_values (void);
   // print all the values
 
-  void dii_req_invoke (CORBA::Request *, 
+  void dii_req_invoke (CORBA::Request *,
                        CORBA::Environment &);
   // invoke DII request with appropriate exception handling.
 
diff --git a/TAO/tests/Param_Test/ulonglong.cpp b/TAO/tests/Param_Test/ulonglong.cpp
index ae767374b25..9d3dad8b76e 100644
--- a/TAO/tests/Param_Test/ulonglong.cpp
+++ b/TAO/tests/Param_Test/ulonglong.cpp
@@ -42,7 +42,26 @@ void
 Test_ULongLong::dii_req_invoke (CORBA::Request *req,
                                 CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_;
+  req->add_out_arg ("s3") <<= this->out_;
+
+  req->set_return_type (CORBA::_tc_ulonglong);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  req->return_value () >>= this->ret_;
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= this->inout_;
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= this->out_;
 }
 
 int
@@ -90,69 +109,6 @@ Test_ULongLong::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_ULongLong::add_args (CORBA::NVList_ptr param_list,
-                          CORBA::NVList_ptr retval,
-                          CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      // we provide top level memory to the ORB to retrieve the data
-      CORBA::Any in_arg (CORBA::_tc_ulonglong,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (CORBA::_tc_ulonglong,
-                            &this->inout_,
-                            0);
-
-      CORBA::Any out_arg (CORBA::_tc_ulonglong,
-                          &this->out_,
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value. Let the ORB allocate storage. We simply tell the ORB
-      // what type we are expecting.
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (CORBA::_tc_ulonglong,
-                               &this->ret_,
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_ULongLong::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_ULongLong::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/ulonglong.h b/TAO/tests/Param_Test/ulonglong.h
index 2b27a929b0f..452f9721aa6 100644
--- a/TAO/tests/Param_Test/ulonglong.h
+++ b/TAO/tests/Param_Test/ulonglong.h
@@ -34,10 +34,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/var_array.cpp b/TAO/tests/Param_Test/var_array.cpp
index 235659d0e85..ea7a29e70f9 100644
--- a/TAO/tests/Param_Test/var_array.cpp
+++ b/TAO/tests/Param_Test/var_array.cpp
@@ -48,7 +48,31 @@ void
 Test_Var_Array::dii_req_invoke (CORBA::Request *req,
                                 CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= Param_Test::Var_Array_forany (this->in_);
+  req->add_inout_arg ("s2") <<= Param_Test::Var_Array_forany (this->inout_);
+  req->add_out_arg ("s3") <<= Param_Test::Var_Array_forany (this->out_.inout ());
+
+  req->set_return_type (Param_Test::_tc_Var_Array);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Var_Array_forany forany;
+
+  req->return_value () >>= forany;
+  this->ret_ = Param_Test::Var_Array_dup (forany.in ());
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= forany;
+  Param_Test::Var_Array_copy (this->inout_, forany.in ());
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= forany;
+  this->out_ = Param_Test::Var_Array_dup (forany.in ());
 }
 
 int
@@ -103,66 +127,6 @@ Test_Var_Array::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Var_Array::add_args (CORBA::NVList_ptr param_list,
-			  CORBA::NVList_ptr retval,
-			  CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Var_Array,
-                         this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Var_Array,
-                            this->inout_,
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Var_Array,
-                          this->out_.inout (), // .out () causes crash
-                          0);
-
-      // add parameters
-      param_list->add_value ("v1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("v2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("v3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Var_Array,
-                               this->ret_.in (),
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Var_Array::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
 CORBA::Boolean
 Test_Var_Array::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/var_array.h b/TAO/tests/Param_Test/var_array.h
index 64c362f1d61..f281f8dc558 100644
--- a/TAO/tests/Param_Test/var_array.h
+++ b/TAO/tests/Param_Test/var_array.h
@@ -37,11 +37,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
-
   const char *opname (void) const;
   // return operation name
 
diff --git a/TAO/tests/Param_Test/var_struct.cpp b/TAO/tests/Param_Test/var_struct.cpp
index 5104f3bcdd1..771b21dfbaa 100644
--- a/TAO/tests/Param_Test/var_struct.cpp
+++ b/TAO/tests/Param_Test/var_struct.cpp
@@ -51,7 +51,30 @@ void
 Test_Var_Struct::dii_req_invoke (CORBA::Request *req,
                                  CORBA::Environment &ACE_TRY_ENV)
 {
+  req->add_in_arg ("s1") <<= this->in_;
+  req->add_inout_arg ("s2") <<= this->inout_.in ();
+  req->add_out_arg ("s3") <<= this->out_.in ();
+
+  req->set_return_type (Param_Test::_tc_Var_Struct);
+
   req->invoke (ACE_TRY_ENV);
+  ACE_CHECK;
+
+  Param_Test::Var_Struct *tmp;
+  req->return_value () >>= tmp;
+  this->ret_ = new Param_Test::Var_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o2 =
+    req->arguments ()->item (1, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o2->value () >>= tmp;
+  this->inout_ = new Param_Test::Var_Struct (*tmp);
+
+  CORBA::NamedValue_ptr o3 =
+    req->arguments ()->item (2, ACE_TRY_ENV);
+  ACE_CHECK;
+  *o3->value () >>= tmp;
+  this->out_ = new Param_Test::Var_Struct (*tmp);
 }
 
 int
@@ -115,68 +138,6 @@ Test_Var_Struct::run_sii_test (Param_Test_ptr objref,
   return -1;
 }
 
-int
-Test_Var_Struct::add_args (CORBA::NVList_ptr param_list,
-			   CORBA::NVList_ptr retval,
-			   CORBA::Environment &ACE_TRY_ENV)
-{
-  ACE_TRY
-    {
-      CORBA::Any in_arg (Param_Test::_tc_Var_Struct,
-                         &this->in_,
-                         0);
-
-      CORBA::Any inout_arg (Param_Test::_tc_Var_Struct,
-                            &this->inout_.inout (), // .out () causes crash
-                            0);
-
-      CORBA::Any out_arg (Param_Test::_tc_Var_Struct,
-                          &this->out_.inout (),
-                          0);
-
-      // add parameters
-      param_list->add_value ("s1",
-                             in_arg,
-                             CORBA::ARG_IN,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s2",
-                             inout_arg,
-                             CORBA::ARG_INOUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      param_list->add_value ("s3",
-                             out_arg,
-                             CORBA::ARG_OUT,
-                             ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      // add return value
-      CORBA::NamedValue *item = retval->item (0,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      item->value ()->replace (Param_Test::_tc_Var_Struct,
-                               &this->ret_.inout (), // see above
-                               0, // does not own
-                               ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      return 0;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Test_Var_Struct::add_args\n");
-
-    }
-  ACE_ENDTRY;
-  return -1;
-}
-
-
 CORBA::Boolean
 Test_Var_Struct::check_validity (void)
 {
diff --git a/TAO/tests/Param_Test/var_struct.h b/TAO/tests/Param_Test/var_struct.h
index b28e8d59bb8..de08ee37c24 100644
--- a/TAO/tests/Param_Test/var_struct.h
+++ b/TAO/tests/Param_Test/var_struct.h
@@ -38,10 +38,6 @@ public:
                     CORBA::Environment &env);
   // run the SII test
 
-  int add_args (CORBA::NVList_ptr nvlist,
-                CORBA::NVList_ptr retval,
-                CORBA::Environment &env);
-  // add args to NVList for DII
   const char *opname (void) const;
   // return operation name