*** empty log message ***

14 files changed, 939 insertions, 1094 deletions

diff --git a/TAO/tao/Connect.cpp b/TAO/tao/Connect.cpp
index 01d548e39e8..b759ac5157a 100644
--- a/TAO/tao/Connect.cpp
+++ b/TAO/tao/Connect.cpp
@@ -261,21 +261,17 @@ TAO_Server_Connection_Handler::handle_request (const TAO_GIOP_RequestHeader &hdr
   TAO_POA *the_poa =
     TAO_ORB_Core_instance ()->root_poa ();
 
-  IIOP_ServerRequest svr_req (&request_body,
+  IIOP_ServerRequest svr_req (hdr,
+                              &request_body,
                               &response,
-                              hdr.request_id,
                               TAO_ORB_Core_instance ()->orb (),
                               the_poa);
 
-  // Why are we copying this when we can just pass in a handle to the
-  // hdr?
-  svr_req.opname_ = hdr.operation;
-
   the_poa->dispatch_servant (hdr.object_key,
                              svr_req,
                              0, // this is SunSoft IIOP residue
                              env);
-  svr_req.release ();
+
 #if 0
   // @@ (ASG) - this commented out code must remain here since the DSI will use
   // it. Please keep it here until I have figured out the best way out 03/22/98.
diff --git a/TAO/tao/IIOP_Interpreter.cpp b/TAO/tao/IIOP_Interpreter.cpp
index 6baf82873c6..839b50ad68c 100644
--- a/TAO/tao/IIOP_Interpreter.cpp
+++ b/TAO/tao/IIOP_Interpreter.cpp
@@ -6,12 +6,12 @@
 
 #include "tao/corba.h"
 
-TAO_IIOP_Interpreter::Table_Element 
+TAO_IIOP_Interpreter::Table_Element
 TAO_IIOP_Interpreter::table_[CORBA::TC_KIND_COUNT] =
 {
   { 0, 1, 0 },                            // CORBA::tk_null
   { 0, 1, 0 },                            // CORBA::tk_void
- 
+
   { 0, 1, 0, 0 },                         // CORBA::tk_short
   { 0, 1, 0, 0 },                         // CORBA::tk_long
   { 0, 1, 0, 0 },                         // CORBA::tk_ushort
@@ -782,94 +782,6 @@ TAO_IIOP_Interpreter::calc_array_attributes (CDR *stream,
   return member_size * (size_t) member_count;
 }
 
-// Visit each of the elements of a structure.
-
-CORBA::TypeCode::traverse_status
-TAO_IIOP_Interpreter::struct_traverse (CDR *stream,
-                                       const void *value1,
-                                       const void *value2,
-                                       CORBA::TypeCode::traverse_status (_FAR *visit)
-                                       (CORBA::TypeCode_ptr tc,
-                                        const void *value1,
-                                        const void *value2,
-                                        void *context,
-                                        CORBA::Environment &env),
-                                       void *context,
-                                       CORBA::Environment &env)
-{
-  // Skip over the type ID and type name in the parameters, then get
-  // the number of members.
-  CORBA::ULong members;
-
-  if (!stream->skip_string ()                   // type ID
-      || !stream->skip_string ()                // type name
-      || !stream->get_ulong (members))
-    {
-      env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-      return CORBA::TypeCode::TRAVERSE_STOP;
-    }
-
-  // Visit each member of the structure/exception.  The initial
-  // pointer(s) point at the first values to visit.  For structs we
-  // could avoid the inter-member padding ... not for the case of
-  // exceptions.  No big deal.
-  //
-  // NOTE: For last element, could turn visit() call into something
-  // subject to compiler's tail call optimization and thus save a
-  // stack frame.
-
-  CORBA::TypeCode::traverse_status retval;
-
-  for (retval = CORBA::TypeCode::TRAVERSE_CONTINUE;
-       members != 0 && retval == CORBA::TypeCode::TRAVERSE_CONTINUE;
-       members--)
-    {
-      CORBA::TypeCode member_tc (CORBA::tk_null);
-      size_t size;
-      size_t alignment;
-
-      // Skip the member's name in the parameter list.
-
-      if (!stream->skip_string ())
-        {
-          env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-          return CORBA::TypeCode::TRAVERSE_STOP;
-        }
-
-      // Get the member's size, alignment, and a temporary TypeCode,
-      // skipping that TypeCode in the stream as we do so.
-      //
-      // This accounts for all variations: different or nonexistent
-      // parameter lists, errors such as out-of-range TCKind values or
-      // nested exceptions, and indirected typecodes.
-
-      size = calc_nested_size_and_alignment (&member_tc,
-                                             stream,
-                                             alignment,
-                                             env);
-      if (env.exception () != 0)
-        return CORBA::TypeCode::TRAVERSE_STOP;
-
-      // Pad the value pointers to account for the alignment
-      // requirements of this member, then visit.
-
-      value1 = ptr_align_binary ((const u_char *) value1, alignment);
-      value2 = ptr_align_binary ((const u_char *) value2, alignment);
-
-      retval = visit (&member_tc, value1, value2, context, env);
-
-      // Update 'value' pointers to account for the size of the values
-      // just visited.
-      value1 = size + (char *)value1;
-      value2 = size + (char *)value2;
-
-      if (env.exception () != 0)
-        retval = CORBA::TypeCode::TRAVERSE_STOP;
-    }
-
-  return retval;
-}
-
 // Cast the discriminant values to the right type and compare them.
 
 CORBA::Boolean
@@ -956,178 +868,3 @@ TAO_IIOP_Interpreter::match_value (CORBA::TCKind kind,
 
   return retval;
 }
-
-// Visit the two elements of the union: the discrminant, and then any
-// specific value as indicated by the discriminant of value1.
-
-CORBA::TypeCode::traverse_status
-TAO_IIOP_Interpreter::union_traverse (CDR *stream,
-                            const void *value1,
-                            const void *value2,
-                            CORBA::TypeCode::traverse_status (_FAR *visit)
-                            (CORBA::TypeCode_ptr tc,
-                             const void *value1,
-                             const void *value2,
-                             void *context,
-                             CORBA::Environment &env),
-                            void *context,
-                            CORBA::Environment &env)
-{
-  size_t discrim_size_with_pad;
-
-  // Figure out size of discriminant plus padding, used to adjust
-  // value pointers later.  This can't be calculated without looking
-  // at all branches of the union ... forcing union traversal to be a
-  // two-pass algorithm, unless/until some data gets squirreled away.
-  {
-    // TODO provide a method to "copy" the CDR stream...
-    CDR temp_cdr (*stream);
-    size_t scratch;
-
-    (void) calc_key_union_attributes (&temp_cdr,
-                                      scratch,
-                                      discrim_size_with_pad,
-                                      env);
-  }
-  if (env.exception() != 0)
-    return CORBA::TypeCode::TRAVERSE_STOP;
-
-  // Skip the optional type ID and type name.
-  if (!stream->skip_string ()                   // type ID, hidden
-      || !stream->skip_string ())
-    {   // typedef name
-      env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-      return CORBA::TypeCode::TRAVERSE_STOP;
-    }
-
-  // Get and skip the discriminant's TypeCode.  This allow for
-  // indirection (e.g. a complex enum discriminant).  We use that
-  // TypeCode to visit the discriminant.
-  //
-  // We know the kind is legal and the TypeCode is valid because this
-  // repeats work we did earlier -- so checks are omitted.
-
-  CORBA::TypeCode discrim_tc (CORBA::tk_null);
-
-  size_t scratch;
-
-  (void) calc_nested_size_and_alignment (&discrim_tc,
-                                         stream,
-                                         scratch,
-                                         env);
-  if (visit (&discrim_tc,
-             value1,
-             value2,
-             context,
-             env) == CORBA::TypeCode::TRAVERSE_STOP)
-    return CORBA::TypeCode::TRAVERSE_STOP;
-
-  // Adjust the pointers to point to the other member of the union;
-  // this ensures alignment for any of the values.  Save the pointer
-  // to the discriminant though; we need it to find out which member
-  // to visit!
-
-  const void *discrim_ptr = value1;
-
-  value1 = discrim_size_with_pad + (char *) value1;
-  value2 = discrim_size_with_pad + (char *) value2;
-
-  // Get the flag that tells if there's a "default" arm in this union,
-  // then the number of members in the union.
-
-  CORBA::Long default_used = 0;
-  CORBA::ULong member_count;
-
-  if (!stream->get_long (default_used))
-    {
-      // default used
-      env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-      return CORBA::TypeCode::TRAVERSE_STOP;
-    }
-
-  if (!stream->get_ulong (member_count))
-    {  // member count
-      env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-      return CORBA::TypeCode::TRAVERSE_STOP;
-    }
-
-  // Scan to find the tuple whose value matches the discriminator.
-  //
-  // While we're scanning, record any default arm's information.  If
-  // we can't find a match for the discriminant value, that arm will
-  // be used later.
-
-  char *default_tc_ptr = 0;
-  size_t default_tc_len = 0;
-
-  while (member_count-- != 0)
-    {
-      // Test to see if the discriminant value matches the one in the
-      // TypeCode; this skips the the discriminant value in this CDR
-      // stream.
-
-      CORBA::Boolean discrim_matched;
-
-      discrim_matched = match_value (discrim_tc.kind_,
-                                     stream,
-                                     discrim_ptr,
-                                     env);
-      if (env.exception () != 0)
-        return CORBA::TypeCode::TRAVERSE_STOP;
-
-      // Skip the name of the member; we never care about it.
-
-      if (!stream->skip_string ())
-        {
-          env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-          return CORBA::TypeCode::TRAVERSE_STOP;
-        }
-
-      // If this is the default member, remember where its typecode
-      // data is stored; we'll use it later.
-
-      if (default_used >= 0 && default_used-- == 0)
-        {
-          default_tc_ptr = stream->buffer ();
-          default_tc_len = stream->length ();
-        }
-
-      // Get the TypeCode for this member.
-      //
-      // XXX we really don't care about size and alignment this time,
-      // only that we initialize the TypeCode.
-
-      CORBA::TypeCode tc (CORBA::tk_null);
-      size_t scratch;
-
-      (void) calc_nested_size_and_alignment (&tc, stream, scratch, env);
-      if (env.exception () != 0)
-        return CORBA::TypeCode::TRAVERSE_STOP;
-
-      // If we matched, visit the member and return.
-      if (discrim_matched)
-        return visit (&tc, value1, value2, context, env);
-    }
-
-  // If we get here, it means any default arm should be used.  We know
-  // at least the basic sanity checks passed; we don't repeat.
-
-  if (default_tc_ptr)
-    {
-      CDR temp_str;
-      temp_str.setup_encapsulation (default_tc_ptr,
-                                    default_tc_len);
-      // Get and use the TypeCode.
-      //
-      // XXX we really don't care about size and alignment this time,
-      // only that we initialize the TypeCode.
-
-      size_t scratch;
-      CORBA::TypeCode tc (CORBA::tk_null);
-
-      (void) calc_nested_size_and_alignment (&tc, &temp_str, scratch, env);
-      return visit (&tc, value1, value2, context, env);
-    }
-  return CORBA::TypeCode::TRAVERSE_CONTINUE;
-}
-
diff --git a/TAO/tao/IIOP_Interpreter.h b/TAO/tao/IIOP_Interpreter.h
index f802f741d0d..9c50b28d5e0 100644
--- a/TAO/tao/IIOP_Interpreter.h
+++ b/TAO/tao/IIOP_Interpreter.h
@@ -125,7 +125,7 @@ public:
   // traversal.
 
   // = Static visitor methods.
-  
+
   // These methods manipulate CDR-encapsulated TypeCode parameter
   // lists, calculating the size and alignment of the data type being
   // described.  The TCKind value has always been removed from the CDR
@@ -187,41 +187,12 @@ public:
   // may specify a multidimensional array ... such arrays are treated
   // as nested single dimensional arrays.)
 
-  static CORBA::TypeCode::traverse_status
-  struct_traverse (CDR *stream,
-                   const void *value1,
-                   const void *value2,
-                   CORBA::TypeCode::traverse_status (_FAR *visit)
-                   (CORBA::TypeCode_ptr tc,
-                    const void *value1,
-                    const void *value2,
-                    void *context,
-                    CORBA::Environment &env),
-                   void *context,
-                   CORBA::Environment &env);
-  // Visit each of the elements of a structure.
-
   static CORBA::Boolean match_value (CORBA::TCKind kind,
                                      CDR *tc_stream,
                                      const void *value,
                                      CORBA::Environment &env);
   // Cast the discriminant values to the right type and compare them.
 
-  static CORBA::TypeCode::traverse_status
-  union_traverse (CDR *stream,
-                  const void *value1,
-                  const void *value2,
-                  CORBA::TypeCode::traverse_status (_FAR *visit)
-                  (CORBA::TypeCode_ptr tc,
-                   const void *value1,
-                   const void *value2,
-                   void *context,
-                   CORBA::Environment &env),
-                  void *context,
-                  CORBA::Environment &env);
-    // Visit the two elements of the union: the discrminant, and then
-    // any specific value as indicated by the discriminant of value1.
-
   static size_t
   calc_key_union_attributes (CDR *stream,
                              size_t &overall_alignment,
diff --git a/TAO/tao/Operation_Table.cpp b/TAO/tao/Operation_Table.cpp
index 9d90e31508b..ae823840851 100644
--- a/TAO/tao/Operation_Table.cpp
+++ b/TAO/tao/Operation_Table.cpp
@@ -59,14 +59,14 @@ TAO_Dynamic_Hash_OpTable::~TAO_Dynamic_Hash_OpTable (void)
 }
 
 int
-TAO_Dynamic_Hash_OpTable::bind (const CORBA::String &opname,
+TAO_Dynamic_Hash_OpTable::bind (const char *opname,
                                 const TAO_Skeleton skel_ptr)
 {
   return this->hash_.bind (CORBA::string_dup (opname), skel_ptr);
 }
 
 int
-TAO_Dynamic_Hash_OpTable::find (const CORBA::String &opname,
+TAO_Dynamic_Hash_OpTable::find (const char *opname,
                                 TAO_Skeleton& skel_ptr)
 {
   return this->hash_.find ((const char *)opname, skel_ptr);
@@ -94,7 +94,7 @@ TAO_Linear_OpTable::~TAO_Linear_OpTable (void)
 }
 
 int
-TAO_Linear_OpTable::bind (const CORBA::String &opname,
+TAO_Linear_OpTable::bind (const char *opname,
                           const TAO_Skeleton skel_ptr)
 {
   CORBA::ULong i = this->next_;
@@ -111,7 +111,7 @@ TAO_Linear_OpTable::bind (const CORBA::String &opname,
 }
 
 int
-TAO_Linear_OpTable::find (const CORBA::String &opname,
+TAO_Linear_OpTable::find (const char *opname,
                           TAO_Skeleton& skel_ptr)
 {
   ACE_ASSERT (this->next_ <= this->tablesize_);
@@ -166,7 +166,7 @@ TAO_Active_Demux_OpTable::~TAO_Active_Demux_OpTable (void)
 }
 
 int
-TAO_Active_Demux_OpTable::bind (const CORBA::String &opname,
+TAO_Active_Demux_OpTable::bind (const char *opname,
 				const TAO_Skeleton skel_ptr)
 {
   CORBA::ULong i = ACE_OS::atoi (opname);
@@ -186,7 +186,7 @@ TAO_Active_Demux_OpTable::bind (const CORBA::String &opname,
 }
 
 int
-TAO_Active_Demux_OpTable::find (const CORBA::String &opname,
+TAO_Active_Demux_OpTable::find (const char *opname,
                                 TAO_Skeleton& skel_ptr)
 {
   CORBA::ULong i = ACE_OS::atoi (opname);
diff --git a/TAO/tao/Operation_Table.h b/TAO/tao/Operation_Table.h
index efa96614a5e..de2802a597b 100644
--- a/TAO/tao/Operation_Table.h
+++ b/TAO/tao/Operation_Table.h
@@ -4,13 +4,13 @@
 //
 // = LIBRARY
 //    TAO
-// 
+//
 // = FILENAME
 //    optable.h
 //
 // = AUTHOR
 //    Aniruddha Gokhale
-// 
+//
 // ============================================================================
 
 #if !defined (TAO_OPTABLE_H)
@@ -32,16 +32,16 @@ struct TAO_operation_db_entry
 class TAO_Export TAO_Operation_Table
   // = TITLE
   //     Abstract class for maintaining and lookup of CORBA IDL
-  //     operation names. 
+  //     operation names.
 {
 public:
-  virtual int find (const CORBA::String &opname, 
+  virtual int find (const char *opname,
 		   TAO_Skeleton &skelfunc) = 0;
   // Uses <{opname}> to look up the skeleton function and pass it back
   // in <{skelfunc}>.  Returns non-negative integer on success, or -1
   // on failure.
 
-  virtual int bind (const CORBA::String &opname,
+  virtual int bind (const char *opname,
 		    const TAO_Skeleton skel_ptr) = 0;
   // Associate the skeleton <{skel_ptr}> with an operation named
   // <{opname}>.  Returns -1 on failure, 0 on success, 1 on duplicate.
@@ -52,7 +52,7 @@ public:
 // Dynamic hashing.  We use template specialization here to use const
 // char* as the external ID. The template specialization is needed
 // since the "hash" method is not defined on type "char *".
-typedef ACE_Hash_Map_Manager<const char *, TAO_Skeleton, ACE_SYNCH_NULL_MUTEX> 
+typedef ACE_Hash_Map_Manager<const char *, TAO_Skeleton, ACE_SYNCH_NULL_MUTEX>
         OP_MAP_MANAGER;
 
 class TAO_Export TAO_Dynamic_Hash_OpTable : public TAO_Operation_Table
@@ -67,17 +67,17 @@ public:
   // Initialize the dynamic hash operation table with a database of operation
   // names. The hash table size may be different from the size of the
   // database. Hence we use the third argument to specify the size of the
-  // internal hash table. 
+  // internal hash table.
 
   ~TAO_Dynamic_Hash_OpTable (void);
   // destructor
 
-  virtual int bind (const CORBA::String &opname, 
+  virtual int bind (const char *opname,
 		    const TAO_Skeleton skel_ptr);
   // Associate the skeleton <{skel_ptr}> with an operation named
   // <{opname}>.  Returns -1 on failure, 0 on success, 1 on duplicate.
 
-  virtual int find (const CORBA::String &opname,
+  virtual int find (const char *opname,
 		    TAO_Skeleton &skelfunc);
   // Uses <{opname}> to look up the skeleton function and pass it back
   // in <{skelfunc}>.  Returns non-negative integer on success, or -1
@@ -114,18 +114,18 @@ public:
   TAO_Linear_OpTable (const TAO_operation_db_entry *db, CORBA::ULong dbsize);
   // constructor.
   // Initialize the linear search operation table with a database of operation
-  // names 
+  // names
 
   ~TAO_Linear_OpTable (void);
   // destructor
 
-  virtual int find (const CORBA::String &opname,
+  virtual int find (const char *opname,
 		    TAO_Skeleton &skel_ptr);
   // Uses <{opname}> to look up the skeleton function and pass it back
   // in <{skelfunc}>.  Returns non-negative integer on success, or -1
   // on failure.
 
-  virtual int bind (const CORBA::String &opname,
+  virtual int bind (const char *opname,
 		    const TAO_Skeleton skelptr);
   // Associate the skeleton <{skel_ptr}> with an operation named
   // <{opname}>.  Returns -1 on failure, 0 on success, 1 on duplicate.
@@ -168,13 +168,13 @@ public:
   ~TAO_Active_Demux_OpTable (void);
   // destructor
 
-  virtual int find (const CORBA::String &opname,
+  virtual int find (const char *opname,
 		    TAO_Skeleton &skel_ptr);
   // Uses <{opname}> to look up the skeleton function and pass it back
   // in <{skelfunc}>.  Returns non-negative integer on success, or -1
   // on failure.
 
-  virtual int bind (const CORBA::String &opname,
+  virtual int bind (const char *opname,
 		    const TAO_Skeleton skelptr);
   // Associate the skeleton <{skel_ptr}> with an operation named
   // <{opname}>.  Returns -1 on failure, 0 on success, 1 on duplicate.
@@ -214,14 +214,14 @@ public:
 
   DEMUX_STRATEGY lookup_strategy (void) const;
   // return the enumerated value for the lookup strategy. Default is Dynamic
-  // Hashing. 
+  // Hashing.
 
   void concrete_strategy (TAO_Operation_Table *ot);
   // Provide a data structure that will do the lookup. This is useful for
   // user-defined lookup strategies.
 
   TAO_Operation_Table *concrete_strategy (void);
-  // return the 
+  // return the
 
   TAO_Operation_Table_Parameters (void);
   // constructor
@@ -237,7 +237,7 @@ private:
 };
 
 // Define a singleton instance of operation table parameters.
-typedef ACE_Singleton<TAO_Operation_Table_Parameters, ACE_SYNCH_RECURSIVE_MUTEX> 
+typedef ACE_Singleton<TAO_Operation_Table_Parameters, ACE_SYNCH_RECURSIVE_MUTEX>
         TAO_OP_TABLE_PARAMETERS;
 
 class TAO_Export TAO_Operation_Table_Factory
@@ -257,7 +257,7 @@ public:
 };
 
 // Define a singleton instance of the operation table factory.
-typedef ACE_Singleton<TAO_Operation_Table_Factory, ACE_SYNCH_RECURSIVE_MUTEX> 
+typedef ACE_Singleton<TAO_Operation_Table_Factory, ACE_SYNCH_RECURSIVE_MUTEX>
         TAO_OP_TABLE_FACTORY;
 
 #endif /* TAO_OPTABLE_H */
diff --git a/TAO/tao/POA.cpp b/TAO/tao/POA.cpp
index 73e85967b36..30bd361cd76 100644
--- a/TAO/tao/POA.cpp
+++ b/TAO/tao/POA.cpp
@@ -2476,7 +2476,7 @@ TAO_POA::dispatch_servant_i (const TAO_ObjectKey &key,
   PortableServer::ObjectId_out id_out (id);
   TAO_POA *poa = 0;
   // const char *operation = req.operation ();
-  const char *operation = req.op_name ();
+  const char *operation = req.operation ();
 
   // Setup for POA Current
   TAO_ORB_Core *orb_core = TAO_ORB_Core_instance ();
@@ -2498,7 +2498,7 @@ TAO_POA::dispatch_servant_i (const TAO_ObjectKey &key,
 		   servant,
                    &current_context,
                    env);
-  
+
   // Upcall
   servant->_dispatch (req,
                       context,
@@ -2509,7 +2509,7 @@ TAO_POA::dispatch_servant_i (const TAO_ObjectKey &key,
                     operation,
                     &current_context,
                     env);
-  
+
   // Reset old context
   orb_core->poa_current (previous_context);
 
diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp
index 9d389a545df..b6d397deaf4 100644
--- a/TAO/tao/POAS.cpp
+++ b/TAO/tao/POAS.cpp
@@ -1,5 +1,5 @@
 // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
-// TAO ORB and the TAO IDL Compiler have been developed by Washington 
+// TAO ORB and the TAO IDL Compiler have been developed by Washington
 // University Computer Science's Distributed Object Computing Group.
 //
 // Information on TAO is available at
@@ -23,30 +23,38 @@ POA_PortableServer::CurrentBase::CurrentBase (void)
   this->optable_ = &tao_PortableServer_CurrentBase_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_CurrentBase_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_CurrentBase_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_CurrentBase_is_a_paramdata};
 void POA_PortableServer::CurrentBase::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::CurrentBase_ptr 	 impl = (POA_PortableServer::CurrentBase_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::CurrentBase_ptr  _tao_impl = (POA_PortableServer::CurrentBase_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_CurrentBase_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_CurrentBase_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::CurrentBase::_is_a (
@@ -76,7 +84,7 @@ void* POA_PortableServer::CurrentBase::_downcast (
 void POA_PortableServer::CurrentBase::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -141,63 +149,103 @@ POA_PortableServer::Policy::Policy (void)
   this->optable_ = &tao_PortableServer_Policy_optable;
 }
 
-void POA_PortableServer::Policy::copy_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void *context, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel PortableServer_Policy_copy_paramdata [] =
+{
+  {PortableServer::_tc_Policy, 0, 0}
+}; // PortableServer_Policy_copy_paramdata
+
+static const TAO_Call_Data_Skel PortableServer_Policy_copy_calldata =
+{"copy", 1, 1, PortableServer_Policy_copy_paramdata};
+
+void POA_PortableServer::Policy::copy_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  ACE_UNUSED_ARG (context);
-  CORBA::NVList_ptr 	 nvlist;
-  POA_PortableServer::Policy_ptr 	 impl = (POA_PortableServer::Policy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  CORBA::Object_ptr *retval = new CORBA::Object_ptr;
-  *retval = CORBA::Object::_nil ();
-    // create an NV list and populate it with typecodes
-  _tao_server_request.orb ()->create_list (0, nvlist); // initialize a list
-  // parse the arguments
-  _tao_server_request.params (nvlist, _tao_environment);
+  POA_PortableServer::Policy *_tao_impl = (POA_PortableServer::Policy *)_tao_object_reference;
+  CORBA::Object_ptr _tao_retval = CORBA::Object::_nil ();
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Policy_copy_calldata,
+    &_tao_retval
+  );
   if (_tao_environment.exception ()) return;
-  *retval = impl->copy(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_Policy, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
-  
+  _tao_retval = _tao_impl->copy (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Policy_copy_calldata,
+    &_tao_retval
+  );
 }
 
-void POA_PortableServer::Policy::destroy_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void *context, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel PortableServer_Policy_destroy_paramdata [] =
+{
+  {CORBA::_tc_void, 0, 0}
+}; // PortableServer_Policy_destroy_paramdata
+
+static const TAO_Call_Data_Skel PortableServer_Policy_destroy_calldata =
+{"destroy", 1, 1, PortableServer_Policy_destroy_paramdata};
+
+void POA_PortableServer::Policy::destroy_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  ACE_UNUSED_ARG (context);
-  CORBA::NVList_ptr 	 nvlist;
-  POA_PortableServer::Policy_ptr 	 impl = (POA_PortableServer::Policy_ptr) _tao_object_reference;
-    // create an NV list and populate it with typecodes
-  _tao_server_request.orb ()->create_list (0, nvlist); // initialize a list
-  // parse the arguments
-  _tao_server_request.params (nvlist, _tao_environment);
+  POA_PortableServer::Policy *_tao_impl = (POA_PortableServer::Policy *)_tao_object_reference;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Policy_destroy_calldata,
+    0
+  );
   if (_tao_environment.exception ()) return;
-  impl->destroy(_tao_environment);
-  
+  _tao_impl->destroy (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Policy_destroy_calldata,
+    0
+  );
 }
 
+static const TAO_Param_Data_Skel PortableServer_Policy_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_Policy_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_Policy_is_a_paramdata};
 void POA_PortableServer::Policy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::Policy_ptr 	 impl = (POA_PortableServer::Policy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::Policy_ptr  _tao_impl = (POA_PortableServer::Policy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Policy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Policy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::Policy::_is_a (
@@ -227,7 +275,7 @@ void* POA_PortableServer::Policy::_downcast (
 void POA_PortableServer::Policy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -311,41 +359,71 @@ POA_PortableServer::ThreadPolicy::ThreadPolicy (void)
   this->optable_ = &tao_PortableServer_ThreadPolicy_optable;
 }
 
-void POA_PortableServer::ThreadPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_ThreadPolicy_value_paramdata [] =
+{
+  {PortableServer::_tc_ThreadPolicyValue, 0, 0}
+}; // PortableServer_ThreadPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_ThreadPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_ThreadPolicy_value_paramdata};
+
+void POA_PortableServer::ThreadPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  POA_PortableServer::ThreadPolicy_ptr impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::ThreadPolicyValue *retval = new PortableServer::ThreadPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_ThreadPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *)_tao_object_reference;
+  PortableServer::ThreadPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_ThreadPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_ThreadPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::ThreadPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::ThreadPolicy_ptr  _tao_impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ThreadPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ThreadPolicy_ptr 	 impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ThreadPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ThreadPolicy::_is_a (
@@ -378,7 +456,7 @@ void* POA_PortableServer::ThreadPolicy::_downcast (
 void POA_PortableServer::ThreadPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -471,41 +549,71 @@ POA_PortableServer::LifespanPolicy::LifespanPolicy (void)
   this->optable_ = &tao_PortableServer_LifespanPolicy_optable;
 }
 
-void POA_PortableServer::LifespanPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_LifespanPolicy_value_paramdata [] =
+{
+  {PortableServer::_tc_LifespanPolicyValue, 0, 0}
+}; // PortableServer_LifespanPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_LifespanPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_LifespanPolicy_value_paramdata};
+
+void POA_PortableServer::LifespanPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  POA_PortableServer::LifespanPolicy_ptr impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::LifespanPolicyValue *retval = new PortableServer::LifespanPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_LifespanPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *)_tao_object_reference;
+  PortableServer::LifespanPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_LifespanPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_LifespanPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::LifespanPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::LifespanPolicy_ptr 	 impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::LifespanPolicy_ptr  _tao_impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_LifespanPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_LifespanPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::LifespanPolicy::_is_a (
@@ -538,7 +646,7 @@ void* POA_PortableServer::LifespanPolicy::_downcast (
 void POA_PortableServer::LifespanPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -630,41 +738,71 @@ POA_PortableServer::IdUniquenessPolicy::IdUniquenessPolicy (void)
   this->optable_ = &tao_PortableServer_IdUniquenessPolicy_optable;
 }
 
-void POA_PortableServer::IdUniquenessPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_IdUniquenessPolicy_value_paramdata [] =
 {
-  POA_PortableServer::IdUniquenessPolicy_ptr impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::IdUniquenessPolicyValue *retval = new PortableServer::IdUniquenessPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_IdUniquenessPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  {PortableServer::_tc_IdUniquenessPolicyValue, 0, 0}
+}; // PortableServer_IdUniquenessPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_IdUniquenessPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_IdUniquenessPolicy_value_paramdata};
+
+void POA_PortableServer::IdUniquenessPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
+{
+  POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *)_tao_object_reference;
+  PortableServer::IdUniquenessPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_IdUniquenessPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_IdUniquenessPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::IdUniquenessPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::IdUniquenessPolicy_ptr 	 impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::IdUniquenessPolicy_ptr  _tao_impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_IdUniquenessPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_IdUniquenessPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::IdUniquenessPolicy::_is_a (
@@ -697,7 +835,7 @@ void* POA_PortableServer::IdUniquenessPolicy::_downcast (
 void POA_PortableServer::IdUniquenessPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -789,41 +927,71 @@ POA_PortableServer::IdAssignmentPolicy::IdAssignmentPolicy (void)
   this->optable_ = &tao_PortableServer_IdAssignmentPolicy_optable;
 }
 
-void POA_PortableServer::IdAssignmentPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_IdAssignmentPolicy_value_paramdata [] =
+{
+  {PortableServer::_tc_IdAssignmentPolicyValue, 0, 0}
+}; // PortableServer_IdAssignmentPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_IdAssignmentPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_IdAssignmentPolicy_value_paramdata};
+
+void POA_PortableServer::IdAssignmentPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  POA_PortableServer::IdAssignmentPolicy_ptr impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::IdAssignmentPolicyValue *retval = new PortableServer::IdAssignmentPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_IdAssignmentPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *)_tao_object_reference;
+  PortableServer::IdAssignmentPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_IdAssignmentPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_IdAssignmentPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::IdAssignmentPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::IdAssignmentPolicy_ptr  _tao_impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_IdAssignmentPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::IdAssignmentPolicy_ptr 	 impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_IdAssignmentPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::IdAssignmentPolicy::_is_a (
@@ -856,7 +1024,7 @@ void* POA_PortableServer::IdAssignmentPolicy::_downcast (
 void POA_PortableServer::IdAssignmentPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -948,41 +1116,71 @@ POA_PortableServer::ImplicitActivationPolicy::ImplicitActivationPolicy (void)
   this->optable_ = &tao_PortableServer_ImplicitActivationPolicy_optable;
 }
 
-void POA_PortableServer::ImplicitActivationPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_ImplicitActivationPolicy_value_paramdata [] =
+{
+  {PortableServer::_tc_ImplicitActivationPolicyValue, 0, 0}
+}; // PortableServer_ImplicitActivationPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_ImplicitActivationPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_ImplicitActivationPolicy_value_paramdata};
+
+void POA_PortableServer::ImplicitActivationPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  POA_PortableServer::ImplicitActivationPolicy_ptr impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::ImplicitActivationPolicyValue *retval = new PortableServer::ImplicitActivationPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_ImplicitActivationPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *)_tao_object_reference;
+  PortableServer::ImplicitActivationPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_ImplicitActivationPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_ImplicitActivationPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::ImplicitActivationPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ImplicitActivationPolicy_ptr 	 impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::ImplicitActivationPolicy_ptr  _tao_impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ImplicitActivationPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ImplicitActivationPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ImplicitActivationPolicy::_is_a (
@@ -1015,7 +1213,7 @@ void* POA_PortableServer::ImplicitActivationPolicy::_downcast (
 void POA_PortableServer::ImplicitActivationPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1107,41 +1305,71 @@ POA_PortableServer::ServantRetentionPolicy::ServantRetentionPolicy (void)
   this->optable_ = &tao_PortableServer_ServantRetentionPolicy_optable;
 }
 
-void POA_PortableServer::ServantRetentionPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_ServantRetentionPolicy_value_paramdata [] =
 {
-  POA_PortableServer::ServantRetentionPolicy_ptr impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::ServantRetentionPolicyValue *retval = new PortableServer::ServantRetentionPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_ServantRetentionPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  {PortableServer::_tc_ServantRetentionPolicyValue, 0, 0}
+}; // PortableServer_ServantRetentionPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_ServantRetentionPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_ServantRetentionPolicy_value_paramdata};
+
+void POA_PortableServer::ServantRetentionPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
+{
+  POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *)_tao_object_reference;
+  PortableServer::ServantRetentionPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_ServantRetentionPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_ServantRetentionPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::ServantRetentionPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ServantRetentionPolicy_ptr 	 impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::ServantRetentionPolicy_ptr  _tao_impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ServantRetentionPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ServantRetentionPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ServantRetentionPolicy::_is_a (
@@ -1174,7 +1402,7 @@ void* POA_PortableServer::ServantRetentionPolicy::_downcast (
 void POA_PortableServer::ServantRetentionPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1266,41 +1494,71 @@ POA_PortableServer::RequestProcessingPolicy::RequestProcessingPolicy (void)
   this->optable_ = &tao_PortableServer_RequestProcessingPolicy_optable;
 }
 
-void POA_PortableServer::RequestProcessingPolicy::_get_value_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void * /*context*/, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel _get_PortableServer_RequestProcessingPolicy_value_paramdata [] =
+{
+  {PortableServer::_tc_RequestProcessingPolicyValue, 0, 0}
+}; // PortableServer_RequestProcessingPolicy_value_paramdata
+
+static const TAO_Call_Data_Skel _get_PortableServer_RequestProcessingPolicy_value_calldata =
+{"_get_value", 1, 1, _get_PortableServer_RequestProcessingPolicy_value_paramdata};
+
+void POA_PortableServer::RequestProcessingPolicy::_get_value_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  POA_PortableServer::RequestProcessingPolicy_ptr impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::RequestProcessingPolicyValue *retval = new PortableServer::RequestProcessingPolicyValue;
-    // this method has no incoming parameters. Nothing to parse
-  *retval = impl->value(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_RequestProcessingPolicyValue, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
+  POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *)_tao_object_reference;
+  PortableServer::RequestProcessingPolicyValue _tao_retval;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &_get_PortableServer_RequestProcessingPolicy_value_calldata,
+    &_tao_retval
+  );
+  if (_tao_environment.exception ()) return;
+  _tao_retval = _tao_impl->value (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &_get_PortableServer_RequestProcessingPolicy_value_calldata,
+    &_tao_retval
+  );
 }
 
+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};
 void POA_PortableServer::RequestProcessingPolicy::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::RequestProcessingPolicy_ptr  _tao_impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_RequestProcessingPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::RequestProcessingPolicy_ptr 	 impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_RequestProcessingPolicy_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::RequestProcessingPolicy::_is_a (
@@ -1333,7 +1591,7 @@ void* POA_PortableServer::RequestProcessingPolicy::_downcast (
 void POA_PortableServer::RequestProcessingPolicy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1422,30 +1680,38 @@ POA_PortableServer::POAManager::POAManager (void)
   this->optable_ = &tao_PortableServer_POAManager_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_POAManager_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_POAManager_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_POAManager_is_a_paramdata};
 void POA_PortableServer::POAManager::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::POAManager_ptr  _tao_impl = (POA_PortableServer::POAManager_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_POAManager_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::POAManager_ptr 	 impl = (POA_PortableServer::POAManager_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_POAManager_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::POAManager::_is_a (
@@ -1475,7 +1741,7 @@ void* POA_PortableServer::POAManager::_downcast (
 void POA_PortableServer::POAManager::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1582,30 +1848,38 @@ POA_PortableServer::AdapterActivator::AdapterActivator (void)
   this->optable_ = &tao_PortableServer_AdapterActivator_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_AdapterActivator_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_AdapterActivator_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_AdapterActivator_is_a_paramdata};
 void POA_PortableServer::AdapterActivator::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::AdapterActivator_ptr  _tao_impl = (POA_PortableServer::AdapterActivator_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_AdapterActivator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::AdapterActivator_ptr 	 impl = (POA_PortableServer::AdapterActivator_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_AdapterActivator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::AdapterActivator::_is_a (
@@ -1635,7 +1909,7 @@ void* POA_PortableServer::AdapterActivator::_downcast (
 void POA_PortableServer::AdapterActivator::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1711,30 +1985,38 @@ POA_PortableServer::ServantManager::ServantManager (void)
   this->optable_ = &tao_PortableServer_ServantManager_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_ServantManager_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_ServantManager_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_ServantManager_is_a_paramdata};
 void POA_PortableServer::ServantManager::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::ServantManager_ptr  _tao_impl = (POA_PortableServer::ServantManager_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ServantManager_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ServantManager_ptr 	 impl = (POA_PortableServer::ServantManager_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ServantManager_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ServantManager::_is_a (
@@ -1764,7 +2046,7 @@ void* POA_PortableServer::ServantManager::_downcast (
 void POA_PortableServer::ServantManager::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1827,30 +2109,38 @@ POA_PortableServer::ServantActivator::ServantActivator (void)
   this->optable_ = &tao_PortableServer_ServantActivator_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_ServantActivator_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_ServantActivator_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_ServantActivator_is_a_paramdata};
 void POA_PortableServer::ServantActivator::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::ServantActivator_ptr  _tao_impl = (POA_PortableServer::ServantActivator_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ServantActivator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ServantActivator_ptr 	 impl = (POA_PortableServer::ServantActivator_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ServantActivator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ServantActivator::_is_a (
@@ -1883,7 +2173,7 @@ void* POA_PortableServer::ServantActivator::_downcast (
 void POA_PortableServer::ServantActivator::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -1979,30 +2269,38 @@ POA_PortableServer::ServantLocator::ServantLocator (void)
   this->optable_ = &tao_PortableServer_ServantLocator_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_ServantLocator_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_ServantLocator_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_ServantLocator_is_a_paramdata};
 void POA_PortableServer::ServantLocator::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::ServantLocator_ptr  _tao_impl = (POA_PortableServer::ServantLocator_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_ServantLocator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::ServantLocator_ptr 	 impl = (POA_PortableServer::ServantLocator_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_ServantLocator_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::ServantLocator::_is_a (
@@ -2035,7 +2333,7 @@ void* POA_PortableServer::ServantLocator::_downcast (
 void POA_PortableServer::ServantLocator::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -2135,30 +2433,38 @@ POA_PortableServer::POA::POA (void)
   this->optable_ = &tao_PortableServer_POA_optable;
 }
 
+static const TAO_Param_Data_Skel PortableServer_POA_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_POA_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_POA_is_a_paramdata};
 void POA_PortableServer::POA::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
+  POA_PortableServer::POA_ptr  _tao_impl = (POA_PortableServer::POA_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_POA_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::POA_ptr 	 impl = (POA_PortableServer::POA_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
-  if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_POA_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::POA::_is_a (
@@ -2188,7 +2494,7 @@ void* POA_PortableServer::POA::_downcast (
 void POA_PortableServer::POA::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -2348,7 +2654,7 @@ PortableServer::RequestProcessingPolicy_ptr POA_PortableServer::_tao_collocated_
     );
 }
 
-char* 
+char*
 POA_PortableServer::_tao_collocated_POA::the_name (
     CORBA::Environment &_tao_environment
   )
@@ -2576,67 +2882,104 @@ POA_PortableServer::Current::Current (void)
   this->optable_ = &tao_PortableServer_Current_optable;
 }
 
-void POA_PortableServer::Current::get_POA_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void *context, CORBA::Environment &_tao_environment)
+static const TAO_Param_Data_Skel PortableServer_Current_get_POA_paramdata [] =
+{
+  {PortableServer::_tc_POA, 0, 0}
+}; // PortableServer_Current_get_POA_paramdata
+
+static const TAO_Call_Data_Skel PortableServer_Current_get_POA_calldata =
+{"get_POA", 1, 1, PortableServer_Current_get_POA_paramdata};
+
+void POA_PortableServer::Current::get_POA_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
 {
-  ACE_UNUSED_ARG (context);
-  CORBA::NVList_ptr 	 nvlist;
-  POA_PortableServer::Current_ptr 	 impl = (POA_PortableServer::Current_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  CORBA::Object_ptr *retval = new CORBA::Object_ptr;
-  *retval = CORBA::Object::_nil ();
-    // create an NV list and populate it with typecodes
-  _tao_server_request.orb ()->create_list (0, nvlist); // initialize a list
-  // parse the arguments
-  _tao_server_request.params (nvlist, _tao_environment);
+  POA_PortableServer::Current *_tao_impl = (POA_PortableServer::Current *)_tao_object_reference;
+  CORBA::Object_ptr _tao_retval = CORBA::Object::_nil ();
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Current_get_POA_calldata,
+    &_tao_retval
+  );
   if (_tao_environment.exception ()) return;
-  *retval = impl->get_POA(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_POA, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
-  
-}
-
-void POA_PortableServer::Current::get_object_id_skel (CORBA::ServerRequest &_tao_server_request, void *_tao_object_reference, void *context, CORBA::Environment &_tao_environment)
-{
-  ACE_UNUSED_ARG (context);
-  CORBA::NVList_ptr 	 nvlist;
-  POA_PortableServer::Current_ptr 	 impl = (POA_PortableServer::Current_ptr) _tao_object_reference;
-  CORBA::Any *result;
-  PortableServer::ObjectId *retval;
-    // create an NV list and populate it with typecodes
-  _tao_server_request.orb ()->create_list (0, nvlist); // initialize a list
-  // parse the arguments
-  _tao_server_request.params (nvlist, _tao_environment);
+  _tao_retval = _tao_impl->get_POA (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Current_get_POA_calldata,
+    &_tao_retval
+  );
+}
+
+static const TAO_Param_Data_Skel PortableServer_Current_get_object_id_paramdata [] =
+{
+  {PortableServer::_tc_ObjectId, 0, 0}
+}; // PortableServer_Current_get_object_id_paramdata
+
+static const TAO_Call_Data_Skel PortableServer_Current_get_object_id_calldata =
+{"get_object_id", 1, 1, PortableServer_Current_get_object_id_paramdata};
+
+void POA_PortableServer::Current::get_object_id_skel (
+    CORBA::ServerRequest &_tao_server_request,
+    void *_tao_object_reference,
+    void * /* context */,
+    CORBA::Environment &_tao_environment
+)
+{
+  POA_PortableServer::Current *_tao_impl = (POA_PortableServer::Current *)_tao_object_reference;
+  PortableServer::ObjectId *_tao_retval = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Current_get_object_id_calldata,
+    _tao_retval
+  );
   if (_tao_environment.exception ()) return;
-  retval = impl->get_object_id(_tao_environment);
-  result = new CORBA::Any (PortableServer::_tc_ObjectId, retval, 1); // ORB owns
-  _tao_server_request.result (result, _tao_environment);
-  
+  _tao_retval = _tao_impl->get_object_id (
+    _tao_environment
+  );
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Current_get_object_id_calldata,
+    _tao_retval
+  );
 }
 
+static const TAO_Param_Data_Skel PortableServer_Current_is_a_paramdata [] =
+{
+  {CORBA::_tc_boolean, 0, 0},
+  {CORBA::_tc_string, CORBA::ARG_IN, 0}
+};
+static const TAO_Call_Data_Skel PortableServer_Current_is_a_calldata =
+{"_is_a", 1, 2, PortableServer_Current_is_a_paramdata};
 void POA_PortableServer::Current::_is_a_skel (
-    CORBA::ServerRequest &req, 
+    CORBA::ServerRequest &_tao_server_request,
     void * _tao_object_reference,
     void * /*context*/,
     CORBA::Environment &_tao_environment
   )
 {
-  CORBA::NVList_ptr nvlist;
-  CORBA::NamedValue_ptr nv;
-  CORBA::Any temp_value (CORBA::_tc_string);
-  CORBA::Any *any;
-  CORBA::Boolean *retval = new CORBA::Boolean;
-  CORBA::String value;
-  
-  req.orb()->create_list (0, nvlist);
-  nv = nvlist->add_value (0, temp_value, CORBA::ARG_IN, _tao_environment);
-  req.params (nvlist, _tao_environment); // parse the args
-  if (_tao_environment.exception () != 0) return;
-  value = *(CORBA::String *)nv->value ()->value ();
-  POA_PortableServer::Current_ptr 	 impl = (POA_PortableServer::Current_ptr) _tao_object_reference;
-  *retval = impl->_is_a (value, _tao_environment);
+  POA_PortableServer::Current_ptr  _tao_impl = (POA_PortableServer::Current_ptr) _tao_object_reference;
+  CORBA::Boolean _tao_retval;
+  char *_tao_value = 0;
+  _tao_server_request.demarshal (
+    _tao_environment,
+    &PortableServer_Current_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
   if (_tao_environment.exception () != 0) return;
-  any = new CORBA::Any (CORBA::_tc_boolean, retval, CORBA::B_TRUE);
-  req.result (any, _tao_environment);
+  _tao_retval = _tao_impl->_is_a (_tao_value, _tao_environment);
+  _tao_server_request.marshal (
+    _tao_environment,
+    &PortableServer_Current_is_a_calldata,
+    &_tao_retval,
+    &_tao_value
+  );
+  CORBA::string_free (_tao_value);
 }
 
 CORBA::Boolean POA_PortableServer::Current::_is_a (
@@ -2669,7 +3012,7 @@ void* POA_PortableServer::Current::_downcast (
 void POA_PortableServer::Current::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &env)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
-  CORBA::String opname = req.op_name (); // retrieve operation name
+  const char *opname = req.operation (); // retrieve operation name
   // find the skeleton corresponding to this opname
   if (this->_find (opname, skel) == -1)
   {
@@ -2739,4 +3082,3 @@ POA_PortableServer::Current::_this (CORBA_Environment &_env)
     return 0;
   return new POA_PortableServer::_tao_collocated_Current (this, stub);
 }
-
diff --git a/TAO/tao/Servant_Base.cpp b/TAO/tao/Servant_Base.cpp
index 5a5855d3586..a6a2cdeb36c 100644
--- a/TAO/tao/Servant_Base.cpp
+++ b/TAO/tao/Servant_Base.cpp
@@ -44,14 +44,14 @@ TAO_ServantBase::_is_a (const char* logical_type_id,
 }
 
 int
-TAO_ServantBase::_find (const CORBA::String &opname,
+TAO_ServantBase::_find (const char *opname,
                         TAO_Skeleton& skelfunc)
 {
   return optable_->find (opname, skelfunc);
 }
 
 int
-TAO_ServantBase::_bind (const CORBA::String &opname,
+TAO_ServantBase::_bind (const char *opname,
                         const TAO_Skeleton skel_ptr)
 {
   return optable_->bind (opname, skel_ptr);
@@ -64,7 +64,7 @@ TAO_ServantBase::_dispatch (CORBA::ServerRequest &req,
 {
   // @@ (ASG) - we should check here if the call was for _non_existant, else
   // issue an error. For the time being we issue an error
-  CORBA::String opname = req.op_name ();
+  const char *opname = req.operation ();
   ACE_UNUSED_ARG (context);
 
   // Something really bad happened: the operation was not
diff --git a/TAO/tao/Servant_Base.h b/TAO/tao/Servant_Base.h
index 92f47707e4f..43f5970d045 100644
--- a/TAO/tao/Servant_Base.h
+++ b/TAO/tao/Servant_Base.h
@@ -62,11 +62,11 @@ protected:
   // results and out parameters (if any) or the exceptions thrown into
   // <request>.
 
-  virtual int _find (const CORBA::String &opname,
+  virtual int _find (const char *opname,
                      TAO_Skeleton &skelfunc);
   // Find an operation in the operation table.
 
-  virtual int _bind (const CORBA::String &opname,
+  virtual int _bind (const char *opname,
                      const TAO_Skeleton skel_ptr);
   // Register a CORBA IDL operation name.
 
diff --git a/TAO/tao/Server_Request.cpp b/TAO/tao/Server_Request.cpp
index bd979cc1805..eca7c47fca1 100644
--- a/TAO/tao/Server_Request.cpp
+++ b/TAO/tao/Server_Request.cpp
@@ -12,18 +12,35 @@ DEFINE_GUID (IID_IIOP_ServerRequest,
 DEFINE_GUID (IID_CORBA_ServerRequest,
 0x4b48d881, 0xf7f0, 0x11ce, 0x95, 0x98, 0x0, 0x0, 0xc0, 0x7c, 0xa8, 0x98);
 
-IIOP_ServerRequest::IIOP_ServerRequest (CDR *req,
+CORBA_ServerRequest *
+CORBA_ServerRequest::_duplicate (CORBA_ServerRequest *req)
+{
+  if (req)
+    {
+      req->AddRef ();
+      return req;
+    }
+  return (CORBA_ServerRequest *) 0;
+}
+
+CORBA_ServerRequest *
+CORBA_ServerRequest::_nil (void)
+{
+  return (CORBA_ServerRequest *) 0;
+}
+
+IIOP_ServerRequest::IIOP_ServerRequest (const TAO_GIOP_RequestHeader &hdr,
+                                        CDR *req,
                                         CDR *resp,
-                                        CORBA::ULong reqid,
                                         CORBA::ORB_ptr the_orb,
                                         TAO_POA *the_poa)
-  : incoming_ (req),
+  : opname_ (CORBA::string_dup (hdr.operation)),
+    incoming_ (req),
     outgoing_ (resp),
-    reqid_ (reqid),
+    reqid_ (hdr.request_id),
     params_ (0),
     retval_ (0),
     exception_ (0),
-    ex_type_ (CORBA::NO_EXCEPTION),
     refcount_ (1),
     orb_ (the_orb),
     poa_ (the_poa)
@@ -32,21 +49,19 @@ IIOP_ServerRequest::IIOP_ServerRequest (CDR *req,
 
 IIOP_ServerRequest::~IIOP_ServerRequest (void)
 {
-  ACE_ASSERT (refcount_ == 0);
-
-  if (params_)
-    CORBA::release (params_);
-  if (retval_)
-    delete retval_;
-  if (exception_)
-    delete exception_;
+  if (this->params_)
+    CORBA::release (this->params_);
+  if (this->retval_)
+    delete this->retval_;
+  if (this->exception_)
+    delete this->exception_;
 }
 
 ULONG
 IIOP_ServerRequest::AddRef (void)
 {
-  ACE_ASSERT (refcount_ > 0);
-  return refcount_++;
+  ACE_ASSERT (this->refcount_ > 0);
+  return this->refcount_++;
 }
 
 ULONG
@@ -54,8 +69,8 @@ IIOP_ServerRequest::Release (void)
 {
   ACE_ASSERT (this != 0);
 
-  if (--refcount_ != 0)
-    return refcount_;
+  if (--this->refcount_ != 0)
+    return this->refcount_;
 
   delete this;
   return 0;
@@ -65,7 +80,7 @@ TAO_HRESULT
 IIOP_ServerRequest::QueryInterface (REFIID riid,
                                     void **ppv)
 {
-  ACE_ASSERT (refcount_ > 0);
+  ACE_ASSERT (this->refcount_ > 0);
   *ppv = 0;
 
   if (IID_IIOP_ServerRequest == riid
@@ -76,7 +91,7 @@ IIOP_ServerRequest::QueryInterface (REFIID riid,
   if (*ppv == 0)
     return ResultFromScode (TAO_E_NOINTERFACE);
 
- (void) AddRef ();
+ (void) this->AddRef ();
   return TAO_NOERROR;
 }
 
@@ -84,8 +99,8 @@ IIOP_ServerRequest::QueryInterface (REFIID riid,
 // inout/out/return values later on.
 
 void
-IIOP_ServerRequest::params (CORBA::NVList_ptr list,
-                            CORBA::Environment &env)
+IIOP_ServerRequest::arguments (CORBA::NVList_ptr &list,
+                               CORBA::Environment &env)
 {
   env.clear ();
 
@@ -97,6 +112,7 @@ IIOP_ServerRequest::params (CORBA::NVList_ptr list,
     {
       CORBA::NamedValue_ptr nv = list->item (i, env);
 
+      // check if it is an in or inout parameter
       if (ACE_BIT_DISABLED (nv->flags (), CORBA::ARG_IN | CORBA::ARG_INOUT))
         continue;
 
@@ -108,6 +124,8 @@ IIOP_ServerRequest::params (CORBA::NVList_ptr list,
       // environments where DSI is just being used in lieu of a
       // language mapped server-side API and the size is really
       // knowable in advance.
+      //
+      // This is exactly what the TAO IDL compiler generated skeletons do.
 
       CORBA::Any_ptr any = nv->value ();
       CORBA::TypeCode_ptr tc = any->type ();
@@ -133,7 +151,7 @@ IIOP_ServerRequest::params (CORBA::NVList_ptr list,
           tc->Release ();
         }
       else
-        value = (void *)any->value ();
+        value = (void *)any->value (); // memory was already preallocated
 
       // Then just unmarshal the value.
       (void) incoming_->decode (tc, value, 0, env);
@@ -141,7 +159,7 @@ IIOP_ServerRequest::params (CORBA::NVList_ptr list,
 
   // If any data is left over, it'd be context values ... else error.
   // We don't support context values, so it's always an error.
-
+  // @@ (TAO) support for Contexts??
   if (incoming_->bytes_remaining () != 0)
     {
       dmsg1 ("params (), %d bytes remaining (error)",
@@ -155,70 +173,32 @@ IIOP_ServerRequest::params (CORBA::NVList_ptr list,
 // only after the parameter list has been provided (maybe empty).
 
 void
-IIOP_ServerRequest::result (CORBA::Any_ptr value,
-                            CORBA::Environment &env)
+IIOP_ServerRequest::set_result (const CORBA::Any &value,
+                                CORBA::Environment &env)
 {
   env.clear ();
 
-  if (!params_ || retval_ || exception_)
+  // setting a result when another result already exists or if an exception
+  // exists is an error
+  if (!this->params_ || this->retval_ || this->exception_)
     env.exception (new CORBA::BAD_INV_ORDER (CORBA::COMPLETED_NO));
   else
-    retval_ = value;
-
-  // XXX send the message now!
+    this->retval_ = new CORBA::Any (value);
 }
 
 // Store the exception value.
 
 void
-IIOP_ServerRequest::exception (CORBA::ExceptionType type,
-                               CORBA::Any_ptr value,
-                               CORBA::Environment &env)
+IIOP_ServerRequest::set_exception (const CORBA::Any &value,
+                                   CORBA::Environment &env)
 {
-  if (!params_ || retval_ || exception_)
+  if (!this->params_ || this->retval_ || this->exception_)
     env.exception (new CORBA::BAD_INV_ORDER (CORBA::COMPLETED_NO));
   else
     {
       env.clear ();
-      exception_ = value;
-      ex_type_ = type;
+      this->exception_ = new CORBA::Any (value);
     }
-
-  // XXX send the message now!
-}
-
-// Invocation attributes.
-
-CORBA::String
-IIOP_ServerRequest::op_name (void)
-{
-  return opname_;
-}
-
-CORBA::Object_ptr
-IIOP_ServerRequest::target (void)
-{
-  // XXX implement me!!  Code from TCP_OA exists ...
-  return 0;
-}
-
-CORBA::Principal_ptr
-IIOP_ServerRequest::caller (void)
-{
-  // XXX ... return client's principal
-  return 0;
-}
-
-CORBA::ORB_ptr
-IIOP_ServerRequest::orb (void)
-{
-  return orb_;
-}
-
-TAO_POA *
-IIOP_ServerRequest::oa (void)
-{
-  return poa_;
 }
 
 // Extension
@@ -265,7 +245,7 @@ IIOP_ServerRequest::demarshal (CORBA::Environment &env,  // exception reporting
   va_end (param_vector);
 
   // Now demarshal the parameters using a call to params.
-  this->params (nvlist, env); // nvlist is now owned by us
+  this->arguments (nvlist, env); // nvlist is now owned by us
 }
 
 // Extension
@@ -377,11 +357,12 @@ IIOP_ServerRequest::init_reply (CORBA::Environment &env)
 
       // Finish the GIOP Reply header, then marshal the exception.
       // XXX x->type () someday ...
-      if (this->ex_type_ == CORBA::SYSTEM_EXCEPTION)
+
+      //      if (this->ex_type_ == CORBA::SYSTEM_EXCEPTION)
+      if (1)
         this->outgoing_->put_ulong (TAO_GIOP_SYSTEM_EXCEPTION);
       else
         this->outgoing_->put_ulong (TAO_GIOP_USER_EXCEPTION);
-
       (void) this->outgoing_->encode (except_tc, x, 0, env);
     }
   else // Normal reply
diff --git a/TAO/tao/Server_Request.h b/TAO/tao/Server_Request.h
index 28d9187f504..b8ee5c6a215 100644
--- a/TAO/tao/Server_Request.h
+++ b/TAO/tao/Server_Request.h
@@ -15,13 +15,14 @@
 //
 // = AUTHOR
 //     Copyright 1994-1995 by Sun Microsystems, Inc. and Chris Cleeland.
-//
+//     Modifications by Aniruddha Gokhale based on CORBAv2.2 Feb 98
 // ============================================================================
 
 #if !defined (TAO_SERVER_REQUEST_H)
 #define TAO_SERVER_REQUEST_H
 
 class TAO_POA;
+class TAO_GIOP_RequestHeader;
 
 class TAO_Param_Data_Skel
 {
@@ -98,23 +99,28 @@ class TAO_Export CORBA_ServerRequest : public TAO_IUnknown
   //   This is not supposed to be IIOP-specific, or to expose quite so
   //   many implementation details, but right now does.
 public:
-  virtual void params (CORBA::NVList_ptr list,
-                       CORBA::Environment &env) = 0;
+  static CORBA_ServerRequest *_duplicate (CORBA_ServerRequest *req);
+  // the duplicate method for Pseudo Objects
+
+  static CORBA_ServerRequest *_nil (void);
+  // the standard _nil method on pseudo objects
+
+  virtual void arguments (CORBA::NVList_ptr &list,
+                          CORBA::Environment &env) = 0;
   // Implementation uses this to provide the ORB with the operation's
   // parameter list ... on return, their values are available; the
   // list fed in has typecodes and (perhap) memory assigned.
 
-  virtual void result (CORBA::Any_ptr value,
-                       CORBA::Environment &env) = 0;
+  virtual void set_result (const CORBA::Any &value,
+                           CORBA::Environment &env) = 0;
   // Implementation uses this to provide the operation result
   // ... illegal if exception() was called or params() was not called.
   //
   // XXX Implementation should be able to assume response has been
   // sent when this returns, and reclaim memory it allocated.
 
-  virtual void exception (CORBA::ExceptionType	type,
-                          CORBA::Any_ptr value,
-                          CORBA::Environment &env) = 0;
+  virtual void set_exception (const CORBA::Any &value,
+                              CORBA::Environment &env) = 0;
   // Implementation uses this to provide the exception value which is
   // the only result of this particular invocation.
   //
@@ -129,19 +135,31 @@ public:
   // NOTE: none of these report exceptions; unavailability of any of
   // this stuff is a catastrophic error since this is all part of the
   // basic CORBA Object Model.
-  virtual CORBA::Principal_ptr caller (void) = 0;
-  virtual CORBA::Object_ptr target (void) = 0;
-  virtual CORBA::String op_name (void) = 0;
+
+  virtual const char *operation (void) const = 0;
+  // get the operation name
+
+  //  CORBA::Context_ptr ctx (void) = 0;
+  // return the context pointer
+
+  // = Extensions.
+
   virtual TAO_POA *oa (void) = 0;
+  // get the Object Adapter
+
   virtual CORBA::ORB_ptr  orb (void) = 0;
+  // get the underlying ORB
 
-  // Extensions.
   virtual void demarshal (CORBA::Environment &env,
                           const TAO_Call_Data_Skel *info,
                           ...) = 0;
+  // demarshal incoming parameters
+
   virtual void marshal (CORBA::Environment &env,
                         const TAO_Call_Data_Skel *info,
                         ...) = 0;
+  // marshal outgoing parameters
+
   virtual void init_reply (CORBA::Environment &env) = 0;
   // Start a Reply message.
 
@@ -158,9 +176,9 @@ class TAO_Export IIOP_ServerRequest : public CORBA_ServerRequest
   //    Class representing an IIOP ServerRequest object.
 public:
   // = Initialization and termination methods.
-  IIOP_ServerRequest (CDR *req,
+  IIOP_ServerRequest (const TAO_GIOP_RequestHeader &hdr,
+                      CDR *req,
                       CDR *resp,
-                      CORBA::ULong reqid,
 		      CORBA::ORB_ptr the_orb,
 		      TAO_POA *the_poa);
   // Constructor
@@ -169,37 +187,41 @@ public:
   // Destructor.
 
   // = General ServerRequest operations
-  void params (CORBA::NVList_ptr list,
-               CORBA::Environment &env);
+  void arguments (CORBA::NVList_ptr &list,
+                  CORBA::Environment &env);
 
-  void result (CORBA::Any_ptr value,
-               CORBA::Environment &env);
+  void set_result (const CORBA::Any &value,
+                   CORBA::Environment &env);
 
-  void exception (CORBA::ExceptionType type,
-                  CORBA::Any_ptr value,
-                  CORBA::Environment &env);
+  void set_exception (const CORBA::Any &value,
+                      CORBA::Environment &env);
 
   // = Request attributes.
 
-  CORBA::String  op_name (void);
-  CORBA::Principal_ptr 	caller (void);
-  CORBA::Object_ptr  target (void);
+  const char *operation (void) const;
+  // return the operation name
+
+  //  CORBA::Context_ptr ctx (void);
+  // return the context pointer
+
+  // = TAO extensions
+
   CORBA::ORB_ptr  orb (void);
-  TAO_POA *oa (void);
+  // return the underlying ORB
 
-  // = Stuff required for memory management.
-  ULONG  AddRef (void);
-  ULONG  Release (void);
-  TAO_HRESULT  QueryInterface (REFIID riid,
-                               void **ppv);
+  TAO_POA *oa (void);
+  // retturn the Object Adapter
 
-  // @@ Please document me.
   virtual void demarshal (CORBA::Environment &env,
                           const TAO_Call_Data_Skel *info,
                           ...);
+  // demarshal incoming parameters
+
   virtual void marshal (CORBA::Environment &env,
                         const TAO_Call_Data_Skel *info,
                         ...);
+  // marshal outgoing parameters and return value
+
   virtual void init_reply (CORBA::Environment &env);
   // start a Reply message
 
@@ -209,36 +231,34 @@ public:
   virtual CDR &outgoing (void);
   // Retrieve the outgoing stream.
 
-  // private:
-  CORBA::String opname_;        
+  // = Stuff required for memory management and COM
+  ULONG  AddRef (void);
+  ULONG  Release (void);
+  TAO_HRESULT  QueryInterface (REFIID riid,
+                               void **ppv);
+
+private:
+  CORBA::String_var opname_;
   // Operation name.
 
-  CDR *incoming_;               
+  CDR *incoming_;
   // Incoming stream.
 
-  CDR *outgoing_;               
+  CDR *outgoing_;
   // Outgoing stream.
 
-  CORBA::ULong reqid_;          
+  CORBA::ULong reqid_;
   // request ID
 
-  CORBA::NVList_ptr params_;    
+  CORBA::NVList_ptr params_;
   // Incoming parameters.
 
-  CORBA::Any_ptr retval_;       
+  CORBA::Any_ptr retval_;
   // Return value.
 
-  CORBA::Any_ptr exception_;    
+  CORBA::Any_ptr exception_;
   // Any exception which might be raised.
 
-  CORBA::ExceptionType ex_type_; 
-  // The type of <exception_>.
-
-  void release (void);
-  // Just drop the refcount, don't destroy the object; most of these
-  // are stack-allocated.
-
-private:
   u_int refcount_;
   // Number of things hold references to here.
 
diff --git a/TAO/tao/Server_Request.i b/TAO/tao/Server_Request.i
index ac811cc9fcd..f22035730fe 100644
--- a/TAO/tao/Server_Request.i
+++ b/TAO/tao/Server_Request.i
@@ -1,3 +1,10 @@
+ACE_INLINE void
+CORBA::release (CORBA_ServerRequest *req)
+{
+   if (req)
+     req->Release ();
+}
+
 ACE_INLINE CDR &
 IIOP_ServerRequest::incoming (void)
 {
@@ -10,8 +17,30 @@ IIOP_ServerRequest::outgoing (void)
   return *this->outgoing_;
 }
 
-ACE_INLINE void 
-IIOP_ServerRequest::release (void) 
-{ 
-  refcount_--; 
+// Invocation attributes.
+ACE_INLINE const char *
+IIOP_ServerRequest::operation (void) const
+{
+  return this->opname_;
+}
+
+#if 0
+//@@ (TAO) to do after Context is implemented
+ACE_INLINE CORBA::Context_ptr
+IIOP_ServerRequest::ctx (void)
+{
+  return 0;
+}
+#endif
+
+ACE_INLINE CORBA::ORB_ptr
+IIOP_ServerRequest::orb (void)
+{
+  return orb_;
+}
+
+ACE_INLINE TAO_POA *
+IIOP_ServerRequest::oa (void)
+{
+  return poa_;
 }
diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp
index 7c12a38ecfd..cbe2f0c1c2a 100644
--- a/TAO/tao/Typecode.cpp
+++ b/TAO/tao/Typecode.cpp
@@ -2253,198 +2253,6 @@ CORBA_TypeCode::typecode_param (CORBA::ULong n,
   return 0;
 }
 
-// For each node in "data", visit it.  For singleton nodes that's all
-// but a NOP; for structs, unions, etc it's more interesting.  The
-// visit routine can descend, if it chooses.
-//
-// NOTE: this does no memory allocation or deallocation except through
-// use of the stack.  Or at least, it should do none -- if you find
-// that just traversing a data value allocates any memory, that's a
-// bug to fix!
-
-CORBA::TypeCode::traverse_status
-CORBA::TypeCode::traverse (const void *value1,
-                           const void *value2,
-                           CORBA::TypeCode::traverse_status (_FAR *visit)
-                           (CORBA::TypeCode_ptr tc,
-                            const void *value1,
-                            const void *value2,
-                            void *context,
-                            CORBA::Environment &env),
-                           void *context,
-                           CORBA::Environment &env)
-{
-  env.clear ();
-
-  // Quickly accomodate the bulk of cases, which are just (tail) calls
-  // to the visit() routine.  We take advantage of the fact that these
-  // are largely in a convenient numeric range to work around poor
-  // optimization of "switch" code in some compilers.  This
-  // improvement has in some cases been more than 5% faster
-  // (significant).
-  //
-  // NOTE: if for some reason the constants in the protocol spec
-  // (including Appendix A) change, this logic may need to be verified
-  // again.  Luckily, changing protocol constants is quite rare; they
-  // normally just get added to (at the end).
-  //
-  if (kind_ <= CORBA::tk_objref
-      || (CORBA::tk_longlong <= kind_ && kind_ <= CORBA::tk_wstring))
-    return visit (this, value1, value2, context, env);
-
-  // Handle the cases that aren't in convenient numeric ranges.
-
-  traverse_status retval;
-
-  switch (kind_)
-    {
-    case CORBA::tk_string:
-    case CORBA::tk_enum:
-      return visit (this, value1, value2, context, env);
-
-      // Typedefs just add a delay, while we skip the typedef ID
-      // and name ...
-
-    case CORBA::tk_alias:
-      {
-        CORBA::TypeCode_ptr tcp;
-        CORBA::Environment env2;
-
-        // XXX rework for efficiency, this doesn't need to allocate
-        // memory during the traversal!
-
-        tcp = typecode_param (2, env);
-        if (env.exception () != 0)
-          return TRAVERSE_STOP;
-
-        retval = tcp->traverse (value1, value2, visit, context, env);
-
-        tcp->Release ();
-      }
-    return retval;
-
-    // Exceptions in-memory are structures, except that there are data
-    // members "hidden" in front: vtable, typecode, refcount.  We skip
-    // them, and allow the traversal code to account for the internal
-    // padding before the other elements of the exception.
-    //
-    // NOTE: see header comment re treatment of these values as "real"
-    // C++ exceptions.  C++ RTTI data might need to be skipped.  Also,
-    // see the comments in unmarshaling code: hard to throw these
-    // values.
-    //
-    // Not enough of the exception runtime is public for binary
-    // standards to exist for C++ exceptions yet.  Compiler-specific
-    // code will need to handle examining, unmarshaling, and throwing
-    // of CORBA exceptions (in C++ environments) for some time.
-    case CORBA::tk_except:
-      value1 = sizeof (CORBA::Exception) + (char *) value1;
-      value2 = sizeof (CORBA::Exception) + (char *) value2;
-      // FALLTHROUGH
-
-    case CORBA::tk_struct:
-      // XXX for OLE Automation, we'll probably need BOTH exceptions
-      // and structs to inherit IUnknown, hence we'll need to be
-      // skipping the vtable pointer ...
-      {
-        // Create the sub-encapsulation stream that holds the
-        // parameters for the typecode.
-
-        CDR stream;
-
-        stream.setup_encapsulation (buffer_, (size_t) length_);
-
-        return TAO_IIOP_Interpreter::struct_traverse (&stream,
-                                                      value1,
-                                                      value2,
-                                                      visit,
-                                                      context,
-                                                      env);
-      }
-    case CORBA::tk_union:
-      {
-        // visit the discriminant, then search the typecode for the
-        // relevant union member and then visit that member.
-        CDR stream;
-
-        stream.setup_encapsulation (buffer_, (size_t) length_);
-
-        return TAO_IIOP_Interpreter::union_traverse (&stream,
-                                                     value1,
-                                                     value2,
-                                                     visit,
-                                                     context,
-                                                     env);
-      }
-      // Sequences are just arrays with bound determined at runtime,
-      // rather than compile time.  Multidimensional arrays are nested
-      // C-style: the leftmost dimension in the IDL definition is
-      // "outermost", etc.
-      {
-        CORBA::TypeCode_ptr tc2;
-        size_t size;
-        CORBA::ULong bounds;
-        CORBA::OctetSeq *seq;
-
-      case CORBA::tk_sequence:
-        // Find out how many elements there are, and adjust the data
-        // pointers to point to those elements rather than to the
-        // sequence itself.
-        seq = (CORBA::OctetSeq *)value1;
-
-        bounds = seq->length;
-        value1 = seq->buffer;
-
-        if (value2)
-          {
-            seq = (CORBA::OctetSeq *)value2;
-            value2 = seq->buffer;
-          }
-        goto shared_seq_array_code;
-
-      case CORBA::tk_array:
-        // Array bounds are in the typecode itself.
-        bounds = ulong_param (1, env);
-        if (env.exception () != 0)
-          return TRAVERSE_STOP;
-
-      shared_seq_array_code:
-        // Find element's type, and size ...
-        tc2 = typecode_param (0, env);
-        if (env.exception () != 0)
-          return TRAVERSE_STOP;
-
-        size = tc2->size (env);
-        if (env.exception () != 0)
-          return TRAVERSE_STOP;
-
-        // ... then visit the elements in order.
-        //
-        // NOTE: for last element, could turn visit() call into
-        // something subject to compiler's tail call optimization and
-        // thus save a stack frame
-        while (bounds--)
-          {
-            if (visit (tc2, value1, value2, context, env) == TRAVERSE_STOP)
-              return TRAVERSE_STOP;
-
-            value1 = size + (char *) value1;
-            value2 = size + (char *) value2;
-          }
-        CORBA::release (tc2);
-        env.clear ();
-      }
-      return TRAVERSE_CONTINUE;
-
-      // case ~0:                       // indirection, illegal at top level
-    default:                            // invalid/illegal
-      break;
-    } // end switch on typecode "kind"
-
-  env.exception (new CORBA::BAD_TYPECODE (CORBA::COMPLETED_NO));
-  return TRAVERSE_STOP;
-}
-
 // Tell user the size of an instance of the data type described by
 // this typecode ... typically used to allocate memory.
 
diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h
index 8959c516ee6..48d5ac0b07a 100644
--- a/TAO/tao/Typecode.h
+++ b/TAO/tao/Typecode.h
@@ -179,45 +179,6 @@ public:
   };
   // these are used to indicate the status of marshaling
 
-  // = The following traverse function is unused in TAO.
-  typedef traverse_status (_FAR * VisitRoutine) (CORBA::TypeCode_ptr tc,
-                                                 const void *value1,
-                                                 const void *value2,
-                                                 void *context,
-                                                 CORBA::Environment &env);
-
-  traverse_status traverse (const void *value1,
-                            const void *value2,
-                            VisitRoutine visit,
-                            void *context,
-                            CORBA::Environment &env);
-  // This routine calls visit () on each component of one (or two)
-  // structurally equivalent data values.  "Components" are either
-  // primitive (long, string, ...) or constructed (struct, ...)  data
-  // elements.
-  //
-  // It will NOT descend into those nodes if they're constructed; it's
-  // the job of the visit () routine to do that as needed.
-  //
-  // "Context" can be used to hold state used by the visit () routine.
-  // To terminate traversal "early", visit () returns TRAVERSE_STOP.
-  //
-  // The "value1" and "value2" parameters are pointers to data values
-  // of the structure described by the TypeCode.  Using the normal
-  // size, alignment, and padding rules used by the compilers on a
-  // given platform, the visit () routine is called with pointers to
-  // subsidiary elements.
-  //
-  // As all this routine does is appropriate pointer adjustments, it
-  // any value at all can be passed in as "value1" or "value2".  You
-  // could ignore one value and examine a data structure; copy from
-  // one to the other; compare one to the other; and more.
-  //
-  // Normal usage is to have application code call its visit () routine
-  // directly, and have that decide whether to use the typecode
-  // interpereter's knowledge of data structure layout through mutual
-  // recursion.
-
   size_t size (CORBA::Environment &env);
   // returns the size. Used by the IIOP marshaling engine.