ChangeLogTag:Mon Jun 30 22:29:51 2003 Balachandran Natarajan <bala@dre.vanderbilt.edu>refactor-stage4

53 files changed, 6254 insertions, 344 deletions

diff --git a/TAO/ChangeLog_ref b/TAO/ChangeLog_ref
index 1d472f9907c..e31ebf94889 100644
--- a/TAO/ChangeLog_ref
+++ b/TAO/ChangeLog_ref
@@ -1,3 +1,8 @@
+Mon Jun 30 22:29:51 2003  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
+
+	* Merged with the main trunk and created a new branch
+	  refactor-stage4. 
+
 Fri Jun 27 14:42:02 2003  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * TAO_IDL/be/be_visitor_traits.cpp:
diff --git a/TAO/tao/Arg_Traits_T.h b/TAO/tao/Arg_Traits_T.h
new file mode 100644
index 00000000000..90e736a4170
--- /dev/null
+++ b/TAO/tao/Arg_Traits_T.h
@@ -0,0 +1,38 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Arg_Traits_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_ARG_TRAITS_T_H
+#define TAO_ARG_TRAITS_T_H
+
+#include "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   *
+   * @brief Base class for all arg traits specializations.
+   *
+   */
+  template<typename T>
+  class Arg_Traits
+  {
+  };
+};
+
+#include "ace/post.h"
+
+#endif /* TAO_ARG_TRAITS_T_H */
diff --git a/TAO/tao/Argument.cpp b/TAO/tao/Argument.cpp
new file mode 100644
index 00000000000..a106ad6bb76
--- /dev/null
+++ b/TAO/tao/Argument.cpp
@@ -0,0 +1,33 @@
+
+// $Id$
+
+#include "tao/Argument.h"
+#include "tao/DynamicC.h"
+
+CORBA::Boolean
+TAO::Argument::marshal (TAO_OutputCDR &)
+{
+  return 1;
+}
+
+CORBA::Boolean
+TAO::Argument::demarshal (TAO_InputCDR &)
+{
+  return 1;
+}
+
+void
+TAO::Argument::interceptor_param (Dynamic::Parameter &)
+{
+}
+
+void
+TAO::Argument::interceptor_result (CORBA::Any *)
+{
+}
+
+CORBA::Boolean
+TAO::Argument::interceptor_replace (CORBA::Any &)
+{
+  return 1;
+}
diff --git a/TAO/tao/Argument.h b/TAO/tao/Argument.h
new file mode 100644
index 00000000000..0f4ef97cf8f
--- /dev/null
+++ b/TAO/tao/Argument.h
@@ -0,0 +1,58 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Basic_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_ARGUMENT_H
+#define TAO_ARGUMENT_H
+
+#include "ace/pre.h"
+#include "tao/corbafwd.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace Dynamic
+{
+  struct Parameter;
+};
+
+namespace CORBA
+{
+  class Any;
+}
+
+class TAO_OutputCDR;
+class TAO_InputCDR;
+
+namespace TAO
+{
+  /**
+   * @class Argument
+   *
+   * @brief Base class for template argument classes.
+   *
+   */
+  class TAO_Export Argument
+  {
+  public:
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+  };
+};
+
+#include "ace/post.h"
+
+#endif /* TAO_ARGUMENT_H */
diff --git a/TAO/tao/Array_VarOut_T.cpp b/TAO/tao/Array_VarOut_T.cpp
index b9058fedc07..90841d0d445 100644
--- a/TAO/tao/Array_VarOut_T.cpp
+++ b/TAO/tao/Array_VarOut_T.cpp
@@ -13,33 +13,33 @@ ACE_RCSID (tao,
            Array_VarOut_T, 
            "$Id$")
 
-template<typename T_slice, typename T_life>
-TAO_FixedArray_Var_T<T_slice,T_life> &
-TAO_FixedArray_Var_T<T_slice,T_life>::operator= (T_slice * p)
+template<typename T, typename T_slice, typename T_life>
+TAO_FixedArray_Var_T<T,T_slice,T_life> &
+TAO_FixedArray_Var_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   // Is what we own the same that is being assigned to us?
   if (this->ptr_ != p)
     {
       // Delete our stuff and assume ownership of p.
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       this->ptr_ = p;
     }
   
   return *this;
 }
 
-template<typename T_slice, typename T_life>
-TAO_FixedArray_Var_T<T_slice,T_life> &
-TAO_FixedArray_Var_T<T_slice,T_life>::operator= (
-    const TAO_FixedArray_Var_T<T_slice,T_life> & p
+template<typename T, typename T_slice, typename T_life>
+TAO_FixedArray_Var_T<T,T_slice,T_life> &
+TAO_FixedArray_Var_T<T,T_slice,T_life>::operator= (
+    const TAO_FixedArray_Var_T<T,T_slice,T_life> & p
   )
 {
   if (this != &p)
     {
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       
       // Deep copy.
-      this->ptr_ = T_life::tao_dup (p.in ());
+      this->ptr_ = TAO::Array_Traits<T,T_slice>::tao_dup (p.in ());
     }
   
   return *this;
@@ -47,33 +47,33 @@ TAO_FixedArray_Var_T<T_slice,T_life>::operator= (
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
-TAO_VarArray_Var_T<T_slice,T_life> &
-TAO_VarArray_Var_T<T_slice,T_life>::operator= (T_slice * p)
+template<typename T, typename T_slice, typename T_life>
+TAO_VarArray_Var_T<T,T_slice,T_life> &
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   // Is what we own the same that is being assigned to us?
   if (this->ptr_ != p)
     {
       // Delete our stuff and assume ownership of p.
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       this->ptr_ = p;
     }
   
   return *this;
 }
 
-template<typename T_slice, typename T_life>
-TAO_VarArray_Var_T<T_slice,T_life> &
-TAO_VarArray_Var_T<T_slice,T_life>::operator= (
-    const TAO_VarArray_Var_T<T_slice,T_life> & p
+template<typename T, typename T_slice, typename T_life>
+TAO_VarArray_Var_T<T,T_slice,T_life> &
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator= (
+    const TAO_VarArray_Var_T<T,T_slice,T_life> & p
   )
 {
   if (this != &p)
     {
-      T_life::tao_free (this->ptr_);
+      TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
       
       // Deep copy.
-      this->ptr_ = T_life::tao_dup (p.in ());
+      this->ptr_ = TAO::Array_Traits<T,T_slice>::tao_dup (p.in ());
     }
   
   return *this;
@@ -81,14 +81,14 @@ TAO_VarArray_Var_T<T_slice,T_life>::operator= (
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 void
-TAO_Array_Forany_T<T_slice,T_life>::_tao_any_destructor (
+TAO_Array_Forany_T<T,T_slice,T_life>::_tao_any_destructor (
     void * _tao_void_pointer
   )
 {
   T_slice * tmp = ACE_static_cast (T_slice *, _tao_void_pointer);
-  T_life::tao_free (tmp);
+  TAO::Array_Traits<T,T_slice>::tao_free (tmp);
 }
 
 #endif /* TAO_ARRAY_VAROUT_T_C */
diff --git a/TAO/tao/Array_VarOut_T.h b/TAO/tao/Array_VarOut_T.h
index d9efb3f754e..dd711969e5a 100644
--- a/TAO/tao/Array_VarOut_T.h
+++ b/TAO/tao/Array_VarOut_T.h
@@ -20,31 +20,50 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+namespace TAO
+{
+  /**
+   * struct Array_Traits
+   *
+   * @brief Specialized for each array in generated code.
+   *
+   */
+  template<typename T, typename T_slice>
+  struct Array_Traits
+  {
+    static T_slice * tao_alloc (void);
+    static void tao_free (T_slice * _tao_slice);
+    static T_slice * tao_dup (const T_slice * _tao_slice);
+    static void tao_copy (T_slice * _tao_to,
+                          const T_slice * _tao_from);
+  };
+};
+
 /**
  * @class TAO_Array_Var_Base_T
  *
  * @brief Parametrized implementation of _var base class for arrays.
  *
  */
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 class TAO_Array_Var_Base_T
 {
 public:
   TAO_Array_Var_Base_T (void);
   TAO_Array_Var_Base_T (T_slice *);
-  TAO_Array_Var_Base_T (const TAO_Array_Var_Base_T<T_slice,T_life> &);
+  TAO_Array_Var_Base_T (const TAO_Array_Var_Base_T<T,T_slice,T_life> &);
   ~TAO_Array_Var_Base_T (void);
-  
+
   T_slice & operator[] (CORBA::ULong index);
   T_slice const & operator[] (CORBA::ULong index) const;
-  operator T_slice * const & () const; 
-  
+  operator T_slice * const & () const;
+
   typedef const T_slice *   _in_type;
   typedef       T_slice *   _inout_type;
   typedef       T_slice *&  _out_type;
   typedef       T_slice *   _retn_type;
 
-  // in, inout, out, _retn 
+  // in, inout, out, _retn
   _in_type      in (void) const;
   _inout_type   inout (void);
   _out_type     out (void);
@@ -64,17 +83,17 @@ protected:
  * elements of fixed size.
  *
  */
-template<typename T_slice, typename T_life>
-class TAO_FixedArray_Var_T: public TAO_Array_Var_Base_T<T_slice,T_life>
+template<typename T, typename T_slice, typename T_life>
+class TAO_FixedArray_Var_T: public TAO_Array_Var_Base_T<T,T_slice,T_life>
 {
 public:
   TAO_FixedArray_Var_T (void);
   TAO_FixedArray_Var_T (T_slice *);
-  TAO_FixedArray_Var_T (const TAO_FixedArray_Var_T<T_slice,T_life> &);
-  
-  TAO_FixedArray_Var_T<T_slice,T_life> &operator= (T_slice *);
-  TAO_FixedArray_Var_T<T_slice,T_life> &operator= (
-      const TAO_FixedArray_Var_T<T_slice,T_life> &
+  TAO_FixedArray_Var_T (const TAO_FixedArray_Var_T<T,T_slice,T_life> &);
+
+  TAO_FixedArray_Var_T<T,T_slice,T_life> &operator= (T_slice *);
+  TAO_FixedArray_Var_T<T,T_slice,T_life> &operator= (
+      const TAO_FixedArray_Var_T<T,T_slice,T_life> &
     );
 };
 
@@ -85,19 +104,19 @@ public:
  * elements of variable size.
  *
  */
-template<typename T_slice, typename T_life>
-class TAO_VarArray_Var_T : public TAO_Array_Var_Base_T<T_slice,T_life>
+template<typename T, typename T_slice, typename T_life>
+class TAO_VarArray_Var_T : public TAO_Array_Var_Base_T<T,T_slice,T_life>
 {
 public:
   TAO_VarArray_Var_T (void);
   TAO_VarArray_Var_T (T_slice *);
-  TAO_VarArray_Var_T (const TAO_VarArray_Var_T<T_slice,T_life> &);
-  
-  TAO_VarArray_Var_T<T_slice,T_life> &operator= (T_slice *);
-  TAO_VarArray_Var_T<T_slice,T_life> &operator= (
-      const TAO_VarArray_Var_T<T_slice,T_life> &
+  TAO_VarArray_Var_T (const TAO_VarArray_Var_T<T,T_slice,T_life> &);
+
+  TAO_VarArray_Var_T<T,T_slice,T_life> &operator= (T_slice *);
+  TAO_VarArray_Var_T<T,T_slice,T_life> &operator= (
+      const TAO_VarArray_Var_T<T,T_slice,T_life> &
     );
-  
+
   operator T_slice *& ();
 };
 
@@ -107,26 +126,26 @@ public:
  * @brief Parametrized implementation of _out class for arrays.
  *
  */
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 class TAO_Array_Out_T
 {
 public:
   TAO_Array_Out_T (T_slice *&);
   TAO_Array_Out_T (T_var &);
-  TAO_Array_Out_T (const TAO_Array_Out_T<T_var,T_slice,T_life> &);
-  
-  TAO_Array_Out_T<T_var,T_slice,T_life> &operator= (
-      const TAO_Array_Out_T<T_var,T_slice,T_life> &
+  TAO_Array_Out_T (const TAO_Array_Out_T<T,T_var,T_slice,T_life> &);
+
+  TAO_Array_Out_T<T,T_var,T_slice,T_life> &operator= (
+      const TAO_Array_Out_T<T,T_var,T_slice,T_life> &
     );
-  TAO_Array_Out_T<T_var,T_slice,T_life> &operator= (T_slice *);
-  
+  TAO_Array_Out_T<T,T_var,T_slice,T_life> &operator= (T_slice *);
+
   operator T_slice *& ();
   T_slice *& ptr (void);
-  
+
   T_slice & operator[] (CORBA::ULong index);
   const T_slice & operator[] (CORBA::ULong index) const;
 private:
-  typedef TAO_Array_Out_T<T_var,T_slice,T_life> THIS_OUT_TYPE;
+  typedef TAO_Array_Out_T<T,T_var,T_slice,T_life> THIS_OUT_TYPE;
   T_slice *& ptr_;
   // Assignment from T_var not allowed.
   void operator= (const T_var &);
@@ -138,28 +157,30 @@ private:
  * @brief Parametrized implementation of _forany class for arrays.
  *
  */
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 class TAO_Array_Forany_T
 {
 public:
   TAO_Array_Forany_T (void);
   TAO_Array_Forany_T (T_slice *,
                       CORBA::Boolean nocopy = 0);
-  TAO_Array_Forany_T (const TAO_Array_Forany_T<T_slice,T_life> &);
+  TAO_Array_Forany_T (const TAO_Array_Forany_T<T,T_slice,T_life> &);
   ~TAO_Array_Forany_T (void);
-  
+
   static void _tao_any_destructor (void *);
-  
+
   TAO_Array_Forany_T & operator= (T_slice *);
-  TAO_Array_Forany_T & operator= (const TAO_Array_Forany_T<T_slice,T_life> &);
-  
+  TAO_Array_Forany_T & operator= (
+      const TAO_Array_Forany_T<T,T_slice,T_life> &
+    );
+
   T_slice & operator[] (CORBA::ULong index);
   const T_slice & operator[] (CORBA::ULong index) const;
-  
+
   operator T_slice * const & () const;
   operator T_slice *& ();
-  
-  // in, inout, out, _retn 
+
+  // in, inout, out, _retn
   const T_slice * in (void) const;
   T_slice * inout (void);
   T_slice * &out (void);
diff --git a/TAO/tao/Array_VarOut_T.inl b/TAO/tao/Array_VarOut_T.inl
index b44754124c3..6f2330f12b5 100644
--- a/TAO/tao/Array_VarOut_T.inl
+++ b/TAO/tao/Array_VarOut_T.inl
@@ -1,41 +1,40 @@
 //$Id$
-
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (void)
   : ptr_ (0)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (T_slice * p)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (T_slice * p)
   : ptr_ (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::TAO_Array_Var_Base_T (
+TAO_Array_Var_Base_T<T,T_slice,T_life>::TAO_Array_Var_Base_T (
     const TAO_Array_Var_Base_T & p
   )
 {
-  this->ptr_ = T_life::tao_dup (p.in ());
+  this->ptr_ = TAO::Array_Tratis<T,T_slice, T_forany>::tao_dup (p.in ());
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::~TAO_Array_Var_Base_T (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::~TAO_Array_Var_Base_T (void)
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Var_Base_T<T_slice,T_life>::operator T_slice * const & () const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::operator T_slice * const & () const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice const &
 TAO_Array_Var_Base_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
@@ -49,204 +48,193 @@ ACE_INLINE
 const T_slice &
 TAO_Array_Var_Base_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
 {
-#if defined (ACE_HAS_BROKEN_IMPLICIT_CONST_CAST)
-  return ACE_const_cast (
-      const T_slice &,
-      this->ptr_[index]
-    );
-#else
-  const T_slice & tmp = this->ptr_[index];
-  return tmp;
-#endif /* ACE_HAS_BROKEN_IMPLICIT_CONST_CAST */
+  return this->ptr_[index];
 }
 #endif
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Var_Base_T<T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-const T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::in (void) const
+T_slice * const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::in (void) const
 {
-  // @@@ (JP) This looks scary I know but it helps MSVC understand
-  // things better when the array is multi-dimensional.
-  return ACE_const_cast (const T_slice *,
-                         this->ptr_);
+  return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::inout (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::inout (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Var_Base_T<T_slice,T_life>::out (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::out (void)
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::_retn (void)
+TAO_Array_Var_Base_T<T,T_slice,T_life>::_retn (void)
 {
   T_slice * tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Var_Base_T<T_slice,T_life>::ptr (void) const
+TAO_Array_Var_Base_T<T,T_slice,T_life>::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (void)
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (void)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (T_slice * p)
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (T_slice * p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_FixedArray_Var_T<T_slice,T_life>::TAO_FixedArray_Var_T (
+TAO_FixedArray_Var_T<T,T_slice,T_life>::TAO_FixedArray_Var_T (
     const TAO_FixedArray_Var_T & p
   )
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (void)
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (void)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (T_slice * p)
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (T_slice * p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::TAO_VarArray_Var_T (
+TAO_VarArray_Var_T<T,T_slice,T_life>::TAO_VarArray_Var_T (
     const TAO_VarArray_Var_T & p
   )
-  : TAO_Array_Var_Base_T<T_slice,T_life> (p)
+  : TAO_Array_Var_Base_T<T,T_slice,T_life> (p)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_VarArray_Var_T<T_slice,T_life>::operator T_slice *& ()
+TAO_VarArray_Var_T<T,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
 // *************************************************************
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (T_slice *& p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (T_slice *& p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (T_var & p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (T_var & p)
   : ptr_ (p.out ())
 {
-  T_life::tao_free (this->ptr_);
+  TAO::Array_Traits<T,T_slice>::tao_free (this->ptr_);
   this->ptr_ = 0;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::TAO_Array_Out_T (
-    const TAO_Array_Out_T<T_var,T_slice,T_life> & p
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::TAO_Array_Out_T (
+    const TAO_Array_Out_T<T,T_var,T_slice,T_life> & p
   )
   : ptr_ (ACE_const_cast (THIS_OUT_TYPE &, p).ptr_)
 {}
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life> &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator= (
-    const TAO_Array_Out_T<T_var,T_slice,T_life> & p
+TAO_Array_Out_T<T,T_var,T_slice,T_life> &
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator= (
+    const TAO_Array_Out_T<T,T_var,T_slice,T_life> & p
   )
 {
   this->ptr_ = ACE_const_cast (THIS_OUT_TYPE &, p).ptr_;
   return *this;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life> &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator= (T_slice *p)
+TAO_Array_Out_T<T,T_var,T_slice,T_life> &
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator= (T_slice *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator T_slice *& ()
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Out_T<T_var,T_slice,T_life>::ptr (void)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::ptr (void)
 {
   return this->ptr_;
 }
 
-template<typename T_var, typename T_slice, typename T_life>
+template<typename T, typename T_var, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Out_T<T_var,T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Out_T<T,T_var,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
 // *************************************************************
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (void)
   : ptr_ (0),
     nocopy_ (0)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (
     T_slice * p,
     CORBA::Boolean nocopy
   )
@@ -254,36 +242,36 @@ TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
     nocopy_ (nocopy)
 {}
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::TAO_Array_Forany_T (
-    const TAO_Array_Forany_T<T_slice,T_life> & p
+TAO_Array_Forany_T<T,T_slice,T_life>::TAO_Array_Forany_T (
+    const TAO_Array_Forany_T<T,T_slice,T_life> & p
   )
 {
   this->ptr_ = p.ptr_;
   this->nocopy_ = p.nocopy_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::~TAO_Array_Forany_T (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::~TAO_Array_Forany_T (void)
 {
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life> &
-TAO_Array_Forany_T<T_slice,T_life>::operator= (T_slice * p)
+TAO_Array_Forany_T<T,T_slice,T_life> &
+TAO_Array_Forany_T<T,T_slice,T_life>::operator= (T_slice * p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life> &
-TAO_Array_Forany_T<T_slice,T_life>::operator= (
-    const TAO_Array_Forany_T<T_slice,T_life> & p
+TAO_Array_Forany_T<T,T_slice,T_life> &
+TAO_Array_Forany_T<T,T_slice,T_life>::operator= (
+    const TAO_Array_Forany_T<T,T_slice,T_life> & p
   )
 {
   this->ptr_ = p.ptr_;
@@ -291,24 +279,24 @@ TAO_Array_Forany_T<T_slice,T_life>::operator= (
   return *this;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::operator T_slice * const & () const
+TAO_Array_Forany_T<T,T_slice,T_life>::operator T_slice * const & () const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
-TAO_Array_Forany_T<T_slice,T_life>::operator T_slice *& ()
+TAO_Array_Forany_T<T,T_slice,T_life>::operator T_slice *& ()
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 const T_slice &
-TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
+TAO_Array_Forany_T<T,T_slice,T_life>::operator[] (CORBA::ULong index) const
 {
 #if defined (ACE_HAS_BROKEN_IMPLICIT_CONST_CAST)
   return ACE_const_cast (
@@ -321,18 +309,18 @@ TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index) const
 #endif /* ACE_HAS_BROKEN_IMPLICIT_CONST_CAST */
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice &
-TAO_Array_Forany_T<T_slice,T_life>::operator[] (CORBA::ULong index)
+TAO_Array_Forany_T<T,T_slice,T_life>::operator[] (CORBA::ULong index)
 {
   return this->ptr_[index];
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 const T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::in (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::in (void) const
 {
   // @@@ (JP) This looks scary I know but it helps MSVC understand
   // things better when the array is multi-dimensional.
@@ -340,51 +328,50 @@ TAO_Array_Forany_T<T_slice,T_life>::in (void) const
                          this->ptr_);
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::inout (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::inout (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *&
-TAO_Array_Forany_T<T_slice,T_life>::out (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::out (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::_retn (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::_retn (void)
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::ptr (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::ptr (void) const
 {
   return this->ptr_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 CORBA::Boolean
-TAO_Array_Forany_T<T_slice,T_life>::nocopy (void) const
+TAO_Array_Forany_T<T,T_slice,T_life>::nocopy (void) const
 {
   return this->nocopy_;
 }
 
-template<typename T_slice, typename T_life>
+template<typename T, typename T_slice, typename T_life>
 ACE_INLINE
 T_slice *
-TAO_Array_Forany_T<T_slice,T_life>::tao_alloc (void)
+TAO_Array_Forany_T<T,T_slice,T_life>::tao_alloc (void)
 {
-  return T_life::tao_alloc ();
+  return TAO::Array_Traits<T,T_slice>::tao_alloc ();
 }
-
diff --git a/TAO/tao/BD_String_Argument_T.cpp b/TAO/tao/BD_String_Argument_T.cpp
new file mode 100644
index 00000000000..4b1ef4d4e37
--- /dev/null
+++ b/TAO/tao/BD_String_Argument_T.cpp
@@ -0,0 +1,418 @@
+// $Id$
+
+#ifndef TAO_BD_STRING_ARGUMENT_T_C
+#define TAO_BD_STRING_ARGUMENT_T_C
+
+#include "tao/BD_String_Argument_T.h"
+
+ACE_RCSID (tao,
+           String_Argument_T,
+           "$Id$")
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+TAO::In_BD_String_Argument_T<S,to_S,from_S,BOUND>::In_BD_String_Argument_T (
+    const S * x
+  )
+  : x_ (x)
+{}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+CORBA::Boolean
+TAO::In_BD_String_Argument_T<S,to_S,from_S,BOUND>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_, BOUND);
+}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+void
+TAO::In_BD_String_Argument_T<S,to_S,from_S,BOUND>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_, BOUND);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+CORBA::Boolean
+TAO::In_BD_String_Argument_T<S,to_S,from_S,BOUND>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= to_S (this->x_, BOUND);
+}
+
+// ===========================================================
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+TAO::Inout_BD_String_Argument_T<S,to_S,from_S,BOUND>::
+Inout_BD_String_Argument_T (S *& x)
+  : x_ (x)
+{}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_Argument_T<S,to_S,from_S,BOUND>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_, BOUND);
+}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_Argument_T<S,to_S,from_S,BOUND>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_, BOUND);
+}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+void
+TAO::Inout_BD_String_Argument_T<S,to_S,from_S,BOUND>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_, BOUND);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename to_S, typename from_S, size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_Argument_T<S,to_S,from_S,BOUND>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= to_S (this->x_, BOUND);
+}
+
+// ==============================================================
+
+template<typename S, 
+         typename S_out, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::Out_BD_String_Argument_T<S,S_out,to_S,from_S,BOUND>::
+Out_BD_String_Argument_T (S_out x)
+  : x_ (x.ptr ())
+{}
+
+template<typename S, 
+         typename S_out, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Out_BD_String_Argument_T<S,S_out,to_S,from_S,BOUND>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_, BOUND);
+}
+
+// ============================================================
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::
+Ret_BD_String_Argument_T (void)
+{
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+void
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= from_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+S *
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+S *
+TAO::Ret_BD_String_Argument_T<S,S_var,to_S,from_S,BOUND>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+In_BD_String_SArgument_T (void)
+{}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+void
+TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_.in (), BOUND);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+const S *
+TAO::In_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::arg (void) const
+{
+  return this->x_.in ();
+}
+
+// ===========================================================
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+Inout_BD_String_SArgument_T (void)
+{}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+void
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= from_S (this->x_.in (), BOUND);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+S *&
+TAO::Inout_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::arg (void)
+{
+  return this->x_.inout ();
+}
+
+// ==============================================================
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::Out_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+Out_BD_String_SArgument_T (void)
+{}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Out_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::marshal (
+    TAO_OutputCDR &cdr
+  )
+{
+  return cdr << from_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+S *&
+TAO::Out_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::arg (void)
+{
+  return this->x_.out ();
+}
+
+// ============================================================
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+TAO::Ret_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+Ret_BD_String_SArgument_T (void)
+{
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Ret_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+void
+TAO::Ret_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= from_S (this->x_.in (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+CORBA::Boolean
+TAO::Ret_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::
+interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_.out (), BOUND);
+}
+
+template<typename S, 
+         typename S_var, 
+         typename to_S, 
+         typename from_S, 
+         size_t BOUND>
+S *&
+TAO::Ret_BD_String_SArgument_T<S,S_var,to_S,from_S,BOUND>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_BD_STRING_ARGUMENT_T_C */
diff --git a/TAO/tao/BD_String_Argument_T.h b/TAO/tao/BD_String_Argument_T.h
new file mode 100644
index 00000000000..8bf5fe4ff5c
--- /dev/null
+++ b/TAO/tao/BD_String_Argument_T.h
@@ -0,0 +1,341 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    BD_String_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_BD_STRING_ARGUMENT_T_H
+#define TAO_BD_STRING_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "ace/CDR_Stream.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Argument.h"
+
+namespace TAO
+{
+  /**
+   * @class In_BD_String_Argument_T
+   *
+   * @brief Template class for IN bounded (w)string argument.
+   *
+   */
+  template<typename S, typename to_S, typename from_S, size_t BOUND>
+  class In_BD_String_Argument_T : public Argument
+  {
+  public:
+    In_BD_String_Argument_T (const S * x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    const S * x_;
+  };
+
+  /**
+   * @class Inout_BD_String_Argument_T
+   *
+   * @brief Template class for INOUT bounded (w)string argument.
+   *
+   */
+  template<typename S, typename to_S, typename from_S, size_t BOUND>
+  class Inout_BD_String_Argument_T : public Argument
+  {
+  public:
+    Inout_BD_String_Argument_T (S *& x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    mutable S *& x_;
+  };
+
+  /**
+   * @class Out_BD_String_Argument_T
+   *
+   * @brief Template class for INOUT bounded (w)string argument.
+   *
+   */
+  template<typename S, 
+           typename S_out, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class Out_BD_String_Argument_T : public Argument
+  {
+  public:
+    Out_BD_String_Argument_T (S_out x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S *& x_;
+  };
+
+  /**
+   * @class Ret_BD_String_Argument_T
+   *
+   * @brief Template class for return stub value of bd (w)string argument.
+   *
+   */
+  template<typename S, 
+           typename S_var, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class Ret_BD_String_Argument_T : public Argument
+  {
+  public:
+    Ret_BD_String_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S * excp (void);
+    S * retn (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class In_BD_String_SArgument_T
+   *
+   * @brief Template class for IN skeleton bd (w)string argument.
+   *
+   */
+  template<typename S, 
+           typename S_var, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class In_BD_String_SArgument_T : public Argument
+  {
+  public:
+    In_BD_String_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S * arg (void) const;
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Inout_BD_String_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton bd (w)string argument.
+   *
+   */
+  template<typename S, 
+           typename S_var, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class Inout_BD_String_SArgument_T : public Argument
+  {
+  public:
+    Inout_BD_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Out_BD_String_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton bd (w)string argument.
+   *
+   */
+  template<typename S, 
+           typename S_var, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class Out_BD_String_SArgument_T : public Argument
+  {
+  public:
+    Out_BD_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_BD_String_SArgument_T
+   *
+   * @brief Template class for return skeleton value of bd (w)string.
+   *
+   */
+  template<typename S, 
+           typename S_var, 
+           typename to_S, 
+           typename from_S, 
+           size_t BOUND>
+  class Ret_BD_String_SArgument_T : public Argument
+  {
+  public:
+    Ret_BD_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct BD_String_Tag
+   *
+   * @brief Struct for bounded (w)string arguments id tag.
+   *
+   */
+  struct TAO_Export BD_String_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of bounded (w)strings.
+   *
+   */
+  template<typename T, 
+           typename T_var, 
+           typename T_out, 
+           typename to_T, 
+           typename from_T, 
+           size_t BOUND>
+  struct BD_String_Arg_Traits_T
+  {
+    typedef T *                                   ret_type;
+    typedef const T *                             in_type;
+    typedef T *&                                  inout_type;
+    typedef T_out                                 out_type;
+
+    typedef In_BD_String_Argument_T<T,
+                                    to_T,
+                                    from_T,
+                                    BOUND>        in_arg_val;
+    typedef Inout_BD_String_Argument_T<T,
+                                       to_T,
+                                       from_T,
+                                       BOUND>     inout_arg_val;
+    typedef Out_BD_String_Argument_T<T,
+                                     T_out,
+                                     to_T,
+                                     from_T,
+                                     BOUND>       out_arg_val;
+    typedef Ret_BD_String_Argument_T<T,
+                                     T_var,
+                                     to_T,
+                                     from_T,
+                                     BOUND>       stub_ret_val;
+
+    typedef In_BD_String_SArgument_T<T,
+                                     T_var,
+                                     to_T,
+                                     from_T,
+                                     BOUND>       in_sarg_val;
+    typedef Inout_BD_String_SArgument_T<T,
+                                        T_var,
+                                        to_T,
+                                        from_T,
+                                        BOUND>    inout_sarg_val;
+    typedef Out_BD_String_SArgument_T<T,
+                                      T_var,
+                                      to_T,
+                                      from_T,
+                                      BOUND>      out_sarg_val;
+    typedef Ret_BD_String_SArgument_T<T,
+                                      T_var,
+                                      to_T,
+                                      from_T,
+                                      BOUND>      skel_ret_val;
+
+    typedef BD_String_Tag                         idl_tag;
+  };
+
+  /**
+   *
+   * @brief Specializations for bounded (w)strings
+   *
+   */
+
+  template<size_t BOUND>
+  class BD_String_Arg_Traits
+    : public BD_String_Arg_Traits_T<CORBA::Char, 
+                                    CORBA::String_var,
+                                    CORBA::String_out,
+                                    ACE_InputCDR::to_string,
+                                    ACE_OutputCDR::from_string,
+                                    BOUND>
+  {
+  };
+
+  template<size_t BOUND>
+  class BD_WString_Arg_Traits
+    : public BD_String_Arg_Traits_T<CORBA::WChar, 
+                                    CORBA::WString_var,
+                                    CORBA::WString_out,
+                                    ACE_InputCDR::to_wstring,
+                                    ACE_OutputCDR::from_wstring,
+                                    BOUND>
+  {
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/BD_String_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("BD_String_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_BD_STRING_ARGUMENT_T_H */
+
diff --git a/TAO/tao/Basic_Argument_T.cpp b/TAO/tao/Basic_Argument_T.cpp
new file mode 100644
index 00000000000..2416bfe041d
--- /dev/null
+++ b/TAO/tao/Basic_Argument_T.cpp
@@ -0,0 +1,263 @@
+// $Id$
+
+#ifndef TAO_BASIC_ARGUMENT_T_C
+#define TAO_BASIC_ARGUMENT_T_C
+
+#include "tao/Basic_Argument_T.h"
+
+ACE_RCSID (tao,
+           Basic_Argument_T,
+           "$Id$")
+
+template<typename S>
+TAO::In_Basic_Argument_T<S>::In_Basic_Argument_T (S const & x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Basic_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Basic_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Basic_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Basic_Argument_T<S>::Inout_Basic_Argument_T (S & x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Basic_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S>
+TAO::Out_Basic_Argument_T<S>::Out_Basic_Argument_T (S & x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Out_Basic_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::Ret_Basic_Argument_T<S>::Ret_Basic_Argument_T (void)
+{
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Basic_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S>
+void
+TAO::Ret_Basic_Argument_T<S>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Basic_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S
+TAO::Ret_Basic_Argument_T<S>::excp (void)
+{
+  return this->x_;
+}
+
+template<typename S>
+S
+TAO::Ret_Basic_Argument_T<S>::retn (void)
+{
+  return this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::In_Basic_SArgument_T<S>::In_Basic_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Basic_SArgument_T<S>::demarshal (TAO_InputCDR &cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Basic_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Basic_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S
+TAO::In_Basic_SArgument_T<S>::arg (void) const
+{
+  return this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Basic_SArgument_T<S>::Inout_Basic_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_SArgument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_SArgument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Basic_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Basic_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S &
+TAO::Inout_Basic_SArgument_T<S>::arg (void)
+{
+  return this->x_;
+}
+
+// ==============================================================
+
+template<typename S>
+TAO::Out_Basic_SArgument_T<S>::Out_Basic_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Out_Basic_SArgument_T<S>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+S &
+TAO::Out_Basic_SArgument_T<S>::arg (void)
+{
+  return this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::Ret_Basic_SArgument_T<S>::Ret_Basic_SArgument_T (void)
+{
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Basic_SArgument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+void
+TAO::Ret_Basic_SArgument_T<S>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Basic_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S &
+TAO::Ret_Basic_SArgument_T<S>::arg (void)
+{
+  return this->x_;
+}
+
+#endif /* TAO_BASIC_ARGUMENT_T_C */
diff --git a/TAO/tao/Basic_Argument_T.h b/TAO/tao/Basic_Argument_T.h
new file mode 100644
index 00000000000..2655bdcbcb7
--- /dev/null
+++ b/TAO/tao/Basic_Argument_T.h
@@ -0,0 +1,251 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Basic_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_BASIC_ARGUMENT_T_H
+#define TAO_BASIC_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_Basic_Argument_T
+   *
+   * @brief Template class for IN stub argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class In_Basic_Argument_T : public Argument
+  {
+  public:
+    In_Basic_Argument_T (S const & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S const & x_;
+  };
+
+  /**
+   * @class Inout_Basic_Argument_T
+   *
+   * @brief Template class for INOUT stub argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Basic_Argument_T : public Argument
+  {
+  public:
+    Inout_Basic_Argument_T (S & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    mutable S & x_;
+  };
+
+  /**
+   * @class Out_Basic_Argument_T
+   *
+   * @brief Template class for OUT stub argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Out_Basic_Argument_T : public Argument
+  {
+  public:
+    Out_Basic_Argument_T (S & x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S & x_;
+  };
+
+  /**
+   * @class Ret_Basic_Argument_T
+   *
+   * @brief Template class for return stub value of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Ret_Basic_Argument_T : public Argument
+  {
+  public:
+    Ret_Basic_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S excp (void);
+    S retn (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class In_Basic_SArgument_T
+   *
+   * @brief Template class for IN skeleton argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class In_Basic_SArgument_T : public Argument
+  {
+  public:
+    In_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S arg (void) const;
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Inout_Basic_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Basic_SArgument_T : public Argument
+  {
+  public:
+    Inout_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Out_Basic_SArgument_T
+   *
+   * @brief Template class for OUT skeleton argument of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Out_Basic_SArgument_T : public Argument
+  {
+  public:
+    Out_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Ret_Basic_SArgument_T
+   *
+   * @brief Template class for return skeleton value of basic IDL types.
+   *
+   */
+  template<typename S>
+  class Ret_Basic_SArgument_T : public Argument
+  {
+  public:
+    Ret_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @struct Basic_Tag
+   *
+   * @brief Struct for basic IDL type arguments id tag.
+   *
+   */
+  struct TAO_Export Basic_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of basic IDL types.
+   *
+   */
+  template<typename T>
+  struct Basic_Arg_Traits_T
+  {
+    typedef T                           ret_type;
+    typedef T                           in_type;
+    typedef T &                         inout_type;
+    typedef T &                         out_type;
+
+    typedef In_Basic_Argument_T<T>      in_arg_val;
+    typedef Inout_Basic_Argument_T<T>   inout_arg_val;
+    typedef Out_Basic_Argument_T<T>     out_arg_val;
+    typedef Ret_Basic_Argument_T<T>     stub_ret_val;
+
+    typedef In_Basic_SArgument_T<T>     in_sarg_val;
+    typedef Inout_Basic_SArgument_T<T>  inout_sarg_val;
+    typedef Out_Basic_SArgument_T<T>    out_sarg_val;
+    typedef Ret_Basic_SArgument_T<T>    skel_ret_val;
+
+    typedef Basic_Tag                   idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Basic_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Basic_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_BASIC_ARGUMENT_T_H */
diff --git a/TAO/tao/Basic_Arguments.cpp b/TAO/tao/Basic_Arguments.cpp
new file mode 100644
index 00000000000..3de4c2c48ec
--- /dev/null
+++ b/TAO/tao/Basic_Arguments.cpp
@@ -0,0 +1,55 @@
+// $Id$
+
+#include "tao/Basic_Arguments.h"
+
+ACE_RCSID (tao,
+           Basic_Arguments,
+           "$Id$")
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class TAO::Arg_Traits_T<void>;
+template class TAO::Arg_Traits_T<CORBA::Short>;
+template class TAO::Arg_Traits_T<CORBA::Long>;
+template class TAO::Arg_Traits_T<CORBA::UShort>;
+template class TAO::Arg_Traits_T<CORBA::ULong>;
+template class TAO::Arg_Traits_T<CORBA::Float>;
+template class TAO::Arg_Traits_T<CORBA::Double>;
+template class TAO::Arg_Traits_T<CORBA::LongLong>;
+template class TAO::Arg_Traits_T<CORBA::ULongLong>;
+template class TAO::Arg_Traits_T<CORBA::LongDouble>;
+
+template class TAO::Basic_Arg_Traits_T<CORBA::Short>;
+template class TAO::Basic_Arg_Traits_T<CORBA::Long>;
+template class TAO::Basic_Arg_Traits_T<CORBA::UShort>;
+template class TAO::Basic_Arg_Traits_T<CORBA::ULong>;
+template class TAO::Basic_Arg_Traits_T<CORBA::Float>;
+template class TAO::Basic_Arg_Traits_T<CORBA::Double>;
+template class TAO::Basic_Arg_Traits_T<CORBA::LongLong>;
+template class TAO::Basic_Arg_Traits_T<CORBA::ULongLong>;
+template class TAO::Basic_Arg_Traits_T<CORBA::LongDouble>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+# pragma instantiate TAO::Arg_Traits_T<void>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::Short>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::Long>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::UShort>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::ULong>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::Float>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::Double>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::LongLong>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::ULongLong>
+# pragma instantiate TAO::Arg_Traits_T<CORBA::LongDouble>
+
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::Short>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::Long>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::UShort>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::ULong>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::Float>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::Double>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::LongLong>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::ULongLong>
+# pragma instantiate TAO::Basic_Arg_Traits_T<CORBA::LongDouble>
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/Basic_Arguments.h b/TAO/tao/Basic_Arguments.h
new file mode 100644
index 00000000000..9a71ab9f0d2
--- /dev/null
+++ b/TAO/tao/Basic_Arguments.h
@@ -0,0 +1,107 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Basic_Arguments.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_BASIC_ARGUMENTS_H
+#define TAO_BASIC_ARGUMENTS_H
+
+#include "ace/pre.h"
+#include "tao/Basic_Argument_T.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Arg_Traits_T.h"
+
+namespace TAO
+{
+  /**
+   *
+   * @brief Specialization for void return type.
+   *
+   */
+  template<>
+  class TAO_Export Arg_Traits<void>
+  {
+    typedef void        ret_type;
+
+    typedef Argument    stub_ret_val;
+    typedef Argument    skel_ret_val;
+
+    typedef Basic_Tag   idl_tag;
+  };
+
+  /**
+   *
+   * @brief Specializations for basic arg types, except (w)char/boolean/octet.
+   *
+   */
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Short>
+    : public Basic_Arg_Traits_T<CORBA::Short>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Long>
+    : public Basic_Arg_Traits_T<CORBA::Long>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::UShort>
+    : public Basic_Arg_Traits_T<CORBA::UShort>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::ULong>
+    : public Basic_Arg_Traits_T<CORBA::Short>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Float>
+    : public Basic_Arg_Traits_T<CORBA::Float>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Double>
+    : public Basic_Arg_Traits_T<CORBA::Double>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::LongLong>
+    : public Basic_Arg_Traits_T<CORBA::LongLong>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::ULongLong>
+    : public Basic_Arg_Traits_T<CORBA::ULongLong>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::LongDouble>
+    : public Basic_Arg_Traits_T<CORBA::LongDouble>
+  {
+  };
+};
+
+#include "ace/post.h"
+
+#endif /* TAO_BASIC_ARGUMENTS_H */
diff --git a/TAO/tao/CORBA_String.h b/TAO/tao/CORBA_String.h
index 33acf238b12..e518c313c16 100644
--- a/TAO/tao/CORBA_String.h
+++ b/TAO/tao/CORBA_String.h
@@ -93,6 +93,9 @@ namespace CORBA
     /// for string of return type.
     char *_retn (void);
 
+    /// TAO extension.
+    char *ptr (void);
+
   private:
     /// instance.
     char *ptr_;
@@ -209,6 +212,9 @@ namespace CORBA
     /// for string of return type.
     CORBA::WChar *_retn (void);
 
+    /// TAO extension.
+    CORBA::WChar *ptr (void);
+
   private:
     /// instance.
     CORBA::WChar *ptr_;
diff --git a/TAO/tao/CORBA_String.inl b/TAO/tao/CORBA_String.inl
index 79c40246dcd..a6c4093675d 100644
--- a/TAO/tao/CORBA_String.inl
+++ b/TAO/tao/CORBA_String.inl
@@ -72,6 +72,13 @@ CORBA::String_var::_retn (void)
   return temp;
 }
 
+/// TAO extension.
+ACE_INLINE char *
+CORBA::String_var::ptr (void)
+{
+  return this->ptr_;
+}
+
 // ----------------------------------------------------
 //  String_out type
 // ----------------------------------------------------
@@ -206,6 +213,13 @@ CORBA::WString_var::_retn (void)
   return temp;
 }
 
+/// TAO extension.
+ACE_INLINE CORBA::WChar *
+CORBA::WString_var::ptr (void)
+{
+  return this->ptr_;
+}
+
 // ----------------------------------------------------
 //  String_out type
 // ----------------------------------------------------
diff --git a/TAO/tao/Cleanup_Func_Registry.h b/TAO/tao/Cleanup_Func_Registry.h
index e5668d97d29..d424c3e5c01 100644
--- a/TAO/tao/Cleanup_Func_Registry.h
+++ b/TAO/tao/Cleanup_Func_Registry.h
@@ -23,6 +23,7 @@
 #include "ace/Array_Base.h"
 #include "ace/OS.h"  // for ACE_CLEANUP_FUNC
 
+
 /**
  * @class TAO_Cleanup_Func_Registry
  *
diff --git a/TAO/tao/Fixed_Array_Argument_T.cpp b/TAO/tao/Fixed_Array_Argument_T.cpp
new file mode 100644
index 00000000000..dca96b64fc4
--- /dev/null
+++ b/TAO/tao/Fixed_Array_Argument_T.cpp
@@ -0,0 +1,310 @@
+// $Id$
+
+#ifndef TAO_FIXED_ARRAY_ARGUMENT_T_C
+#define TAO_FIXED_ARRAY_ARGUMENT_T_C
+
+#include "tao/Fixed_Array_Argument_T.h"
+
+ACE_RCSID (tao,
+           Fixed_Array_Argument_T,
+           "$Id$")
+
+template<typename S, typename S_slice, typename S_forany>
+TAO::In_Fixed_Array_Argument_T<S,S_slice,S_forany>::
+In_Fixed_Array_Argument_T (const S x)
+  : x_ ((S_slice *) x)
+{}
+
+template<typename S, typename S_slice, typename S_forany>
+CORBA::Boolean
+TAO::In_Fixed_Array_Argument_T<S,S_slice,S_forany>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << this->x_;
+}
+
+template<typename S, typename S_slice, typename S_forany>
+void
+TAO::In_Fixed_Array_Argument_T<S,S_slice,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename S_slice, typename S_forany>
+CORBA::Boolean
+TAO::In_Fixed_Array_Argument_T<S,S_slice,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S, typename S_forany>
+TAO::Inout_Fixed_Array_Argument_T<S,S_forany>::Inout_Fixed_Array_Argument_T (
+    S x
+  )
+  : x_ (x)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_Argument_T<S,S_forany>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_Argument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::Inout_Fixed_Array_Argument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_Argument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_forany>
+TAO::Out_Fixed_Array_Argument_T<S,S_forany>::Out_Fixed_Array_Argument_T (S x)
+  : x_ (x)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Out_Fixed_Array_Argument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+// ============================================================
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
+Ret_Fixed_Array_Argument_T (void)
+{
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
+  S_slice * tmp = 0;
+  ACE_ALLOCATOR (tmp,
+                 ARRAY_TRAITS::tao_alloc ());
+  this->x_ = tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  S_forany tmp (this->x_.ptr ());
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+void
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
+interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= S_forany (this->x_.ptr ());
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::
+interceptor_replace (CORBA::Any & any)
+{
+  S_forany tmp (this->x_.ptr ());
+  return any >>= tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+S_slice *
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+S_slice *
+TAO::Ret_Fixed_Array_Argument_T<S,S_slice,S_var,S_forany>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S, typename S_forany>
+TAO::In_Fixed_Array_SArgument_T<S,S_forany>::In_Fixed_Array_SArgument_T (void)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::In_Fixed_Array_SArgument_T<S,S_forany>::demarshal (TAO_InputCDR &cdr)
+{
+  S_forany tmp (this->x_);
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::In_Fixed_Array_SArgument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= S_forany (this->x_);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::In_Fixed_Array_SArgument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  S_forany tmp (this->x_);
+  return any >>= tmp;
+}
+
+template<typename S, typename S_forany>
+const S &
+TAO::In_Fixed_Array_SArgument_T<S,S_forany>::arg (void) const
+{
+  return this->x_;
+}
+
+// ===========================================================
+
+template<typename S, typename S_forany>
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::
+Inout_Fixed_Array_SArgument_T (void)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << S_forany (this->x_);
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
+{
+  S_forany tmp (this->x_);
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= S_forany (this->x_);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  S_forany tmp (this->x_);
+  return any >>= tmp;
+}
+
+template<typename S, typename S_forany>
+S &
+TAO::Inout_Fixed_Array_SArgument_T<S,S_forany>::arg (void)
+{
+  return this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_forany>
+TAO::Out_Fixed_Array_SArgument_T<S,S_forany>::Out_Fixed_Array_SArgument_T (
+    void
+  )
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Out_Fixed_Array_SArgument_T<S,S_forany>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << S_forany (this->x_);
+}
+
+template<typename S, typename S_forany>
+S &
+TAO::Out_Fixed_Array_SArgument_T<S,S_forany>::arg (void)
+{
+  return this->x_;
+}
+
+// ============================================================
+
+template<typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Fixed_Array_SArgument_T<S_slice,S_var,S_forany>::
+Ret_Fixed_Array_SArgument_T (void)
+{
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Fixed_Array_SArgument_T<S_slice,S_var,S_forany>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << S_forany (this->x_.inout ());
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+void
+TAO::Ret_Fixed_Array_SArgument_T<S_slice,S_var,S_forany>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= S_forany (this->x_.ptr ());
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Fixed_Array_SArgument_T<S_slice,S_var,S_forany>::
+interceptor_replace (CORBA::Any & any)
+{
+  S_forany tmp (this->x_.inout ());
+  return any >>= tmp;
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+S_slice *&
+TAO::Ret_Fixed_Array_SArgument_T<S_slice,S_var,S_forany>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_FIXED_ARRAY_ARGUMENT_T_C */
diff --git a/TAO/tao/Fixed_Array_Argument_T.h b/TAO/tao/Fixed_Array_Argument_T.h
new file mode 100644
index 00000000000..35e9031cce4
--- /dev/null
+++ b/TAO/tao/Fixed_Array_Argument_T.h
@@ -0,0 +1,264 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Fixed_Array_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_FIXED_ARRAY_ARGUMENT_T_H
+#define TAO_FIXED_ARRAY_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_Fixed_Array_Argument_T
+   *
+   * @brief IN stub argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_slice, typename S_forany>
+  class In_Fixed_Array_Argument_T : public Argument
+  {
+  public:
+    In_Fixed_Array_Argument_T (const S x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S_forany x_;
+  };
+
+  /**
+   * @class Inout_Fixed_Array_Argument_T
+   *
+   * @brief INOUT stub argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Inout_Fixed_Array_Argument_T : public Argument
+  {
+  public:
+    Inout_Fixed_Array_Argument_T (S x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S_forany x_;
+  };
+
+  /**
+   * @class Out_Fixed_Array_Argument_T
+   *
+   * @brief OUT stub argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Out_Fixed_Array_Argument_T : public Argument
+  {
+  public:
+    Out_Fixed_Array_Argument_T (S x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    S_forany x_;
+  };
+
+  /**
+   * @class Ret_Fixed_Array_Argument_T
+   *
+   * @brief Return stub value of fixed size element array.
+   *
+   */
+  template<typename S,
+           typename S_slice, 
+           typename S_var, 
+           typename S_forany>
+  class Ret_Fixed_Array_Argument_T : public Argument
+  {
+  public:
+    Ret_Fixed_Array_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_slice * excp (void);
+    S_slice * retn (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class In_Fixed_Array_SArgument_T
+   *
+   * @brief IN skeleton argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class In_Fixed_Array_SArgument_T : public Argument
+  {
+  public:
+    In_Fixed_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S & arg (void) const;
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Inout_Fixed_Array_SArgument_T
+   *
+   * @brief INOUT skeleton argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Inout_Fixed_Array_SArgument_T : public Argument
+  {
+  public:
+    Inout_Fixed_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Out_Fixed_Array_SArgument_T
+   *
+   * @brief OUT skeleton argument of fixed size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Out_Fixed_Array_SArgument_T : public Argument
+  {
+  public:
+    Out_Fixed_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Ret_Fixed_Array_SArgument_T
+   *
+   * @brief Skeleton value of fixed size element array.
+   *
+   */
+  template<typename S_slice, typename S_var, typename S_forany>
+  class Ret_Fixed_Array_SArgument_T : public Argument
+  {
+  public:
+    Ret_Fixed_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_slice *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct Fixed_Array_Tag
+   *
+   * @brief Struct for fixed size element array argument id tag.
+   *
+   */
+  struct TAO_Export Fixed_Array_Tag {};
+
+  /**
+   * @struct Fixed_Array_Arg_Traits_T
+   *
+   * @brief Argument traits of fixed size element array.
+   *
+   */
+  template<typename T, 
+           typename T_slice, 
+           typename T_var, 
+           typename T_forany>
+  struct Fixed_Array_Arg_Traits_T
+  {
+    typedef T_slice *                                   ret_type;
+    typedef const T                                     in_type;
+    typedef T                                           inout_type;
+    typedef T                                           out_type;
+
+    typedef In_Fixed_Array_Argument_T<T,
+                                      T_slice,
+                                      T_forany>         in_arg_val;
+    typedef Inout_Fixed_Array_Argument_T<T,T_forany>    inout_arg_val;
+    typedef Out_Fixed_Array_Argument_T<T,T_forany>      out_arg_val;
+    typedef Ret_Fixed_Array_Argument_T<T,
+                                       T_slice,
+                                       T_var,
+                                       T_forany>        stub_ret_val;
+
+    typedef In_Fixed_Array_SArgument_T<T,T_forany>      in_sarg_val;
+    typedef Inout_Fixed_Array_SArgument_T<T,T_forany>   inout_sarg_val;
+    typedef Out_Fixed_Array_SArgument_T<T,T_forany>     out_sarg_val;
+    typedef Ret_Fixed_Array_SArgument_T<T_slice,
+                                        T_var,
+                                        T_forany>       skel_ret_val;
+
+    typedef Fixed_Array_Tag                             idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Fixed_Array_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Fixed_Array_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_FIXED_ARRAY_ARGUMENT_T_H */
diff --git a/TAO/tao/Fixed_Size_Argument_T.cpp b/TAO/tao/Fixed_Size_Argument_T.cpp
new file mode 100644
index 00000000000..aee7ca4bdf4
--- /dev/null
+++ b/TAO/tao/Fixed_Size_Argument_T.cpp
@@ -0,0 +1,263 @@
+// $Id$
+
+#ifndef TAO_FIXED_SIZE_ARGUMENT_T_C
+#define TAO_FIXED_SIZE_ARGUMENT_T_C
+
+#include "tao/Fixed_Size_Argument_T.h"
+
+ACE_RCSID (tao,
+           Fixed_Size_Argument_T,
+           "$Id$")
+
+template<typename S>
+TAO::In_Fixed_Size_Argument_T<S>::In_Fixed_Size_Argument_T (S const & x)
+  : x_ (&x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Fixed_Size_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Fixed_Size_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Fixed_Size_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Fixed_Size_Argument_T<S>::Inout_Fixed_Size_Argument_T (S & x)
+  : x_ (&x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Fixed_Size_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S>
+TAO::Out_Fixed_Size_Argument_T<S>::Out_Fixed_Size_Argument_T (S & x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Out_Fixed_Size_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::Ret_Fixed_Size_Argument_T<S>::Ret_Fixed_Size_Argument_T (void)
+{
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Fixed_Size_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::Ret_Fixed_Size_Argument_T<S>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Fixed_Size_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S
+TAO::Ret_Fixed_Size_Argument_T<S>::excp (void)
+{
+  return *this->x_;
+}
+
+template<typename S>
+S
+TAO::Ret_Fixed_Size_Argument_T<S>::retn (void)
+{
+  return *this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::In_Fixed_Size_SArgument_T<S>::In_Fixed_Size_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Fixed_Size_SArgument_T<S>::demarshal (TAO_InputCDR &cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Fixed_Size_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Fixed_Size_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+const S &
+TAO::In_Fixed_Size_SArgument_T<S>::arg (void) const
+{
+  return *this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Fixed_Size_SArgument_T<S>::Inout_Fixed_Size_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_SArgument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_SArgument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Fixed_Size_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Fixed_Size_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S &
+TAO::Inout_Fixed_Size_SArgument_T<S>::arg (void)
+{
+  return *this->x_;
+}
+
+// ==============================================================
+
+template<typename S>
+TAO::Out_Fixed_Size_SArgument_T<S>::Out_Fixed_Size_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Out_Fixed_Size_SArgument_T<S>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+S &
+TAO::Out_Fixed_Size_SArgument_T<S>::arg (void)
+{
+  return this->x_;
+}
+
+// ============================================================
+
+template<typename S>
+TAO::Ret_Fixed_Size_SArgument_T<S>::Ret_Fixed_Size_SArgument_T (void)
+{
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Fixed_Size_SArgument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+void
+TAO::Ret_Fixed_Size_SArgument_T<S>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Ret_Fixed_Size_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S &
+TAO::Ret_Fixed_Size_SArgument_T<S>::arg (void)
+{
+  return *this->x_;
+}
+
+#endif /* TAO_FIXED_SIZE_ARGUMENT_T_C */
diff --git a/TAO/tao/Fixed_Size_Argument_T.h b/TAO/tao/Fixed_Size_Argument_T.h
new file mode 100644
index 00000000000..64b5380a0d5
--- /dev/null
+++ b/TAO/tao/Fixed_Size_Argument_T.h
@@ -0,0 +1,251 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Basic_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_FIXED_SIZE_ARGUMENT_T_H
+#define TAO_FIXED_SIZE_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_Fixed_Size_Argument_T
+   *
+   * @brief Template class for IN stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class In_Fixed_Size_Argument_T : public Argument
+  {
+  public:
+    In_Fixed_Size_Argument_T (S const & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    const S * x_;
+  };
+
+  /**
+   * @class Inout_Fixed_Size_Argument_T
+   *
+   * @brief Template class for INOUT stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Fixed_Size_Argument_T : public Argument
+  {
+  public:
+    Inout_Fixed_Size_Argument_T (S & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Out_Fixed_Size_Argument_T
+   *
+   * @brief Template class for OUT stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Out_Fixed_Size_Argument_T : public Argument
+  {
+  public:
+    Out_Fixed_Size_Argument_T (S & x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S & x_;
+  };
+
+  /**
+   * @class Ret_Fixed_Size_Argument_T
+   *
+   * @brief Template class for return stub value of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Ret_Fixed_Size_Argument_T : public Argument
+  {
+  public:
+    Ret_Fixed_Size_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S excp (void);
+    S retn (void);
+
+  protected:
+    S * x_;
+  };
+
+  /**
+   * @class In_Fixed_Size_SArgument_T
+   *
+   * @brief Template class for IN skeleton argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class In_Fixed_Size_SArgument_T : public Argument
+  {
+  public:
+    In_Fixed_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S & arg (void) const;
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Inout_Fixed_Size_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton arg of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Fixed_Size_SArgument_T : public Argument
+  {
+  public:
+    Inout_Fixed_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Out_Fixed_Size_SArgument_T
+   *
+   * @brief Template class for OUT skeleton argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Out_Fixed_Size_SArgument_T : public Argument
+  {
+  public:
+    Out_Fixed_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Ret_Fixed_Size_SArgument_T
+   *
+   * @brief Template class for return skeleton value of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Ret_Fixed_Size_SArgument_T : public Argument
+  {
+  public:
+    Ret_Fixed_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @struct Basic_Tag
+   *
+   * @brief Struct for fixed size IDL type arguments id tag.
+   *
+   */
+  struct TAO_Export Fixed_Size_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of fixed size IDL types.
+   *
+   */
+  template<typename T>
+  struct Fixed_Size_Arg_Traits_T
+  {
+    typedef T                                 ret_type;
+    typedef const T &                         in_type;
+    typedef T &                               inout_type;
+    typedef T &                               out_type;
+
+    typedef In_Fixed_Size_Argument_T<T>       in_arg_val;
+    typedef Inout_Fixed_Size_Argument_T<T>    inout_arg_val;
+    typedef Out_Fixed_Size_Argument_T<T>      out_arg_val;
+    typedef Ret_Fixed_Size_Argument_T<T>      stub_ret_val;
+
+    typedef In_Fixed_Size_SArgument_T<T>      in_sarg_val;
+    typedef Inout_Fixed_Size_SArgument_T<T>   inout_sarg_val;
+    typedef Out_Fixed_Size_SArgument_T<T>     out_sarg_val;
+    typedef Ret_Fixed_Size_SArgument_T<T>     skel_ret_val;
+
+    typedef Fixed_Size_Tag                    idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Fixed_Size_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Fixed_Size_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_FIXED_SIZE_ARGUMENT_T_H */
diff --git a/TAO/tao/Makefile.bor b/TAO/tao/Makefile.bor
index 55003ad884f..f310de684d9 100644
--- a/TAO/tao/Makefile.bor
+++ b/TAO/tao/Makefile.bor
@@ -5,11 +5,11 @@
 NAME = TAO
 
 DIRS = \
-   Valuetype \
-   ObjRefTemplate \
-   IORInterceptor \
+  Valuetype \
+  ObjRefTemplate \
+  IORInterceptor \
 	PortableServer \
-   Messaging \
+  Messaging \
 	DynamicAny \
 	DynamicInterface \
 	BiDir_GIOP \
@@ -29,10 +29,12 @@ OBJFILES = \
 	$(OBJDIR)\Acceptor_Registry.obj \
 	$(OBJDIR)\Adapter.obj \
 	$(OBJDIR)\Any.obj \
+	$(OBJDIR)\Argument.obj \
 	$(OBJDIR)\Asynch_Invocation.obj \
 	$(OBJDIR)\Asynch_Queued_Message.obj \
-   $(OBJDIR)\Asynch_Reply_Dispatcher_Base.obj \
+  $(OBJDIR)\Asynch_Reply_Dispatcher_Base.obj \
 	$(OBJDIR)\Base_Transport_Property.obj \
+	$(OBJDIR)\Basic_Arguments.obj \
 	$(OBJDIR)\BiDir_Adapter.obj \
 	$(OBJDIR)\Bind_Dispatcher_Guard.obj \
 	$(OBJDIR)\Block_Flushing_Strategy.obj \
@@ -53,8 +55,8 @@ OBJFILES = \
 	$(OBJDIR)\Client_Strategy_Factory.obj \
 	$(OBJDIR)\CodecFactory.obj \
 	$(OBJDIR)\CodecFactory_ORBInitializer.obj \
-   $(OBJDIR)\Codeset_Manager.obj \
-   $(OBJDIR)\Codeset_Translator_Factory.obj \
+  $(OBJDIR)\Codeset_Manager.obj \
+  $(OBJDIR)\Codeset_Translator_Factory.obj \
 	$(OBJDIR)\Collocation_Resolver.obj \
 	$(OBJDIR)\Connect_Strategy.obj \
 	$(OBJDIR)\Default_Collocation_Resolver.obj \
@@ -97,8 +99,8 @@ OBJFILES = \
 	$(OBJDIR)\GIOP_Utils.obj \
 	$(OBJDIR)\IFR_Client_Adapter.obj \
 	$(OBJDIR)\IIOPC.obj \
-   $(OBJDIR)\IOP_CodecC.obj \
-   $(OBJDIR)\IOP_IORC.obj \
+  $(OBJDIR)\IOP_CodecC.obj \
+  $(OBJDIR)\IOP_IORC.obj \
 	$(OBJDIR)\IIOP_Acceptor.obj \
 	$(OBJDIR)\IIOP_Connection_Handler.obj \
 	$(OBJDIR)\IIOP_Connector.obj \
@@ -133,8 +135,8 @@ OBJFILES = \
 	$(OBJDIR)\Managed_Types.obj \
 	$(OBJDIR)\Marshal.obj \
 	$(OBJDIR)\MCAST_Parser.obj \
-   $(OBJDIR)\Messaging_PolicyValueC.obj \
-   $(OBJDIR)\Messaging_SyncScopeC.obj \
+  $(OBJDIR)\Messaging_PolicyValueC.obj \
+  $(OBJDIR)\Messaging_SyncScopeC.obj \
 	$(OBJDIR)\Muxed_TMS.obj \
 	$(OBJDIR)\NVList.obj \
 	$(OBJDIR)\ORB.obj \
@@ -179,7 +181,7 @@ OBJFILES = \
 	$(OBJDIR)\Remote_Object_Proxy_Impl.obj \
 	$(OBJDIR)\Reply_Dispatcher.obj \
 	$(OBJDIR)\RequestInfo_Util.obj \
-        $(OBJDIR)\Request_Dispatcher.obj \
+  $(OBJDIR)\Request_Dispatcher.obj \
 	$(OBJDIR)\Resource_Factory.obj \
 	$(OBJDIR)\Resume_Handle.obj \
 	$(OBJDIR)\Sequence.obj \
@@ -188,6 +190,7 @@ OBJFILES = \
 	$(OBJDIR)\Service_Context.obj \
 	$(OBJDIR)\ServicesC.obj \
 	$(OBJDIR)\Services_Activate.obj \
+	$(OBJDIR)\Special_Basic_Arguments.obj \
 	$(OBJDIR)\StringSeqC.obj \
 	$(OBJDIR)\Stub.obj \
 	$(OBJDIR)\Stub_Factory.obj \
@@ -214,6 +217,7 @@ OBJFILES = \
 	$(OBJDIR)\TypeCodeFactory_Adapter.obj \
 	$(OBJDIR)\Typecode.obj \
 	$(OBJDIR)\Typecode_Constants.obj \
+	$(OBJDIR)\UB_String_Arguments.obj \
 	$(OBJDIR)\Valuetype_Adapter.obj \
 	$(OBJDIR)\Wait_On_Leader_Follower.obj \
 	$(OBJDIR)\Wait_On_Reactor.obj \
diff --git a/TAO/tao/Makefile.tao b/TAO/tao/Makefile.tao
index 7f02bc8a0e6..c461dc5300b 100644
--- a/TAO/tao/Makefile.tao
+++ b/TAO/tao/Makefile.tao
@@ -299,7 +299,12 @@ ORB_CORE_FILES = \
   Request_Dispatcher \
   Valuetype_Adapter \
   ObjectKey_Table \
-  Refcounted_ObjectKey
+  Refcounted_ObjectKey \
+  Argument \
+  Basic_Arguments \
+  Special_Basic_Arguments \
+  UB_String_Arguments
+
 
 DYNAMIC_ANY_FILES =
 
@@ -322,6 +327,15 @@ TEMPLATE_FILES = \
   Seq_Var_T \
   Value_VarOut_T \
   VarOut_T \
+  Basic_Argument_T \
+  BD_String_Argument_T \
+  Object_Argument_T \
+  Special_Basic_Argument_T \
+  UB_String_Argument_T \
+  Fixed_Size_Argument_T \
+  Var_Size_Argument_T \
+  Fixed_Array_Argument_T \
+  Var_Array_Argument_T \
   TAO_Singleton
 
 ifndef TAO_ROOT
diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp
index 30c2b1351b5..705535751cb 100644
--- a/TAO/tao/Object.cpp
+++ b/TAO/tao/Object.cpp
@@ -993,14 +993,20 @@ TAO_Object_Proxy_Broker * (*_TAO_collocation_Object_Proxy_Broker_Factory_functio
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
-// template class TAO_Object_Manager<CORBA::Object, CORBA::Object_var>;
 template class TAO_Pseudo_Var_T<CORBA::Object>;
 template class TAO_Pseudo_Out_T<CORBA::Object, CORBA::Object_var>;
+template class TAO::Arg_Traits<CORBA::Object>;
+template class TAO::Object_Arg_Traits_T<CORBA::Object_ptr,
+                                        CORBA::Object_var,
+                                        CORBA::Object_out>;
 
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 
-// #pragma instantiate TAO_Object_Manager<CORBA::Object, CORBA::Object_var>
 #pragma instantiate TAO_Pseudo_Var_T<CORBA::Object>
 #pragma instantiate TAO_Pseudo_Out_T<CORBA::Object, CORBA::Object_var>
+#pragma instantiate TAO::Arg_Traits<CORBA::Object>
+#pragma instantiate TAO::Object_Arg_Traits_T<CORBA::Object_ptr, \
+                                             CORBA::Object_var, \
+                                             CORBA::Object_out>;
 
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h
index b135af36084..59aef410cf4 100644
--- a/TAO/tao/Object.h
+++ b/TAO/tao/Object.h
@@ -31,6 +31,8 @@
 #include "tao/Pseudo_VarOut_T.h"
 #include "ace/Synch.h"
 #include "tao/IOP_IORC.h"
+#include "tao/Object_Argument_T.h"
+#include "tao/Arg_Traits_T.h"
 
 
 class TAO_Stub;
@@ -381,6 +383,18 @@ namespace CORBA
   };
 }   // End CORBA namespace.
 
+/// Used in generated code if CORBA::Object is an argument or return type.
+namespace TAO
+{
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Object>
+    : public Object_Arg_Traits_T<CORBA::Object_ptr, 
+                                 CORBA::Object_var, 
+                                 CORBA::Object_out>
+  {
+  };
+};
+
 /// This function pointer is set only when the Portable server
 /// library is present.
 extern TAO_Export TAO_Object_Proxy_Broker * (*_TAO_collocation_Object_Proxy_Broker_Factory_function_pointer) (
diff --git a/TAO/tao/Object_Argument_T.cpp b/TAO/tao/Object_Argument_T.cpp
new file mode 100644
index 00000000000..516de4d05b1
--- /dev/null
+++ b/TAO/tao/Object_Argument_T.cpp
@@ -0,0 +1,282 @@
+// $Id$
+
+#ifndef TAO_OBJECT_ARGUMENT_T_C
+#define TAO_OBJECT_ARGUMENT_T_C
+
+#include "tao/Object_Argument_T.h"
+
+ACE_RCSID (tao,
+           Object_Argument_T,
+           "$Id$")
+
+template<typename S_ptr>
+TAO::In_Object_Argument_T<S_ptr>::In_Object_Argument_T (S_ptr x)
+  : x_ (x)
+{}
+
+template<typename S_ptr>
+CORBA::Boolean
+TAO::In_Object_Argument_T<S_ptr>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S_ptr>
+void
+TAO::In_Object_Argument_T<S_ptr>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S_ptr>
+CORBA::Boolean
+TAO::In_Object_Argument_T<S_ptr>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S_ptr>
+TAO::Inout_Object_Argument_T<S_ptr>::Inout_Object_Argument_T (S_ptr & x)
+  : x_ (x)
+{}
+
+template<typename S_ptr>
+CORBA::Boolean
+TAO::Inout_Object_Argument_T<S_ptr>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S_ptr>
+CORBA::Boolean
+TAO::Inout_Object_Argument_T<S_ptr>::demarshal (TAO_InputCDR & cdr)
+{
+  CORBA::release (this->x_);
+  return cdr >> this->x_;
+}
+
+template<typename S_ptr>
+void
+TAO::Inout_Object_Argument_T<S_ptr>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S_ptr>
+CORBA::Boolean
+TAO::Inout_Object_Argument_T<S_ptr>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S_ptr, typename S_out>
+TAO::Out_Object_Argument_T<S_ptr,S_out>::Out_Object_Argument_T (S_out & x)
+  : x_ (x.ptr ())
+{}
+
+template<typename S_ptr, typename S_out>
+CORBA::Boolean
+TAO::Out_Object_Argument_T<S_ptr,S_out>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+// ============================================================
+
+template<typename S_ptr, typename S_var>
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::Ret_Object_Argument_T (void)
+{
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+void
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_;
+}
+
+template<typename S_ptr, typename S_var>
+S_ptr
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S_ptr, typename S_var>
+S_ptr
+TAO::Ret_Object_Argument_T<S_ptr,S_var>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S_ptr, typename S_var>
+TAO::In_Object_SArgument_T<S_ptr,S_var>::In_Object_SArgument_T (void)
+{}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::In_Object_SArgument_T<S_ptr,S_var>::demarshal (TAO_InputCDR &cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+void
+TAO::In_Object_SArgument_T<S_ptr,S_var>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_.in ();
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::In_Object_SArgument_T<S_ptr,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+S_ptr
+TAO::In_Object_SArgument_T<S_ptr,S_var>::arg (void) const
+{
+  return this->x_.in ();
+}
+
+// ===========================================================
+
+template<typename S_ptr, typename S_var>
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::Inout_Object_SArgument_T (void)
+{}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+void
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_.in ();
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+S_ptr&
+TAO::Inout_Object_SArgument_T<S_ptr,S_var>::arg (void)
+{
+  return this->x_.inout ();
+}
+
+// ==============================================================
+
+template<typename S_ptr, typename S_var, typename S_out>
+TAO::Out_Object_SArgument_T<S_ptr,S_var,S_out>::Out_Object_SArgument_T (
+    void
+  )
+{}
+
+template<typename S_ptr, typename S_var, typename S_out>
+CORBA::Boolean
+TAO::Out_Object_SArgument_T<S_ptr,S_var,S_out>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S_ptr, typename S_var, typename S_out>
+S_out
+TAO::Out_Object_SArgument_T<S_ptr,S_var,S_out>::arg (void)
+{
+  return this->x_.out ();
+}
+
+// ============================================================
+
+template<typename S_ptr, typename S_var>
+TAO::Ret_Object_SArgument_T<S_ptr,S_var>::Ret_Object_SArgument_T (void)
+{
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Ret_Object_SArgument_T<S_ptr,S_var>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S_ptr, typename S_var>
+void
+TAO::Ret_Object_SArgument_T<S_ptr,S_var>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S_ptr, typename S_var>
+CORBA::Boolean
+TAO::Ret_Object_SArgument_T<S_ptr,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S_ptr, typename S_var>
+S_ptr &
+TAO::Ret_Object_SArgument_T<S_ptr,S_var>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_OBJECT_ARGUMENT_T_C */
diff --git a/TAO/tao/Object_Argument_T.h b/TAO/tao/Object_Argument_T.h
new file mode 100644
index 00000000000..688109157b8
--- /dev/null
+++ b/TAO/tao/Object_Argument_T.h
@@ -0,0 +1,258 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Object_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_OBJECT_ARGUMENT_T_H
+#define TAO_OBJECT_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+// This set of classes is also used by valuetype arguments. If the
+// specialization is done using S * for the parameter, the semantics
+// are the same as for interfaces, so there's no need for another
+// set of classes.
+
+namespace TAO
+{
+  /**
+   * @class In_Object_Argument_T
+   *
+   * @brief Template class for IN object argument.
+   *
+   */
+  template<typename S_ptr>
+  class In_Object_Argument_T : public Argument
+  {
+  public:
+    In_Object_Argument_T (S_ptr x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S_ptr x_;
+  };
+
+  /**
+   * @class Inout_Object_Argument_T
+   *
+   * @brief Template class for INOUT object argument.
+   *
+   */
+  template<typename S_ptr>
+  class Inout_Object_Argument_T : public Argument
+  {
+  public:
+    Inout_Object_Argument_T (S_ptr & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    mutable S_ptr & x_;
+  };
+
+  /**
+   * @class Out_Object_Argument_T
+   *
+   * @brief Template class for INOUT object argument.
+   *
+   */
+  template<typename S_ptr, typename S_out>
+  class Out_Object_Argument_T : public Argument
+  {
+  public:
+    Out_Object_Argument_T (S_out & x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S_ptr & x_;
+  };
+
+  /**
+   * @class Ret_Object_Argument_T
+   *
+   * @brief Template class for return stub value of object argument.
+   *
+   */
+  template<typename S_ptr, typename S_var>
+  class Ret_Object_Argument_T : public Argument
+  {
+  public:
+    Ret_Object_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_ptr excp (void);
+    S_ptr retn (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class In_Object_SArgument_T
+   *
+   * @brief Template class for IN skeleton object argument.
+   *
+   */
+  template<typename S_ptr, typename S_var>
+  class In_Object_SArgument_T : public Argument
+  {
+  public:
+    In_Object_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_ptr arg (void) const;
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Inout_Object_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton object argument.
+   *
+   */
+  template<typename S_ptr, typename S_var>
+  class Inout_Object_SArgument_T : public Argument
+  {
+  public:
+    Inout_Object_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_ptr & arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Out_Object_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton object argument.
+   *
+   */
+  template<typename S_ptr, typename S_var, typename S_out>
+  class Out_Object_SArgument_T : public Argument
+  {
+  public:
+    Out_Object_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S_out arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_Object_SArgument_T
+   *
+   * @brief Template class for return skeleton value of object.
+   *
+   */
+  template<typename S_ptr, typename S_var>
+  class Ret_Object_SArgument_T : public Argument
+  {
+  public:
+    Ret_Object_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_ptr & arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct Object_Tag
+   *
+   * @brief Struct for object arguments id tag.
+   *
+   */
+  struct TAO_Export Object_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of objects.
+   *
+   */
+
+  template<typename T_ptr, typename T_var, typename T_out>
+  struct Object_Arg_Traits_T
+  {
+    typedef T_ptr                                         ret_type;
+    typedef T_ptr                                         in_type;
+    typedef T_ptr &                                       inout_type;
+    typedef T_out                                         out_type;
+
+    typedef In_Object_Argument_T<T_ptr>                   in_arg_val;
+    typedef Inout_Object_Argument_T<T_ptr>                inout_arg_val;
+    typedef Out_Object_Argument_T<T_ptr,T_out>            out_arg_val;
+    typedef Ret_Object_Argument_T<T_ptr,T_var>            stub_ret_val;
+
+    typedef In_Object_SArgument_T<T_ptr,T_var>            in_sarg_val;
+    typedef Inout_Object_SArgument_T<T_ptr,T_var>         inout_sarg_val;
+    typedef Out_Object_SArgument_T<T_ptr,T_var,T_out>     out_sarg_val;
+    typedef Ret_Object_SArgument_T<T_ptr,T_var>           skel_ret_val;
+
+    typedef Object_Tag                                    idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Object_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Object_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_OBJECT_ARGUMENT_T_H */
+
diff --git a/TAO/tao/Objref_VarOut_T.cpp b/TAO/tao/Objref_VarOut_T.cpp
index 4c95b48fa4d..3701176ef17 100644
--- a/TAO/tao/Objref_VarOut_T.cpp
+++ b/TAO/tao/Objref_VarOut_T.cpp
@@ -15,30 +15,66 @@ ACE_RCSID (tao,
            Objref_VarOut_T,
            "$Id$")
 
+// @@@ (JP) This needs to be here temporarily until we regenerate the
+// hand-crafted files.
+
+template<typename T>
+T *
+TAO::Objref_Traits<T>::tao_duplicate (T * p)
+{
+  return T::_duplicate (p);
+}
+
+template<typename T>
+void
+TAO::Objref_Traits<T>::tao_release (T * p)
+{
+  CORBA::release (p);
+}
+
+template<typename T>
+T *
+TAO::Objref_Traits<T>::tao_nil (void)
+{
+  return T::_nil ();
+}
+
+template<typename T>
+CORBA::Boolean
+TAO::Objref_Traits<T>::tao_marshal (T * p,
+                                    TAO_OutputCDR & cdr)
+{
+  return p->marshal (cdr);
+}
+
+// =================================================================
+
 template <typename T, typename T_life>
 TAO_Objref_Var_T<T, T_life>::TAO_Objref_Var_T (void)
-  : ptr_ (T_life::tao_nil ())
+  : ptr_ (TAO::Objref_Traits<T>::tao_nil ())
 {
 }
 
 template <typename T, typename T_life>
-TAO_Objref_Var_T<T, T_life>::TAO_Objref_Var_T (const TAO_Objref_Var_T<T, T_life> & p)
+TAO_Objref_Var_T<T, T_life>::TAO_Objref_Var_T (
+    const TAO_Objref_Var_T<T, T_life> & p
+  )
   : TAO_Base_var (),
-    ptr_ (T_life::tao_duplicate (p.ptr ()))
+    ptr_ (TAO::Objref_Traits<T>::tao_duplicate (p.ptr ()))
 {
 }
 
 template <typename T, typename T_life>
 TAO_Objref_Var_T<T, T_life>::~TAO_Objref_Var_T (void)
 {
-  T_life::tao_release (this->ptr_);
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
 }
 
 template <typename T, typename T_life>
 TAO_Objref_Var_T<T, T_life> &
 TAO_Objref_Var_T<T, T_life>::operator= (T * p)
 {
-  T_life::tao_release (this->ptr_);
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
@@ -51,8 +87,8 @@ TAO_Objref_Var_T<T, T_life>::operator= (
 {
   if (this != &p)
     {
-      T_life::tao_release (this->ptr_);
-      this->ptr_ = T_life::tao_duplicate (p.ptr ());
+      TAO::Objref_Traits<T>::tao_release (this->ptr_);
+      this->ptr_ = TAO::Objref_Traits<T>::tao_duplicate (p.ptr ());
     }
 
   return *this;
@@ -95,8 +131,8 @@ template <typename T, typename T_life>
 T *&
 TAO_Objref_Var_T<T, T_life>::out (void)
 {
-  T_life::tao_release (this->ptr_);
-  this->ptr_ = T_life::tao_nil ();
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
+  this->ptr_ = TAO::Objref_Traits<T>::tao_nil ();
   return this->ptr_;
 }
 
@@ -105,7 +141,7 @@ T *
 TAO_Objref_Var_T<T, T_life>::_retn (void)
 {
   T * val = this->ptr_;
-  this->ptr_ = T_life::tao_nil ();
+  this->ptr_ = TAO::Objref_Traits<T>::tao_nil ();
   return val;
 }
 
@@ -120,14 +156,14 @@ template <typename T, typename T_life>
 void
 TAO_Objref_Var_T<T, T_life>::free (void)
 {
-  T_life::tao_release (this->ptr_);
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
 }
 
 template <typename T, typename T_life>
 void
 TAO_Objref_Var_T<T, T_life>::reset (T * p)
 {
-  T_life::tao_release (this->ptr_);
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
   this->ptr_ = p;
 }
 
@@ -146,8 +182,8 @@ TAO_Objref_Out_T<T, T_life>::TAO_Objref_Out_T (
   )
   : ptr_ (p.out ())
 {
-  T_life::tao_release (this->ptr_);
-  this->ptr_ = T_life::tao_nil ();
+  TAO::Objref_Traits<T>::tao_release (this->ptr_);
+  this->ptr_ = TAO::Objref_Traits<T>::tao_nil ();
 }
 
 template <typename T, typename T_life>
@@ -174,7 +210,7 @@ TAO_Objref_Out_T<T, T_life>::operator= (
     const TAO_Objref_Var_T<T, T_life> & p
   )
 {
-  this->ptr_ = T_life::tao_duplicate (p.ptr ());
+  this->ptr_ = TAO::Objref_Traits<T>::tao_duplicate (p.ptr ());
   return *this;
 }
 
diff --git a/TAO/tao/Objref_VarOut_T.h b/TAO/tao/Objref_VarOut_T.h
index 608672d2d8c..43b923e65f9 100644
--- a/TAO/tao/Objref_VarOut_T.h
+++ b/TAO/tao/Objref_VarOut_T.h
@@ -24,13 +24,31 @@
 
 #include "ace/CORBA_macros.h"
 
+namespace TAO
+{
+  /**
+   * struct Objref_Traits
+   *
+   * @brief Specialized for each interface in generated code.
+   *
+   */
+  template<typename T>
+  struct Objref_Traits
+  {
+    static T * tao_duplicate (T *);
+    static void tao_release (T *);
+    static T * tao_nil (void);
+    static CORBA::Boolean tao_marshal (T *,
+                                       TAO_OutputCDR &);
+  };
+};
+
 /**
  * @class TAO_Objref_Var_T
  *
  * @brief Parametrized implementation of _var class for object references.
  *
  */
-
 template <typename T, typename T_life>
 class TAO_Objref_Var_T : private TAO_Base_var
 {
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index 2d6f6fca63d..92276fe4be8 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -487,6 +487,36 @@ TAO_NAMESPACE_DEFINE (
   )
 TAO_NAMESPACE_END
 
+// =======================================================
+// Hand-crafted
+
+CORBA::Policy_ptr
+TAO::Objref_Traits<CORBA::Policy>::tao_duplicate (CORBA::Policy_ptr p)
+{
+  return CORBA::Policy::_duplicate (p);
+}
+
+void
+TAO::Objref_Traits<CORBA::Policy>::tao_release (CORBA::Policy_ptr p)
+{
+  CORBA::release (p);
+}
+
+CORBA::Policy_ptr
+TAO::Objref_Traits<CORBA::Policy>::tao_nil (void)
+{
+  return CORBA::Policy::_nil ();
+}
+
+CORBA::Boolean
+TAO::Objref_Traits<CORBA::Policy>::tao_marshal (CORBA::Policy_ptr p,
+                                                TAO_OutputCDR & cdr)
+{
+  return p->marshal (cdr);
+}
+
+// =================================================================
+
 // TAO_IDL - Generated from
 // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_cs.cpp:61
 
diff --git a/TAO/tao/Policy_ForwardC.cpp b/TAO/tao/Policy_ForwardC.cpp
index c864253d151..6c4487095d7 100644
--- a/TAO/tao/Policy_ForwardC.cpp
+++ b/TAO/tao/Policy_ForwardC.cpp
@@ -173,12 +173,12 @@ template class TAO_Unbounded_Object_Sequence<CORBA::Policy,
           > \
       >
 
-#pragma instantiate TAO_Unbounded_Object_Sequence<CORBA::Policy,
+# pragma instantiate TAO_Unbounded_Object_Sequence<CORBA::Policy,
                                                   TAO_Objref_Var_T<CORBA::Policy, CORBA::tao_Policy_life>,
                                                   CORBA::tao_Policy_life,
                                                   CORBA::tao_Policy_cast>
 
-#pragms instantiate TAO_Seq_Var_Base_T<CORBA::PolicyList,
+# pragma instantiate TAO_Seq_Var_Base_T<CORBA::PolicyList,
                                        TAO_Object_Manager<CORBA::Policy,
                                                           TAO_Objref_Var_T<CORBA::Policy,
                                                                            CORBA::tao_Policy_life>,
diff --git a/TAO/tao/Policy_ForwardC.h b/TAO/tao/Policy_ForwardC.h
index 5b1cb921925..01725f37403 100644
--- a/TAO/tao/Policy_ForwardC.h
+++ b/TAO/tao/Policy_ForwardC.h
@@ -240,6 +240,25 @@ TAO_NAMESPACE  CORBA
 }
 TAO_NAMESPACE_CLOSE // module CORBA
 
+// =====================================================
+// Hand-crafted
+
+namespace TAO
+{
+  ACE_TEMPLATE_SPECIALIZATION
+  struct TAO_Export Objref_Traits<CORBA::Policy>
+  {
+    static CORBA::Policy_ptr tao_duplicate (CORBA::Policy_ptr);
+    static void tao_release (CORBA::Policy_ptr);
+    static CORBA::Policy_ptr tao_nil (void);
+    static CORBA::Boolean tao_marshal (CORBA::Policy_ptr,
+                                       TAO_OutputCDR &);
+  };
+}
+
+
+// ==========================================================
+
 // TAO_IDL - Generated from
 // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface_fwd/any_op_ch.cpp:65
 
diff --git a/TAO/tao/Sequence_T.cpp b/TAO/tao/Sequence_T.cpp
index 9a3aa7adc84..261fd3c6d3c 100644
--- a/TAO/tao/Sequence_T.cpp
+++ b/TAO/tao/Sequence_T.cpp
@@ -401,8 +401,8 @@ TAO_Object_Manager<T,T_var,T_life>::operator= (
 
   if (this->release_)
     {
-      T_life::tao_release (*this->ptr_);
-      *this->ptr_ = T_life::tao_duplicate (*rhs.ptr_);
+      TAO::Objref_Traits<T>::tao_release (*this->ptr_);
+      *this->ptr_ = TAO::Objref_Traits<T>::tao_duplicate (*rhs.ptr_);
     }
   else
     {
@@ -422,7 +422,7 @@ TAO_Object_Manager<T,T_var,T_life>::operator= (T * p)
       // that of a var variable.  Therefore we will not duplicate the
       // user provided pointer before assigning it to the internal
       // variable.
-      T_life::tao_release (*this->ptr_);
+      TAO::Objref_Traits<T>::tao_release (*this->ptr_);
       *this->ptr_ = p;
     }
   else
@@ -443,8 +443,8 @@ TAO_Object_Manager<T,T_var,T_life>::operator= (const T_var & p)
       // that of a var variable.  Therefore we duplicate p's
       // pointer before assigning it to the internal
       // variable.
-      T_life::tao_release (*this->ptr_);
-      *this->ptr_ = T_life::tao_duplicate (p.in ());
+      TAO::Objref_Traits<T>::tao_release (*this->ptr_);
+      *this->ptr_ = TAO::Objref_Traits<T>::tao_duplicate (p.in ());
     }
   else
     {
@@ -458,8 +458,8 @@ template <typename T, typename T_var, typename T_life>
 T *&
 TAO_Object_Manager<T,T_var,T_life>::out (void)
 {
-  T_life::tao_release (*this->ptr_);
-  *this->ptr_ = T_life::tao_nil ();
+  TAO::Objref_Traits<T>::tao_release (*this->ptr_);
+  *this->ptr_ = TAO::Objref_Traits<T>::tao_nil ();
   return *this->ptr_;
 }
 
@@ -468,7 +468,7 @@ T *
 TAO_Object_Manager<T,T_var,T_life>::_retn (void)
 {
   T *temp = *this->ptr_;
-  *this->ptr_ = T_life::tao_nil ();
+  *this->ptr_ = TAO::Objref_Traits<T>::tao_nil ();
   return temp;
 }
 
@@ -577,7 +577,7 @@ TAO_Unbounded_Object_Sequence (
 
       for (CORBA::ULong i = 0; i < rhs.length_; ++i)
         {
-          tmp1[i] = T_life::tao_duplicate (tmp2[i]);
+          tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]);
         }
 
       this->buffer_ = tmp1;
@@ -613,8 +613,8 @@ operator= (const TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &rhs)
 
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         {
-          T_life::tao_release (tmp[i]);
-          tmp[i] = T_life::tao_nil ();
+          TAO::Objref_Traits<T>::tao_release (tmp[i]);
+          tmp[i] = TAO::Objref_Traits<T>::tao_nil ();
         }
 
       if (this->maximum_ < rhs.maximum_)
@@ -648,7 +648,7 @@ operator= (const TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast> &rhs)
 
   for (CORBA::ULong i = 0; i < rhs.length_; ++i)
     {
-      tmp1[i] = T_life::tao_duplicate (tmp2[i]);
+      tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]);
     }
 
   return *this;
@@ -667,7 +667,7 @@ TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::allocbuf (
 
   for (CORBA::ULong i = 0; i < nelems; ++i)
     {
-      buf[i] = T_life::tao_nil ();
+      buf[i] = TAO::Objref_Traits<T>::tao_nil ();
     }
 
   return buf;
@@ -719,7 +719,7 @@ TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_allocate_buffer (
         // the old instances.
         if (!this->release_)
           {
-            tmp[i] = T_life::tao_duplicate (old[i]);
+            tmp[i] = TAO::Objref_Traits<T>::tao_duplicate (old[i]);
           }
         else
           {
@@ -751,8 +751,8 @@ TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_deallocate_buffer (
 
   for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
-      T_life::tao_release (tmp[i]);
-      tmp[i] = T_life::tao_nil ();
+      TAO::Objref_Traits<T>::tao_release (tmp[i]);
+      tmp[i] = TAO::Objref_Traits<T>::tao_nil ();
     }
 
   TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::freebuf (tmp);
@@ -771,37 +771,11 @@ TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_shrink_buffer (
 
   for (CORBA::ULong i = nl; i < ol; ++i)
     {
-      T_life::tao_release (tmp[i]);
-      tmp[i] = T_life::tao_nil ();
+      TAO::Objref_Traits<T>::tao_release (tmp[i]);
+      tmp[i] = TAO::Objref_Traits<T>::tao_nil ();
     }
 }
 
-template <typename T, typename T_var, typename T_life, typename T_cast> 
-void
-TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_downcast (
-    void * target,
-    CORBA::Object_ptr src
-    ACE_ENV_ARG_DECL
-  )
-{
-  T ** tmp = ACE_static_cast (T **, 
-                              target);
-
-  *tmp = T_cast::tao_narrow (src 
-                             ACE_ENV_ARG_PARAMETER);
-
-  ACE_CHECK;
-}
-
-template <typename T, typename T_var, typename T_life, typename T_cast> 
-CORBA::Object_ptr
-TAO_Unbounded_Object_Sequence<T,T_var,T_life,T_cast>::_upcast (
-    void * src
-  ) const
-{
-  return T_cast::tao_upcast (src);
-}
-
 // *************************************************************
 // Operations for class TAO_Bounded_Object_Sequence
 // *************************************************************
@@ -842,7 +816,7 @@ TAO_Bounded_Object_Sequence (
 
       for (CORBA::ULong i = 0; i < rhs.length_; ++i)
         {
-          tmp1[i] = T_life::tao_duplicate (tmp2[i]);
+          tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]);
         }
 
       this->buffer_ = tmp1;
@@ -875,8 +849,8 @@ TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::operator= (
 
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         {
-          T_life::tao_release (tmp[i]);
-          tmp[i] = T_life::tao_nil ();
+          TAO::Objref_Traits<T>::tao_release (tmp[i]);
+          tmp[i] = TAO::Objref_Traits<T>::tao_nil ();
         }
       // No need to reallocate the buffer since it is always of size
       // MAX
@@ -905,7 +879,7 @@ TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::operator= (
 
   for (CORBA::ULong i=0; i < rhs.length_; ++i)
     {
-      tmp1[i] = T_life::tao_duplicate (tmp2[i]);
+      tmp1[i] = TAO::Objref_Traits<T>::tao_duplicate (tmp2[i]);
     }
 
   return *this;
@@ -928,7 +902,7 @@ TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::allocbuf (
 
   for (CORBA::ULong i = 0; i < MAX; ++i)
     {
-      buf[i] = T_life::tao_nil ();
+      buf[i] = TAO::Objref_Traits<T>::tao_nil ();
     }
 
   return buf;
@@ -947,10 +921,10 @@ TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::freebuf (T ** buffer)
   // complaint and call CORBA::release() on each one.
   for (CORBA::ULong i = 0; i < MAX; ++i)
     {
-      if (buffer[i] != T_life::tao_nil ())
+      if (buffer[i] != TAO::Objref_Traits<T>::tao_nil ())
         {
-          T_life::tao_release (buffer[i]);
-          buffer[i] = T_life::tao_nil ();
+          TAO::Objref_Traits<T>::tao_release (buffer[i]);
+          buffer[i] = TAO::Objref_Traits<T>::tao_nil ();
         }
     }
 
@@ -1009,45 +983,11 @@ TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_shrink_buffer (
 
   for (CORBA::ULong i = nl; i < ol; ++i)
     {
-      T_life::tao_release (tmp[i]);
-      tmp[i] = T_life::tao_nil ();
+      TAO::Objref_Traits<T>::tao_release (tmp[i]);
+      tmp[i] = TAO::Objref_Traits<T>::tao_nil ();
     }
 }
 
-template <typename T, 
-          typename T_var, 
-          typename T_life, 
-          typename T_cast, 
-          size_t MAX>
-void
-TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_downcast (
-    void * target,
-    CORBA::Object_ptr src
-    ACE_ENV_ARG_DECL
-  )
-{
-  T ** tmp = ACE_static_cast (T **, 
-                              target);
-
-  *tmp = T_cast::tao_narrow (src 
-                             ACE_ENV_ARG_PARAMETER);
-
-  ACE_CHECK;
-}
-
-template <typename T, 
-          typename T_var, 
-          typename T_life, 
-          typename T_cast, 
-          size_t MAX> 
-CORBA::Object_ptr
-TAO_Bounded_Object_Sequence<T,T_var,T_life,T_cast,MAX>::_upcast (
-    void * src
-  ) const
-{
-  return T_cast::tao_upcast (src);
-}
-
 // *************************************************************
 // Operations for class TAO_Unbounded_Pseudo_Sequence
 // *************************************************************
diff --git a/TAO/tao/Sequence_T.h b/TAO/tao/Sequence_T.h
index 2506c8807f4..4d934fe824f 100644
--- a/TAO/tao/Sequence_T.h
+++ b/TAO/tao/Sequence_T.h
@@ -21,6 +21,8 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+#include "tao/Objref_VarOut_T.h"
+
 /**
  * @class TAO_Unbounded_Sequence
  *
@@ -255,8 +257,6 @@ template<typename T,
   class TAO_Bounded_Object_Sequence;
 template<size_t MAX> class TAO_Bounded_String_Sequence;
 
-// *************************************************************
-
   /**
    * @class TAO_Object_Manager
    *
@@ -585,10 +585,6 @@ public:
   virtual void _deallocate_buffer (void);
   virtual void _shrink_buffer (CORBA::ULong new_length,
                                CORBA::ULong old_length);
-  virtual void _downcast (void * target,
-                          CORBA::Object_ptr src
-                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-  virtual CORBA::Object_ptr _upcast (void * src) const;
 };
 
 // *************************************************************
@@ -656,10 +652,6 @@ public:
   virtual void _deallocate_buffer (void);
   virtual void _shrink_buffer (CORBA::ULong new_length,
                                CORBA::ULong old_length);
-  virtual void _downcast (void * target,
-                          CORBA::Object_ptr src
-                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-  virtual CORBA::Object_ptr _upcast (void * src) const;
 };
 
 // *************************************************************
diff --git a/TAO/tao/Sequence_T.i b/TAO/tao/Sequence_T.i
index 62febe426fb..1e4a223985c 100644
--- a/TAO/tao/Sequence_T.i
+++ b/TAO/tao/Sequence_T.i
@@ -159,7 +159,7 @@ template <typename T, typename T_var, typename T_life>
 ACE_INLINE
 TAO_Object_Manager<T,T_var,T_life>::operator const T_var () const
 {
-  return T_life::tao_duplicate (*this->ptr_);
+  return TAO::Objref_Traits<T>::tao_duplicate (*this->ptr_);
 }
 
 template <typename T, typename T_var, typename T_life>
diff --git a/TAO/tao/Special_Basic_Argument_T.cpp b/TAO/tao/Special_Basic_Argument_T.cpp
new file mode 100644
index 00000000000..44b11743bbc
--- /dev/null
+++ b/TAO/tao/Special_Basic_Argument_T.cpp
@@ -0,0 +1,303 @@
+// $Id$
+
+#ifndef TAO_BASIC_ARGUMENT_T_C
+#define TAO_BASIC_ARGUMENT_T_C
+
+#include "tao/Special_Basic_Argument_T.h"
+
+ACE_RCSID (tao,
+           Special_Basic_Argument_T,
+           "$Id$")
+
+template<typename S, typename to_S, typename from_S>
+TAO::In_Special_Basic_Argument_T<S,to_S,from_S>::In_Special_Basic_Argument_T (
+    const S & x
+  )
+  : x_ (x)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::In_Special_Basic_Argument_T<S,to_S,from_S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << from_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::In_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::In_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+// ===========================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Inout_Special_Basic_Argument_T<S,to_S,from_S>::
+Inout_Special_Basic_Argument_T (S & x)
+  : x_ (x)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_Argument_T<S,to_S,from_S>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_Argument_T<S,to_S,from_S>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::Inout_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+// ==============================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Out_Special_Basic_Argument_T<S,to_S,from_S>::
+Out_Special_Basic_Argument_T (S & x)
+  : x_ (x)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Out_Special_Basic_Argument_T<S,to_S,from_S>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_);
+}
+
+// ============================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::
+Ret_Special_Basic_Argument_T (void)
+{
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= this->x_;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+S
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::excp (void)
+{
+  return this->x_;
+}
+
+template<typename S, typename to_S, typename from_S>
+S
+TAO::Ret_Special_Basic_Argument_T<S,to_S,from_S>::retn (void)
+{
+  return this->x_;
+}
+
+// ============================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::In_Special_Basic_SArgument_T<S,to_S,from_S>::
+In_Special_Basic_SArgument_T (void)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::In_Special_Basic_SArgument_T<S,to_S,from_S>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::In_Special_Basic_SArgument_T<S,to_S,from_S>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::In_Special_Basic_SArgument_T<S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+S
+TAO::In_Special_Basic_SArgument_T<S,to_S,from_S>::arg (void) const
+{
+  return this->x_;
+}
+
+// ===========================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Inout_Special_Basic_SArgument_T<S,to_S,from_S>::
+Inout_Special_Basic_SArgument_T (void)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_SArgument_T<S,to_S,from_S>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_SArgument_T<S,to_S,from_S>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  return cdr >> to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::Inout_Special_Basic_SArgument_T<S,to_S,from_S>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= from_S (this->x_);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Inout_Special_Basic_SArgument_T <S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+S &
+TAO::Inout_Special_Basic_SArgument_T<S,to_S,from_S>::arg (void)
+{
+  return this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Out_Special_Basic_SArgument_T<S,to_S,from_S>::
+Out_Special_Basic_SArgument_T (void)
+{}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Out_Special_Basic_SArgument_T<S,to_S,from_S>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+S &
+TAO::Out_Special_Basic_SArgument_T<S,to_S,from_S>::arg (void)
+{
+  return this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename to_S, typename from_S>
+TAO::Ret_Special_Basic_SArgument_T<S,to_S,from_S>::
+Ret_Special_Basic_SArgument_T (void)
+{
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Ret_Special_Basic_SArgument_T<S,to_S,from_S>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << from_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+void
+TAO::Ret_Special_Basic_SArgument_T<S,to_S,from_S>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= this->x_;
+}
+
+template<typename S, typename to_S, typename from_S>
+CORBA::Boolean
+TAO::Ret_Special_Basic_SArgument_T<S,to_S,from_S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= to_S (this->x_);
+}
+
+template<typename S, typename to_S, typename from_S>
+S &
+TAO::Ret_Special_Basic_SArgument_T<S,to_S,from_S>::arg (void)
+{
+  return this->x_;
+}
+
+#endif /* TAO_BASIC_ARGUMENT_T_C */
+
diff --git a/TAO/tao/Special_Basic_Argument_T.h b/TAO/tao/Special_Basic_Argument_T.h
new file mode 100644
index 00000000000..3e3214588f6
--- /dev/null
+++ b/TAO/tao/Special_Basic_Argument_T.h
@@ -0,0 +1,252 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Special_Basic_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_SPECIAL_BASIC_ARGUMENT_T_H
+#define TAO_SPECIAL_BASIC_ARGUMENT_T_H
+
+#include "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Argument.h"
+
+namespace TAO
+{
+  /**
+   * @class In_Special_Basic_Argument_T
+   *
+   * @brief Template class for IN stub argument of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export In_Special_Basic_Argument_T : public Argument
+  {
+  public:
+    In_Special_Basic_Argument_T (S const & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S const & x_;
+  };
+
+  /**
+   * @class Inout_Special_Basic_Argument_T
+   *
+   * @brief Template class for INOUT stub argument of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Inout_Special_Basic_Argument_T : public Argument
+  {
+  public:
+    Inout_Special_Basic_Argument_T (S & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    mutable S & x_;
+  };
+
+  /**
+   * @class Out_Special_Basic_Argument_T
+   *
+   * @brief Template class for OUT stub argument of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Out_Special_Basic_Argument_T : public Argument
+  {
+  public:
+    Out_Special_Basic_Argument_T (S & x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S & x_;
+  };
+
+  /**
+   * @class Ret_Basic_Argument_T
+   *
+   * @brief Template class for return stub value of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Ret_Special_Basic_Argument_T : public Argument
+  {
+  public:
+    Ret_Special_Basic_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S excp (void);
+    S retn (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class In_Special_Basic_SArgument_T
+   *
+   * @brief Template class for IN skeleton argument of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export In_Special_Basic_SArgument_T : public Argument
+  {
+  public:
+    In_Special_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S arg (void) const;
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Inout_Special_Basic_SArgument_T
+   *
+   * @brief Template class for INOUT (w)char/boolean/octet skeleton argument.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Inout_Special_Basic_SArgument_T : public Argument
+  {
+  public:
+    Inout_Special_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Out_Special_Basic_SArgument_T
+   *
+   * @brief Template class for OUT skeleton argument of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Out_Special_Basic_SArgument_T : public Argument
+  {
+  public:
+    Out_Special_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Ret_Basic_SArgument_T
+   *
+   * @brief Template class for return skeleton value of (w)char/boolean/octet.
+   *
+   */
+  template<typename S, typename to_S, typename from_S>
+  class TAO_Export Ret_Special_Basic_SArgument_T : public Argument
+  {
+  public:
+    Ret_Special_Basic_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @struct Special_Basic_Tag
+   *
+   * @brief Struct for basic IDL type arguments id tag.
+   *
+   */
+  struct TAO_Export Special_Basic_Tag {};
+
+  /**
+   * @struct Special_Basic_Traits_T
+   *
+   * @brief Template class for argument traits of (w)char/boolean/octet.
+   *
+   */
+  template<typename T, typename to_T, typename from_T>
+  struct TAO_Export Special_Basic_Arg_Traits_T
+  {
+    typedef T                                               ret_type;
+    typedef T                                               in_type;
+    typedef T &                                             inout_type;
+    typedef T &                                             out_type;
+
+    typedef In_Special_Basic_Argument_T<T,to_T,from_T>      in_arg_val;
+    typedef Inout_Special_Basic_Argument_T<T,to_T,from_T>   inout_arg_val;
+    typedef Out_Special_Basic_Argument_T<T,to_T,from_T>     out_arg_val;
+    typedef Ret_Special_Basic_Argument_T<T,to_T,from_T>     stub_ret_val;
+
+    typedef In_Special_Basic_SArgument_T<T,to_T,from_T>     in_sarg_val;
+    typedef Inout_Special_Basic_SArgument_T<T,to_T,from_T>  inout_sarg_val;
+    typedef Out_Special_Basic_SArgument_T<T,to_T,from_T>    out_sarg_val;
+    typedef Ret_Special_Basic_SArgument_T<T,to_T,from_T>    skel_ret_val;
+
+    typedef Special_Basic_Tag                               idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Special_Basic_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Special_Basic_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_SPECIAL_BASIC_ARGUMENT_T_H */
diff --git a/TAO/tao/Special_Basic_Arguments.cpp b/TAO/tao/Special_Basic_Arguments.cpp
new file mode 100644
index 00000000000..63bba52ec54
--- /dev/null
+++ b/TAO/tao/Special_Basic_Arguments.cpp
@@ -0,0 +1,63 @@
+// $Id$
+
+#include "tao/Special_Basic_Arguments.h"
+
+ACE_RCSID (tao,
+           Special_Basic_Arguments,
+           "$Id$")
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class TAO::Arg_Traits<ACE_InputCDR::to_char>;
+template class TAO::Arg_Traits<ACE_InputCDR::to_wchar>;
+template class TAO::Arg_Traits<ACE_InputCDR::to_octet>;
+template class TAO::Arg_Traits<ACE_InputCDR::to_boolean>;
+
+template class TAO::Special_Basic_Arg_Traits_T<CORBA::Char,
+                                               ACE_InputCDR::to_char,
+                                               ACE_OutputCDR::from_char>;
+
+template class TAO::Special_Basic_Arg_Traits_T<CORBA::WChar,
+                                               ACE_InputCDR::to_wchar,
+                                               ACE_OutputCDR::from_wchar>;
+
+template class TAO::Special_Basic_Arg_Traits_T<CORBA::Octet,
+                                               ACE_InputCDR::to_octet,
+                                               ACE_OutputCDR::from_octet>;
+
+template class TAO::Special_Basic_Arg_Traits_T<CORBA::Boolean,
+                                               ACE_InputCDR::to_boolean,
+                                               ACE_OutputCDR::from_boolean>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+# pragma instantiate TAO::Arg_Traits<ACE_InputCDR::to_char>
+# pragma instantiate TAO::Arg_Traits<ACE_InputCDR::to_wchar>
+# pragma instantiate TAO::Arg_Traits<ACE_InputCDR::to_octet>
+# pragma instantiate TAO::Arg_Traits<ACE_InputCDR::to_boolean>
+
+# pragma instantiate TAO::Special_Basic_Arg_Traits_T< \
+                              CORBA::Char, \
+                              ACE_InputCDR::to_char, \
+                              ACE_OutputCDR::from_char \
+                            >
+
+# pragma instantiate TAO::Special_Basic_Arg_Traits_T< \
+                              CORBA::WChar, \
+                              ACE_InputCDR::to_wchar, \
+                              ACE_OutputCDR::from_wchar \
+                            >
+
+# pragma instantiate TAO::Special_Basic_Arg_Traits_T< \
+                              CORBA::Octet, \
+                              ACE_InputCDR::to_octet, \
+                              ACE_OutputCDR::from_octet \
+                            >
+
+# pragma instantiate TAO::Special_Basic_Arg_Traits_T< \
+                              CORBA::Boolean, \
+                              ACE_InputCDR::to_boolean, \
+                              ACE_OutputCDR::from_boolean \
+                            >
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/Special_Basic_Arguments.h b/TAO/tao/Special_Basic_Arguments.h
new file mode 100644
index 00000000000..b3e4211f4ec
--- /dev/null
+++ b/TAO/tao/Special_Basic_Arguments.h
@@ -0,0 +1,71 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Special_Basic_Arguments.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_SPECIAL_BASIC_ARGUMENTS_H
+#define TAO_SPECIAL_BASIC_ARGUMENTS_H
+
+#include "ace/pre.h"
+#include "ace/CDR_Stream.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Special_Basic_Argument_T.h"
+#include "Arg_Traits_T.h"
+
+namespace TAO
+{
+  /**
+   *
+   * @brief Specializations for (w)char, octet and boolean.
+   *
+   */
+
+  template<>
+  class TAO_Export Arg_Traits<ACE_InputCDR::to_char>
+    : public Special_Basic_Arg_Traits_T<CORBA::Char,
+                                        ACE_InputCDR::to_char,
+                                        ACE_OutputCDR::from_char>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<ACE_InputCDR::to_wchar> 
+    : public Special_Basic_Arg_Traits_T<CORBA::WChar,
+                                        ACE_InputCDR::to_wchar,
+                                        ACE_OutputCDR::from_wchar>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<ACE_InputCDR::to_octet> 
+    : public Special_Basic_Arg_Traits_T<CORBA::Octet,
+                                        ACE_InputCDR::to_octet,
+                                        ACE_OutputCDR::from_octet>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<ACE_InputCDR::to_boolean> 
+    : public Special_Basic_Arg_Traits_T<CORBA::Boolean,
+                                        ACE_InputCDR::to_boolean,
+                                        ACE_OutputCDR::from_boolean>
+  {
+  };
+};
+
+#include "ace/post.h"
+
+#endif /* TAO_SPECIAL_BASIC_ARGUMENTS_H */
+
diff --git a/TAO/tao/TAO.dsp b/TAO/tao/TAO.dsp
index 9b9c6708c55..017c67d5dbf 100644
--- a/TAO/tao/TAO.dsp
+++ b/TAO/tao/TAO.dsp
@@ -184,6 +184,10 @@ SOURCE=.\append.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Argument.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\Asynch_Invocation.cpp

 # End Source File

 # Begin Source File

@@ -200,6 +204,10 @@ SOURCE=.\Base_Transport_Property.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Basic_Arguments.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\BiDir_Adapter.cpp

 # End Source File

 # Begin Source File

@@ -868,6 +876,10 @@ SOURCE=.\skip.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Special_Basic_Arguments.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\StringSeqC.cpp

 # ADD CPP /GR

 # End Source File

@@ -983,6 +995,10 @@ SOURCE=.\TypeCodeFactory_Adapter.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\UB_String_Arguments.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\Valuetype_Adapter.cpp

 # End Source File

 # Begin Source File

@@ -1060,6 +1076,14 @@ SOURCE=.\arg_shifter.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\Arg_Traits_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Argument.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\Array_VarOut_T.h

 # End Source File

 # Begin Source File

@@ -1080,6 +1104,18 @@ SOURCE=.\Base_Transport_Property.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\Basic_Argument_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Basic_Arguments.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\BD_String_Argument_T.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\BiDir_Adapter.h

 # End Source File

 # Begin Source File

@@ -1296,6 +1332,14 @@ SOURCE=.\FILE_Parser.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\Fixed_Array_Argument_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Fixed_Size_Argument_T.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\Flushing_Strategy.h

 # End Source File

 # Begin Source File

@@ -1544,6 +1588,10 @@ SOURCE=.\object.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\Object_Argument_T.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\Object_KeyC.h

 # End Source File

 # Begin Source File

@@ -1748,10 +1796,6 @@ SOURCE=.\SArgument.h
 # End Source File

 # Begin Source File

 

-SOURCE=.\SArgument_T.h

-# End Source File

-# Begin Source File

-

 SOURCE=.\Seq_Out_T.h

 # End Source File

 # Begin Source File

@@ -1792,6 +1836,14 @@ SOURCE=.\singletons.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\Special_Basic_Argument_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Special_Basic_Arguments.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\StringSeqC.h

 # End Source File

 # Begin Source File

@@ -1912,10 +1964,26 @@ SOURCE=.\TypeCodeFactory_Adapter.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\UB_String_Argument_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\UB_String_Arguments.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\Valuetype_Adapter.h

 # End Source File

 # Begin Source File

 

+SOURCE=.\Var_Array_Argument_T.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Var_Size_Argument_T.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\varbase.h

 # End Source File

 # Begin Source File

@@ -2599,11 +2667,36 @@ SOURCE=.\Array_VarOut_T.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Basic_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\BD_String_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

 SOURCE=.\Codeset_Translator_Factory_T.cpp

 # PROP Exclude_From_Build 1

 # End Source File

 # Begin Source File

 

+SOURCE=.\Fixed_Array_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\Fixed_Size_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\Object_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

 SOURCE=.\Objref_VarOut_T.cpp

 # PROP Exclude_From_Build 1

 # End Source File

@@ -2629,6 +2722,26 @@ SOURCE=.\Sequence_T.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Special_Basic_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\UB_String_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\Var_Array_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

+SOURCE=.\Var_Size_Argument_T.cpp

+# PROP Exclude_From_Build 1

+# End Source File

+# Begin Source File

+

 SOURCE=.\VarOut_T.cpp

 # PROP Exclude_From_Build 1

 # End Source File

diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp
index 0e6f7fee172..84a63aa1da8 100644
--- a/TAO/tao/Typecode.cpp
+++ b/TAO/tao/Typecode.cpp
@@ -3719,16 +3719,18 @@ template class ACE_Hash_Map_Manager_Ex<const char *,
                                        ACE_Hash<const char *>,
                                        ACE_Equal_To<const char *>,
                                        ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Base_Ex<const char *,
-                                             ACE_Unbounded_Queue<CORBA::Long> *,
-                                             ACE_Hash<const char *>,
-                                             ACE_Equal_To<const char *>,
-                                             ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<const char *,
-                                                ACE_Unbounded_Queue<CORBA::Long> *,
-                                                ACE_Hash<const char *>,
-                                                ACE_Equal_To<const char *>,
-                                                ACE_Null_Mutex>;
+template class 
+  ACE_Hash_Map_Iterator_Base_Ex<const char *,
+                                ACE_Unbounded_Queue<CORBA::Long> *,
+                                ACE_Hash<const char *>,
+                                ACE_Equal_To<const char *>,
+                                ACE_Null_Mutex>;
+template class 
+  ACE_Hash_Map_Reverse_Iterator_Ex<const char *,
+                                   ACE_Unbounded_Queue<CORBA::Long> *,
+                                   ACE_Hash<const char *>,
+                                   ACE_Equal_To<const char *>,
+                                   ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<const char *,
                                         ACE_Unbounded_Queue<CORBA::Long> *,
                                         ACE_Hash<const char *>,
@@ -3738,17 +3740,49 @@ template class ACE_Hash_Map_Iterator_Ex<const char *,
 template class TAO_Pseudo_Var_T<CORBA::TypeCode>;
 template class TAO_Pseudo_Out_T<CORBA::TypeCode, CORBA::TypeCode_var>;
 
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+template class TAO::Arg_Traits<CORBA::TypeCode>;
+template class TAO::Object_Arg_Traits_T<CORBA::TypeCode_ptr,
+                                        CORBA::TypeCode_var,
+                                        CORBA::TypeCode_out>;
 
-#pragma instantiate TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var>
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 
-#pragma instantiate ACE_Hash_Map_Entry<const char *, ACE_Unbounded_Queue<CORBA::Long> *>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<const char *, ACE_Unbounded_Queue<CORBA::Long> *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<const char *, ACE_Unbounded_Queue<CORBA::Long> *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Nullv_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<const char *, ACE_Unbounded_Queue<CORBA::Long> *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<const char *, ACE_Unbounded_Queue<CORBA::Long> *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>
+#pragma instantiate TAO_Pseudo_Object_Manager<CORBA::TypeCode, \
+                                              CORBA::TypeCode_var>
+
+#pragma instantiate ACE_Hash_Map_Entry<const char *, \
+                                       ACE_Unbounded_Queue<CORBA::Long> *>
+#pragma instantiate \
+  ACE_Hash_Map_Manager_Ex<const char *, \
+                          ACE_Unbounded_Queue<CORBA::Long> *, \
+                          ACE_Hash<const char *>, \
+                          ACE_Equal_To<const char *>, \
+                          ACE_Null_Mutex>
+#pragma instantiate \
+  ACE_Hash_Map_Iterator_Base_Ex<const char *, \
+                                ACE_Unbounded_Queue<CORBA::Long> *, \
+                                ACE_Hash<const char *>, \
+                                ACE_Equal_To<const char *>, \
+                                ACE_Nullv_Mutex>
+#pragma instantiate \
+  ACE_Hash_Map_Reverse_Iterator_Ex<const char *, \
+                                   ACE_Unbounded_Queue<CORBA::Long> *, \
+                                   ACE_Hash<const char *>, \
+                                   ACE_Equal_To<const char *>, \
+                                   ACE_Null_Mutex>
+#pragma instantiate \
+  ACE_Hash_Map_Iterator_Ex<const char *, \
+                           ACE_Unbounded_Queue<CORBA::Long> *, \
+                           ACE_Hash<const char *>, \
+                           ACE_Equal_To<const char *>, \
+                           ACE_Null_Mutex>
 
 #pragma instantiate TAO_Pseudo_Var_T<CORBA::TypeCode>
 #pragma instantiate TAO_Pseudo_Out_T<CORBA::TypeCode, CORBA::TypeCode_var>
 
+#pragma instantiate TAO::Arg_Traits<CORBA::TypeCode>
+#pragma instantiate TAO::Object_Arg_Traits_T<CORBA::TypeCode_ptr, \
+                                             CORBA::TypeCode_var, \
+                                             CORBA::TypeCode_out>
+
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h
index 0d138d06f89..326c398d6f9 100644
--- a/TAO/tao/Typecode.h
+++ b/TAO/tao/Typecode.h
@@ -27,6 +27,8 @@
 
 #include "tao/Exception.h"
 #include "tao/Pseudo_VarOut_T.h"
+#include "tao/Object_Argument_T.h"
+#include "tao/Arg_Traits_T.h"
 
 // Forward declarations
 class TAO_InputCDR;
@@ -542,6 +544,15 @@ namespace CORBA
 
 namespace TAO
 {
+  /// Used in generated code if CORBA::TypeCode is an argument or return type.
+  template<>
+  class TAO_Export Arg_Traits<CORBA::TypeCode>
+    : public Object_Arg_Traits_T<CORBA::TypeCode_ptr, 
+                                 CORBA::TypeCode_var, 
+                                 CORBA::TypeCode_out>
+  {
+  };
+
   /**
    * @class TC_Private_State
    *
diff --git a/TAO/tao/UB_String_Argument_T.cpp b/TAO/tao/UB_String_Argument_T.cpp
new file mode 100644
index 00000000000..9afcc40b11e
--- /dev/null
+++ b/TAO/tao/UB_String_Argument_T.cpp
@@ -0,0 +1,274 @@
+// $Id$
+
+#ifndef TAO_UB_STRING_ARGUMENT_T_C
+#define TAO_UB_STRING_ARGUMENT_T_C
+
+#include "tao/UB_String_Argument_T.h"
+
+ACE_RCSID (tao,
+           String_Argument_T,
+           "$Id$")
+
+template<typename S>
+TAO::In_UB_String_Argument_T<S>::In_UB_String_Argument_T (const S * x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_UB_String_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+void
+TAO::In_UB_String_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_UB_String_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_UB_String_Argument_T<S>::Inout_UB_String_Argument_T (S *& x)
+  : x_ (x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_UB_String_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_UB_String_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  CORBA::string_free (this->x_);
+  return cdr >> this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_UB_String_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_UB_String_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_out>
+TAO::Out_UB_String_Argument_T<S,S_out>::Out_UB_String_Argument_T (S_out & x)
+  : x_ (x.ptr ())
+{}
+
+template<typename S, typename S_out>
+CORBA::Boolean
+TAO::Out_UB_String_Argument_T<S,S_out>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+// ============================================================
+
+template<typename S, typename S_var>
+TAO::Ret_UB_String_Argument_T<S,S_var>::Ret_UB_String_Argument_T (void)
+{
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_UB_String_Argument_T<S,S_var>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::Ret_UB_String_Argument_T<S,S_var>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_UB_String_Argument_T<S,S_var>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S, typename S_var>
+S *
+TAO::Ret_UB_String_Argument_T<S,S_var>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S, typename S_var>
+S *
+TAO::Ret_UB_String_Argument_T<S,S_var>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S, typename S_var>
+TAO::In_UB_String_SArgument_T<S,S_var>::In_UB_String_SArgument_T (void)
+{}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::In_UB_String_SArgument_T<S,S_var>::demarshal (TAO_InputCDR &cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::In_UB_String_SArgument_T<S,S_var>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_.in ();
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::In_UB_String_SArgument_T<S,S_var>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S, typename S_var>
+const S *
+TAO::In_UB_String_SArgument_T<S,S_var>::arg (void) const
+{
+  return this->x_.in ();
+}
+
+// ===========================================================
+
+template<typename S, typename S_var>
+TAO::Inout_UB_String_SArgument_T<S,S_var>::Inout_UB_String_SArgument_T (void)
+{}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Inout_UB_String_SArgument_T<S,S_var>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Inout_UB_String_SArgument_T<S,S_var>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_.out ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::Inout_UB_String_SArgument_T<S,S_var>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_.in ();
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Inout_UB_String_SArgument_T<S,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S, typename S_var>
+S *&
+TAO::Inout_UB_String_SArgument_T<S,S_var>::arg (void)
+{
+  return this->x_.inout ();
+}
+
+// ==============================================================
+
+template<typename S, typename S_var>
+TAO::Out_UB_String_SArgument_T<S,S_var>::Out_UB_String_SArgument_T (
+    void
+  )
+{}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Out_UB_String_SArgument_T<S,S_var>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S, typename S_var>
+S *&
+TAO::Out_UB_String_SArgument_T<S,S_var>::arg (void)
+{
+  return this->x_.out ();
+}
+
+// ============================================================
+
+template<typename S, typename S_var>
+TAO::Ret_UB_String_SArgument_T<S,S_var>::Ret_UB_String_SArgument_T (void)
+{
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_UB_String_SArgument_T<S,S_var>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::Ret_UB_String_SArgument_T<S,S_var>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_UB_String_SArgument_T<S,S_var>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S, typename S_var>
+S *&
+TAO::Ret_UB_String_SArgument_T<S,S_var>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_UB_STRING_ARGUMENT_T_C */
diff --git a/TAO/tao/UB_String_Argument_T.h b/TAO/tao/UB_String_Argument_T.h
new file mode 100644
index 00000000000..3ff6f54fece
--- /dev/null
+++ b/TAO/tao/UB_String_Argument_T.h
@@ -0,0 +1,252 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    UB_String_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_UB_STRING_ARGUMENT_T_H
+#define TAO_UB_STRING_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_UB_String_Argument_T
+   *
+   * @brief Template class for IN unbounded (w)string argument.
+   *
+   */
+  template<typename S>
+  class In_UB_String_Argument_T : public Argument
+  {
+  public:
+    In_UB_String_Argument_T (const S * x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    const S * x_;
+  };
+
+  /**
+   * @class Inout_UB_String_Argument_T
+   *
+   * @brief Template class for INOUT unbounded (w)string argument.
+   *
+   */
+  template<typename S>
+  class Inout_UB_String_Argument_T : public Argument
+  {
+  public:
+    Inout_UB_String_Argument_T (S *& x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    mutable S *& x_;
+  };
+
+  /**
+   * @class Out_UB_String_Argument_T
+   *
+   * @brief Template class for INOUT unbounded (w)string argument.
+   *
+   */
+  template<typename S, typename S_out>
+  class Out_UB_String_Argument_T : public Argument
+  {
+  public:
+    Out_UB_String_Argument_T (S_out & x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    mutable S *& x_;
+  };
+
+  /**
+   * @class Ret_UB_String_Argument_T
+   *
+   * @brief Template class for return stub value of ub (w)string argument.
+   *
+   */
+  template<typename S, typename S_var>
+  class Ret_UB_String_Argument_T : public Argument
+  {
+  public:
+    Ret_UB_String_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S * excp (void);
+    S * retn (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class In_UB_String_SArgument_T
+   *
+   * @brief Template class for IN skeleton UB (w)string argument.
+   *
+   */
+  template<typename S, typename S_var>
+  class In_UB_String_SArgument_T : public Argument
+  {
+  public:
+    In_UB_String_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S * arg (void) const;
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Inout_UB_String_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton UB (w)string argument.
+   *
+   */
+  template<typename S, typename S_var>
+  class Inout_UB_String_SArgument_T : public Argument
+  {
+  public:
+    Inout_UB_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Out_UB_String_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton UB (w)string argument.
+   *
+   */
+  template<typename S, typename S_var>
+  class Out_UB_String_SArgument_T : public Argument
+  {
+  public:
+    Out_UB_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_UB_String_SArgument_T
+   *
+   * @brief Template class for return skeleton value of UB (w)string.
+   *
+   */
+  template<typename S, typename S_var>
+  class Ret_UB_String_SArgument_T : public Argument
+  {
+  public:
+    Ret_UB_String_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct UB_String_Tag
+   *
+   * @brief Struct for unbounded (w)string arguments id tag.
+   *
+   */
+  struct TAO_Export UB_String_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of unbounded (w)strings.
+   *
+   */
+  template<typename T, typename T_var, typename T_out>
+  struct UB_String_Arg_Traits_T
+  {
+    typedef T *                                         ret_type;
+    typedef const T *                                   in_type;
+    typedef T *&                                        inout_type;
+    typedef T_out                                       out_type;
+
+    typedef In_UB_String_Argument_T<T>                  in_arg_val;
+    typedef Inout_UB_String_Argument_T<T>               inout_arg_val;
+    typedef Out_UB_String_Argument_T<T,T_out>           out_arg_val;
+    typedef Ret_UB_String_Argument_T<T,T_var>           stub_ret_val;
+
+    typedef In_UB_String_SArgument_T<T,T_var>           in_sarg_val;
+    typedef Inout_UB_String_SArgument_T<T,T_var>        inout_sarg_val;
+    typedef Out_UB_String_SArgument_T<T,T_var>          out_sarg_val;
+    typedef Ret_UB_String_SArgument_T<T,T_var>          skel_ret_val;
+
+    typedef UB_String_Tag                               idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/UB_String_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("UB_String_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_UB_STRING_ARGUMENT_T_H */
+
diff --git a/TAO/tao/UB_String_Arguments.cpp b/TAO/tao/UB_String_Arguments.cpp
new file mode 100644
index 00000000000..0fed9644852
--- /dev/null
+++ b/TAO/tao/UB_String_Arguments.cpp
@@ -0,0 +1,33 @@
+// $Id$
+
+#include "tao/UB_String_Arguments.h"
+
+ACE_RCSID (tao,
+           Special_Basic_Arguments,
+           "$Id$")
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class TAO::Arg_Traits<CORBA::String>;
+template class TAO::Arg_Traits<CORBA::WString>;
+
+template class TAO::UB_String_Arg_Traits_T<CORBA::Char, 
+                                           CORBA::String_var, 
+                                           CORBA::String_out>;
+template class TAO::UB_String_Arg_Traits_T<CORBA::WChar, 
+                                           CORBA::WString_var,
+                                           CORBA::WString_out>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+# pragma instantiate TAO::Arg_Traits<CORBA::String>
+# pragma instantiate TAO::Arg_Traits<CORBA::WString>
+
+# pragma instantiate TAO::UB_String_Arg_Traits_T<CORBA::Char, \
+                                                 CORBA::String_var, \
+                                                 CORBA::String_out>
+# pragma instantiate TAO::UB_String_Arg_Traits_T<CORBA::WChar, \
+                                                 CORBA::WString_var, \
+                                                 CORBA::WString_out>
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/UB_String_Arguments.h b/TAO/tao/UB_String_Arguments.h
new file mode 100644
index 00000000000..ca9cb31a08b
--- /dev/null
+++ b/TAO/tao/UB_String_Arguments.h
@@ -0,0 +1,54 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    UB_String_Arguments.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_UB_STRING_ARGUMENTS_H
+#define TAO_UB_STRING_ARGUMENTS_H
+
+#include "ace/pre.h"
+#include "tao/corbafwd.h"
+#include "tao/UB_String_Argument_T.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Arg_Traits_T.h"
+
+namespace TAO
+{
+  /**
+   *
+   * @brief Specializatons for unbounded (w)strings.
+   *
+   */
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::Char *>
+    : public UB_String_Arg_Traits_T<CORBA::Char, 
+                                    CORBA::String_var,
+                                    CORBA::String_out>
+  {
+  };
+
+  template<>
+  class TAO_Export Arg_Traits<CORBA::WChar *>
+    : public UB_String_Arg_Traits_T<CORBA::WChar, 
+                                    CORBA::WString_var,
+                                    CORBA::WString_out>
+  {
+  };
+};
+
+#include "ace/post.h"
+
+#endif /* TAO_UB_STRING_ARGUMENTS_H */
diff --git a/TAO/tao/Valuetype/Sequence_T.inl b/TAO/tao/Valuetype/Sequence_T.inl
index d36e355b374..f8bbada422e 100644
--- a/TAO/tao/Valuetype/Sequence_T.inl
+++ b/TAO/tao/Valuetype/Sequence_T.inl
@@ -83,7 +83,7 @@ ACE_INLINE
 T *&
 TAO_Valuetype_Manager<T,T_var,T_life>::out (void)
 {
-  T_life::tao_remove_ref (*this->ptr_);
+  TAO::Value_Traits<T>::tao_remove_ref (*this->ptr_);
   *this->ptr_ = 0;
   return *this->ptr_;
 }
diff --git a/TAO/tao/Valuetype/Value_VarOut_T.cpp b/TAO/tao/Valuetype/Value_VarOut_T.cpp
index 9ee88a39c8f..6b3bbb8b541 100644
--- a/TAO/tao/Valuetype/Value_VarOut_T.cpp
+++ b/TAO/tao/Valuetype/Value_VarOut_T.cpp
@@ -9,6 +9,22 @@ ACE_RCSID (tao,
            Value_VarOut_T, 
            "$Id$")
 
+template<typename T>
+void
+TAO::Value_Traits<T>::tao_add_ref (T * p)
+{
+  CORBA::add_ref (p);
+}
+
+template<typename T>
+void
+TAO::Value_Traits<T>::tao_remove_ref (T * p)
+{
+  CORBA::remove_ref (p);
+}
+
+// ===============================================================
+
 template <typename T, typename T_life>
 TAO_Value_Var_T<T,T_life>::TAO_Value_Var_T (void)
   : ptr_ (0)
@@ -36,21 +52,21 @@ TAO_Value_Var_T<T,T_life>::TAO_Value_Var_T (
     const TAO_Value_Var_T<T,T_life> & p
   )
 {
-  T_life::tao_add_ref (p.ptr ());
+  TAO::Value_Traits<T>::tao_add_ref (p.ptr ());
   this->ptr_ = p.ptr ();
 }
 
 template <typename T, typename T_life>
 TAO_Value_Var_T<T,T_life>::~TAO_Value_Var_T (void)
 {
-  T_life::tao_remove_ref (this->ptr_);
+  TAO::Value_Traits<T>::tao_remove_ref (this->ptr_);
 }
 
 template <typename T, typename T_life>
 TAO_Value_Var_T<T,T_life> &
 TAO_Value_Var_T<T,T_life>::operator= (T * p)
 {
-  T_life::tao_remove_ref (this->ptr_);
+  TAO::Value_Traits<T>::tao_remove_ref (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
@@ -61,9 +77,9 @@ TAO_Value_Var_T<T,T_life>::operator= (const TAO_Value_Var_T & p)
 {
   if (this != &p)
   {
-    T_life::tao_remove_ref (this->ptr_);
+    TAO::Value_Traits<T>::tao_remove_ref (this->ptr_);
     T * tmp = p.ptr ();
-    T_life::tao_add_ref (tmp);
+    TAO::Value_Traits<T>::tao_add_ref (tmp);
     this->ptr_ = tmp;
   }
   
@@ -107,7 +123,7 @@ template <typename T, typename T_life>
 T *&
 TAO_Value_Var_T<T,T_life>::out (void)
 {
-  T_life::tao_remove_ref (this->ptr_);
+  TAO::Value_Traits<T>::tao_remove_ref (this->ptr_);
   this->ptr_ = 0;
   return this->ptr_;
 }
@@ -134,7 +150,7 @@ template <typename T, typename T_life>
 TAO_Value_Out_T<T,T_life>::TAO_Value_Out_T (TAO_Value_Var_T<T,T_life> & p)
   : ptr_ (p.out ())
 {
-  T_life::tao_remove_ref (this->ptr_);
+  TAO::Value_Traits<T>::tao_remove_ref (this->ptr_);
   this->ptr_ = 0;
 }
 
@@ -156,7 +172,7 @@ TAO_Value_Out_T<T,T_life> &
 TAO_Value_Out_T<T,T_life>::operator= (const TAO_Value_Var_T<T,T_life> & p)
 {
   T * tmp = p.ptr ();
-  T_life::tao_add_ref (tmp);
+  TAO::Value_Traits<T>::tao_add_ref (tmp);
   this->ptr_ = tmp;
   return *this;
 }
diff --git a/TAO/tao/Valuetype/Value_VarOut_T.h b/TAO/tao/Valuetype/Value_VarOut_T.h
index a2fcee4223e..320542876db 100644
--- a/TAO/tao/Valuetype/Value_VarOut_T.h
+++ b/TAO/tao/Valuetype/Value_VarOut_T.h
@@ -20,6 +20,22 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+namespace TAO
+{
+  /**
+   * struct Value_Traits
+   *
+   * @brief Specialized for each valuetype in generated code.
+   *
+   */
+  template<typename T>
+  struct Value_Traits
+  {
+    static void tao_add_ref (T *);
+    static void tao_remove_ref (T *);
+  };
+};
+
 /**
  * @class TAO_Value_Var_T
  *
diff --git a/TAO/tao/Var_Array_Argument_T.cpp b/TAO/tao/Var_Array_Argument_T.cpp
new file mode 100644
index 00000000000..d5ccfa010a1
--- /dev/null
+++ b/TAO/tao/Var_Array_Argument_T.cpp
@@ -0,0 +1,319 @@
+// $Id$
+
+#ifndef TAO_VAR_ARRAY_ARGUMENT_T_C
+#define TAO_VAR_ARRAY_ARGUMENT_T_C
+
+#include "tao/Var_Array_Argument_T.h"
+
+ACE_RCSID (tao,
+           Var_Array_Argument_T,
+           "$Id$")
+
+template<typename S, typename S_slice, typename S_forany>
+TAO::In_Var_Array_Argument_T<S,S_slice,S_forany>::
+In_Var_Array_Argument_T (const S x)
+  : x_ ((S_slice *) x)
+{}
+
+template<typename S, typename S_slice, typename S_forany>
+CORBA::Boolean
+TAO::In_Var_Array_Argument_T<S,S_slice,S_forany>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << this->x_;
+}
+
+template<typename S, typename S_slice, typename S_forany>
+void
+TAO::In_Var_Array_Argument_T<S,S_slice,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename S_slice, typename S_forany>
+CORBA::Boolean
+TAO::In_Var_Array_Argument_T<S,S_slice,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S, typename S_forany>
+TAO::Inout_Var_Array_Argument_T<S,S_forany>::Inout_Var_Array_Argument_T (
+    S x
+  )
+  : x_ (x)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_Argument_T<S,S_forany>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_Argument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> this->x_;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::Inout_Var_Array_Argument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_Argument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_var, typename S_out, typename S_forany>
+TAO::Out_Var_Array_Argument_T<S,S_var,S_out,S_forany>::
+Out_Var_Array_Argument_T (S_out x)
+{
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
+  ACE_ALLOCATOR (x.ptr (),
+                 ARRAY_TRAITS::tao_alloc ());
+  this->x_ = x.ptr ();
+}
+
+template<typename S, typename S_var, typename S_out, typename S_forany>
+CORBA::Boolean
+TAO::Out_Var_Array_Argument_T<S,S_var,S_out,S_forany>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  S_forany tmp (this->x_.ptr ());
+  return cdr >> tmp;
+}
+
+// ============================================================
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
+Ret_Var_Array_Argument_T (void)
+{
+  typedef TAO::Array_Traits<S,S_slice> ARRAY_TRAITS;
+  S_slice * tmp = 0;
+  ACE_ALLOCATOR (tmp,
+                 ARRAY_TRAITS::tao_alloc ());
+  this->x_ = tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::demarshal (
+    TAO_InputCDR & cdr
+  )
+{
+  S_forany tmp (this->x_.ptr ());
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+void
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
+interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= S_forany (this->x_.ptr ());
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::
+interceptor_replace (CORBA::Any & any)
+{
+  S_forany tmp (this->x_.ptr ());
+  return any >>= tmp;
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+S_slice *
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S, typename S_slice, typename S_var, typename S_forany>
+S_slice *
+TAO::Ret_Var_Array_Argument_T<S,S_slice,S_var,S_forany>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S, typename S_forany>
+TAO::In_Var_Array_SArgument_T<S,S_forany>::In_Var_Array_SArgument_T (void)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::In_Var_Array_SArgument_T<S,S_forany>::demarshal (TAO_InputCDR &cdr)
+{
+  S_forany tmp (this->x_);
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::In_Var_Array_SArgument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= S_forany (this->x_);
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::In_Var_Array_SArgument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  S_forany tmp (this->x_);
+  return any >>= tmp;
+}
+
+template<typename S, typename S_forany>
+const S &
+TAO::In_Var_Array_SArgument_T<S,S_forany>::arg (void) const
+{
+  return this->x_;
+}
+
+// ===========================================================
+
+template<typename S, typename S_forany>
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::
+Inout_Var_Array_SArgument_T (void)
+{}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << S_forany (this->x_);
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::demarshal (TAO_InputCDR & cdr)
+{
+  S_forany tmp (this->x_);
+  return cdr >> tmp;
+}
+
+template<typename S, typename S_forany>
+void
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::interceptor_param (
+    Dynamic::Parameter & p
+  )
+{
+  p.argument <<= S_forany (this->x_);
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S, typename S_forany>
+CORBA::Boolean
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::interceptor_replace (
+    CORBA::Any & any
+  )
+{
+  S_forany tmp (this->x_);
+  return any >>= tmp;
+}
+
+template<typename S, typename S_forany>
+S &
+TAO::Inout_Var_Array_SArgument_T<S,S_forany>::arg (void)
+{
+  return this->x_;
+}
+
+// ==============================================================
+
+template<typename S_slice, typename S_var, typename S_forany>
+TAO::Out_Var_Array_SArgument_T<S_slice,S_var,S_forany>::
+Out_Var_Array_SArgument_T (void)
+{}
+
+template<typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Out_Var_Array_SArgument_T<S_slice,S_var,S_forany>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << S_forany (this->x_.ptr ());
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+S_slice *&
+TAO::Out_Var_Array_SArgument_T<S_slice,S_var,S_forany>::arg (void)
+{
+  return this->x_.out ();
+}
+
+// ============================================================
+
+template<typename S_slice, typename S_var, typename S_forany>
+TAO::Ret_Var_Array_SArgument_T<S_slice,S_var,S_forany>::
+Ret_Var_Array_SArgument_T (void)
+{
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Var_Array_SArgument_T<S_slice,S_var,S_forany>::marshal (
+    TAO_OutputCDR & cdr
+  )
+{
+  return cdr << S_forany (this->x_.ptr ());
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+void
+TAO::Ret_Var_Array_SArgument_T<S_slice,S_var,S_forany>::interceptor_result (
+    CORBA::Any * any
+  )
+{
+  (*any) <<= S_forany (this->x_.ptr ());
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+CORBA::Boolean
+TAO::Ret_Var_Array_SArgument_T<S_slice,S_var,S_forany>::
+interceptor_replace (CORBA::Any & any)
+{
+  S_forany tmp (this->x_.ptr ());
+  return any >>= tmp;
+}
+
+template<typename S_slice, typename S_var, typename S_forany>
+S_slice *&
+TAO::Ret_Var_Array_SArgument_T<S_slice,S_var,S_forany>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_VAR_ARRAY_ARGUMENT_T_C */
diff --git a/TAO/tao/Var_Array_Argument_T.h b/TAO/tao/Var_Array_Argument_T.h
new file mode 100644
index 00000000000..c977106dff2
--- /dev/null
+++ b/TAO/tao/Var_Array_Argument_T.h
@@ -0,0 +1,270 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Var_Array_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_VAR_ARRAY_ARGUMENT_T_H
+#define TAO_VAR_ARRAY_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_Var_Array_Argument_T
+   *
+   * @brief IN stub argument of variable size element array.
+   *
+   */
+  template<typename S, typename S_slice, typename S_forany>
+  class In_Var_Array_Argument_T : public Argument
+  {
+  public:
+    In_Var_Array_Argument_T (const S x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S_forany x_;
+  };
+
+  /**
+   * @class Inout_Var_Array_Argument_T
+   *
+   * @brief INOUT stub argument of variable size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Inout_Var_Array_Argument_T : public Argument
+  {
+  public:
+    Inout_Var_Array_Argument_T (S x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S_forany x_;
+  };
+
+  /**
+   * @class Out_Var_Array_Argument_T
+   *
+   * @brief OUT stub argument of variable size element array.
+   *
+   */
+  template<typename S, typename S_var, typename S_out, typename S_forany>
+  class Out_Var_Array_Argument_T : public Argument
+  {
+  public:
+    Out_Var_Array_Argument_T (S_out x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_Var_Array_Argument_T
+   *
+   * @brief Return stub value of variable size element array.
+   *
+   */
+  template<typename S,
+           typename S_slice, 
+           typename S_var, 
+           typename S_forany>
+  class Ret_Var_Array_Argument_T : public Argument
+  {
+  public:
+    Ret_Var_Array_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_slice * excp (void);
+    S_slice * retn (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class In_Var_Array_SArgument_T
+   *
+   * @brief IN skeleton argument of variable size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class In_Var_Array_SArgument_T : public Argument
+  {
+  public:
+    In_Var_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S & arg (void) const;
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Inout_Var_Array_SArgument_T
+   *
+   * @brief INOUT skeleton argument of variable size element array.
+   *
+   */
+  template<typename S, typename S_forany>
+  class Inout_Var_Array_SArgument_T : public Argument
+  {
+  public:
+    Inout_Var_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S x_;
+  };
+
+  /**
+   * @class Out_Var_Array_SArgument_T
+   *
+   * @brief OUT skeleton argument of variable size element array.
+   *
+   */
+  template<typename S_slice, typename S_var, typename S_forany>
+  class Out_Var_Array_SArgument_T : public Argument
+  {
+  public:
+    Out_Var_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S_slice *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_Var_Array_SArgument_T
+   *
+   * @brief Skeleton value of variable size element array.
+   *
+   */
+  template<typename S_slice, typename S_var, typename S_forany>
+  class Ret_Var_Array_SArgument_T : public Argument
+  {
+  public:
+    Ret_Var_Array_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S_slice *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct Var_Array_Tag
+   *
+   * @brief Struct for variable size element array argument id tag.
+   *
+   */
+  struct TAO_Export Var_Array_Tag {};
+
+  /**
+   * @struct Var_Array_Arg_Traits_T
+   *
+   * @brief Argument traits of variable size element array.
+   *
+   */
+  template<typename T, 
+           typename T_slice, 
+           typename T_var, 
+           typename T_out,
+           typename T_forany>
+  struct Var_Array_Arg_Traits_T
+  {
+    typedef T_slice *                                   ret_type;
+    typedef const T                                     in_type;
+    typedef T                                           inout_type;
+    typedef T_out                                       out_type;
+
+    typedef In_Var_Array_Argument_T<T,
+                                    T_slice,
+                                    T_forany>           in_arg_val;
+    typedef Inout_Var_Array_Argument_T<T,T_forany>      inout_arg_val;
+    typedef Out_Var_Array_Argument_T<T,
+                                     T_var,
+                                     T_out,
+                                     T_forany>          out_arg_val;
+    typedef Ret_Var_Array_Argument_T<T,
+                                     T_slice,
+                                     T_var,
+                                     T_forany>          stub_ret_val;
+
+    typedef In_Var_Array_SArgument_T<T,T_forany>        in_sarg_val;
+    typedef Inout_Var_Array_SArgument_T<T,T_forany>     inout_sarg_val;
+    typedef Out_Var_Array_SArgument_T<T_slice,
+                                      T_var,
+                                      T_forany>         out_sarg_val;
+    typedef Ret_Var_Array_SArgument_T<T_slice,
+                                      T_var,
+                                      T_forany>         skel_ret_val;
+
+    typedef Var_Array_Tag                               idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Var_Array_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Var_Array_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_VAR_ARRAY_ARGUMENT_T_H */
diff --git a/TAO/tao/Var_Size_Argument_T.cpp b/TAO/tao/Var_Size_Argument_T.cpp
new file mode 100644
index 00000000000..c8e4f40c39f
--- /dev/null
+++ b/TAO/tao/Var_Size_Argument_T.cpp
@@ -0,0 +1,268 @@
+// $Id$
+
+#ifndef TAO_VAR_SIZE_ARGUMENT_T_C
+#define TAO_VAR_SIZE_ARGUMENT_T_C
+
+#include "tao/Var_Size_Argument_T.h"
+
+ACE_RCSID (tao,
+           Var_Size_Argument_T,
+           "$Id$")
+
+template<typename S>
+TAO::In_Var_Size_Argument_T<S>::In_Var_Size_Argument_T (S const & x)
+  : x_ (&x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Var_Size_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Var_Size_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Var_Size_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Var_Size_Argument_T<S>::Inout_Var_Size_Argument_T (S & x)
+  : x_ (&x)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_Argument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_Argument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Var_Size_Argument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_Argument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_out>
+TAO::Out_Var_Size_Argument_T<S,S_out>::Out_Var_Size_Argument_T (S_out x)
+  : x_ (x.ptr ())
+{
+  ACE_NEW (this->x_,
+           S);
+}
+
+template<typename S, typename S_out>
+CORBA::Boolean
+TAO::Out_Var_Size_Argument_T<S,S_out>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+// ============================================================
+
+template<typename S, typename S_var>
+TAO::Ret_Var_Size_Argument_T<S,S_var>::Ret_Var_Size_Argument_T (void)
+{
+  ACE_NEW (this->x_.out (),
+           S);
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_Var_Size_Argument_T<S,S_var>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_.inout ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::Ret_Var_Size_Argument_T<S,S_var>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_Var_Size_Argument_T<S,S_var>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_.inout ();
+}
+
+template<typename S, typename S_var>
+S *
+TAO::Ret_Var_Size_Argument_T<S,S_var>::excp (void)
+{
+  return this->x_.ptr ();
+}
+
+template<typename S, typename S_var>
+S *
+TAO::Ret_Var_Size_Argument_T<S,S_var>::retn (void)
+{
+  return this->x_._retn ();
+}
+
+// ============================================================
+
+template<typename S>
+TAO::In_Var_Size_SArgument_T<S>::In_Var_Size_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Var_Size_SArgument_T<S>::demarshal (TAO_InputCDR &cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::In_Var_Size_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_IN;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::In_Var_Size_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+const S &
+TAO::In_Var_Size_SArgument_T<S>::arg (void) const
+{
+  return *this->x_;
+}
+
+// ===========================================================
+
+template<typename S>
+TAO::Inout_Var_Size_SArgument_T<S>::Inout_Var_Size_SArgument_T (void)
+{}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_SArgument_T<S>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << *this->x_;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_SArgument_T<S>::demarshal (TAO_InputCDR & cdr)
+{
+  return cdr >> *this->x_;
+}
+
+template<typename S>
+void
+TAO::Inout_Var_Size_SArgument_T<S>::interceptor_param (Dynamic::Parameter & p)
+{
+  p.argument <<= *this->x_;
+  p.mode = CORBA::PARAM_INOUT;
+}
+
+template<typename S>
+CORBA::Boolean
+TAO::Inout_Var_Size_SArgument_T<S>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_;
+}
+
+template<typename S>
+S &
+TAO::Inout_Var_Size_SArgument_T<S>::arg (void)
+{
+  return *this->x_;
+}
+
+// ==============================================================
+
+template<typename S, typename S_var>
+TAO::Out_Var_Size_SArgument_T<S,S_var>::Out_Var_Size_SArgument_T (void)
+{}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Out_Var_Size_SArgument_T<S,S_var>::marshal (TAO_OutputCDR &cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S, typename S_var>
+S *&
+TAO::Out_Var_Size_SArgument_T<S,S_var>::arg (void)
+{
+  return this->x_.out ();
+}
+
+// ============================================================
+
+template<typename S, typename S_var>
+TAO::Ret_Var_Size_SArgument_T<S,S_var>::Ret_Var_Size_SArgument_T (void)
+{
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_Var_Size_SArgument_T<S,S_var>::marshal (TAO_OutputCDR & cdr)
+{
+  return cdr << this->x_.in ();
+}
+
+template<typename S, typename S_var>
+void
+TAO::Ret_Var_Size_SArgument_T<S,S_var>::interceptor_result (CORBA::Any * any)
+{
+  (*any) <<= this->x_.in ();
+}
+
+template<typename S, typename S_var>
+CORBA::Boolean
+TAO::Ret_Var_Size_SArgument_T<S,S_var>::interceptor_replace (CORBA::Any & any)
+{
+  return any >>= this->x_.out ();
+}
+
+template<typename S, typename S_var>
+S *&
+TAO::Ret_Var_Size_SArgument_T<S,S_var>::arg (void)
+{
+  return this->x_.out ();
+}
+
+#endif /* TAO_VAR_SIZE_ARGUMENT_T_C */
diff --git a/TAO/tao/Var_Size_Argument_T.h b/TAO/tao/Var_Size_Argument_T.h
new file mode 100644
index 00000000000..c0a298ae764
--- /dev/null
+++ b/TAO/tao/Var_Size_Argument_T.h
@@ -0,0 +1,251 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    Basic_Argument_T.h
+ *
+ *  $Id$
+ *
+ *  @authors Jeff Parsons and Carlos O'Ryan
+ */
+//=============================================================================
+
+
+#ifndef TAO_VAR_SIZE_ARGUMENT_T_H
+#define TAO_VAR_SIZE_ARGUMENT_T_H
+
+#include "ace/pre.h"
+#include "tao/Argument.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace TAO
+{
+  /**
+   * @class In_Var_Size_Argument_T
+   *
+   * @brief Template class for IN stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class In_Var_Size_Argument_T : public Argument
+  {
+  public:
+    In_Var_Size_Argument_T (S const & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    const S * x_;
+  };
+
+  /**
+   * @class Inout_Var_Size_Argument_T
+   *
+   * @brief Template class for INOUT stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Var_Size_Argument_T : public Argument
+  {
+  public:
+    Inout_Var_Size_Argument_T (S & x);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Out_Var_Size_Argument_T
+   *
+   * @brief Template class for OUT stub argument of fixed size IDL types.
+   *
+   */
+  template<typename S, typename S_out>
+  class Out_Var_Size_Argument_T : public Argument
+  {
+  public:
+    Out_Var_Size_Argument_T (S_out x);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+  private:
+    S *& x_;
+  };
+
+  /**
+   * @class Ret_Var_Size_Argument_T
+   *
+   * @brief Template class for return stub value of fixed size IDL types.
+   *
+   */
+  template<typename S, typename S_var>
+  class Ret_Var_Size_Argument_T : public Argument
+  {
+  public:
+    Ret_Var_Size_Argument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S * excp (void);
+    S * retn (void);
+
+  protected:
+    S_var x_;
+  };
+
+  /**
+   * @class In_Var_Size_SArgument_T
+   *
+   * @brief Template class for IN skeleton argument of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class In_Var_Size_SArgument_T : public Argument
+  {
+  public:
+    In_Var_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    const S & arg (void) const;
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Inout_Var_Size_SArgument_T
+   *
+   * @brief Template class for INOUT skeleton arg of fixed size IDL types.
+   *
+   */
+  template<typename S>
+  class Inout_Var_Size_SArgument_T : public Argument
+  {
+  public:
+    Inout_Var_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+    virtual CORBA::Boolean demarshal (TAO_InputCDR &);
+
+    virtual void interceptor_param (Dynamic::Parameter &);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S & arg (void);
+
+  private:
+    S * x_;
+  };
+
+  /**
+   * @class Out_Var_Size_SArgument_T
+   *
+   * @brief Template class for OUT skeleton argument of fixed size IDL types.
+   *
+   */
+  template<typename S, typename S_var>
+  class Out_Var_Size_SArgument_T : public Argument
+  {
+  public:
+    Out_Var_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @class Ret_Var_Size_SArgument_T
+   *
+   * @brief Template class for return skeleton value of fixed size IDL types.
+   *
+   */
+  template<typename S, typename S_var>
+  class Ret_Var_Size_SArgument_T : public Argument
+  {
+  public:
+    Ret_Var_Size_SArgument_T (void);
+
+    virtual CORBA::Boolean marshal (TAO_OutputCDR &);
+
+    virtual void interceptor_result (CORBA::Any *);
+    virtual CORBA::Boolean interceptor_replace (CORBA::Any &);
+
+    S *& arg (void);
+
+  private:
+    S_var x_;
+  };
+
+  /**
+   * @struct Basic_Tag
+   *
+   * @brief Struct for fixed size IDL type arguments id tag.
+   *
+   */
+  struct TAO_Export Var_Size_Tag {};
+
+  /**
+   * @struct Basic_Arg_Traits_T
+   *
+   * @brief Template class for argument traits of fixed size IDL types.
+   *
+   */
+  template<typename T, typename T_var, typename T_out>
+  struct Var_Size_Arg_Traits_T
+  {
+    typedef T *                                         ret_type;
+    typedef const T &                                   in_type;
+    typedef T &                                         inout_type;
+    typedef T_out                                       out_type;
+
+    typedef In_Var_Size_Argument_T<T>                   in_arg_val;
+    typedef Inout_Var_Size_Argument_T<T>                inout_arg_val;
+    typedef Out_Var_Size_Argument_T<T,T_out>            out_arg_val;
+    typedef Ret_Var_Size_Argument_T<T,T_var>            stub_ret_val;
+
+    typedef In_Var_Size_SArgument_T<T>                  in_sarg_val;
+    typedef Inout_Var_Size_SArgument_T<T>               inout_sarg_val;
+    typedef Out_Var_Size_SArgument_T<T,T_var>           out_sarg_val;
+    typedef Ret_Var_Size_SArgument_T<T,T_var>           skel_ret_val;
+
+    typedef Var_Size_Tag                                idl_tag;
+  };
+};
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/Var_Size_Argument_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Var_Size_Argument_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/post.h"
+
+#endif /* TAO_VAR_SIZE_ARGUMENT_T_H */
diff --git a/TAO/tao/corba.h b/TAO/tao/corba.h
index 3f720fd9557..92ed6d6dd62 100644
--- a/TAO/tao/corba.h
+++ b/TAO/tao/corba.h
@@ -79,6 +79,17 @@
 #include "tao/Array_VarOut_T.h"
 #include "tao/VarOut_T.h"
 
+// Template arg helper classes.
+#include "tao/Basic_Argument_T.h"
+#include "tao/BD_String_Argument_T.h"
+#include "tao/Fixed_Array_Argument_T.h"
+#include "tao/Fixed_Size_Argument_T.h"
+#include "tao/Object_Argument_T.h"
+#include "tao/Special_Basic_Argument_T.h"
+#include "tao/UB_String_Argument_T.h"
+#include "tao/Var_Array_Argument_T.h"
+#include "tao/Var_Size_Argument_T.h"
+
 #include "tao/Remote_Object_Proxy_Impl.h"
 
 #include "tao/StringSeqC.h"