ChangeLogTag:Sat Feb 19 14:23:38 2000 Carlos O'Ryan <coryan@uci.edu>

38 files changed, 904 insertions, 835 deletions

diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp
index f9a75265904..9f8eeb5c8fa 100644
--- a/TAO/tao/Any.cpp
+++ b/TAO/tao/Any.cpp
@@ -1,40 +1,16 @@
-// @ (#) $Id$
+// $Id$
 
+// Portions of this file are:
 // Copyright 1994-1995 by Sun Microsystems Inc.
 // All Rights Reserved
 //
-// ORB:         Implementation of CORBA_Any
-//
-// This includes three constructors, a destructor, and a "replace"
-// method for the "Any" data type.  "Any" values pair a pointer to a
-// data structure in the native binary representation (e.g. C struct)
-// with a TypeCode that describes that data structure.
-//
-// The copy constructor and the destructor each use the TypeCode
-// interpreter with specialized "visit" callback routines.  The
-// "visit" routines are used respectively to make "deep copies" and
-// perform "deep frees" of the aritrary values as described by the
-// "Any" value's typecode.
-//
-// Note that these "visit" routines are called directly, and they
-// choose whether or not to use the TypeCode interpreter to examine
-// constituents.  In the simple cases, the "visit" routines can do
-// their work without any further calls; only for constructed types is
-// the interpreter's knowledge really required.
-//
-// THREADING NOTE: "Any" is a data structure which must be protected
-// by external critical sections.  Like simpler numeric types, "Any"
-// instances are accessed and modified atomically.  This
-// implementation is reentrant, so that independent "Any" values may
-// be manipulated concurrently when the underlying programming
-// environment is itself reentrant.
-//
 
 #include "tao/Any.h"
 #include "tao/Typecode.h"
 #include "tao/Marshal.h"
 #include "tao/ORB_Core.h"
 #include "tao/Object.h"
+#include "tao/singletons.h"
 
 #if !defined (__ACE_INLINE__)
 # include "tao/Any.i"
@@ -89,6 +65,7 @@ CORBA_Any::value (void) const
 CORBA_Any::CORBA_Any (void)
   : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)),
     value_ (0),
+    byte_order_ (TAO_ENCAP_BYTE_ORDER),
     cdr_ (0),
     any_owns_data_ (0)
 {
@@ -103,6 +80,7 @@ CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc,
                       CORBA::Boolean any_owns_data)
   : type_ (CORBA::TypeCode::_duplicate (tc)),
     value_ (value),
+    byte_order_ (TAO_ENCAP_BYTE_ORDER),
     cdr_ (0),
     any_owns_data_ (any_owns_data)
 {
@@ -122,6 +100,7 @@ CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc,
           ACE_TRY_CHECK;
 
           // Retrieve the start of the message block chain and save it.
+          this->byte_order_ = TAO_ENCAP_BYTE_ORDER;
           this->cdr_ = stream.begin ()->clone ();
         }
     }
@@ -136,9 +115,11 @@ CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc,
 // Constructor using a message block.
 CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr type,
                       CORBA::UShort,
+                      int byte_order,
                       const ACE_Message_Block* mb)
   : type_ (CORBA::TypeCode::_duplicate (type)),
     value_ (0),
+    byte_order_ (byte_order),
     cdr_ (ACE_Message_Block::duplicate (mb)),
     any_owns_data_ (0)
 {
@@ -159,6 +140,7 @@ CORBA_Any::CORBA_Any (const CORBA_Any &src)
 
   // CDR stream always contains encoded object, if any holds anything
   // at all.
+  this->byte_order_ = src.byte_order_;
   this->cdr_ = ACE_Message_Block::duplicate (src.cdr_);
 
   // No need to copy src's value_.  We can always get that from cdr.
@@ -208,6 +190,7 @@ CORBA_Any::operator= (const CORBA_Any &src)
 
       this->any_owns_data_ = 0;
 
+      this->byte_order_ = src.byte_order_;
       this->cdr_ = ACE_Message_Block::duplicate (src.cdr_);
       // Simply duplicate the cdr string here.  We can save the decode
       // operation if there's no need to extract the object.
@@ -292,12 +275,14 @@ CORBA_Any::replace (CORBA::TypeCode_ptr tc,
       ACE_CHECK;
 
       // Retrieve the start of the message block chain and duplicate it.
+      this->byte_order_ = TAO_ENCAP_BYTE_ORDER;
       this->cdr_ = ACE_Message_Block::duplicate (stream.begin ());
     }
 }
 
 void
 CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
+                         int byte_order,
                          const ACE_Message_Block *mb,
                          CORBA::Environment &ACE_TRY_ENV)
 {
@@ -318,6 +303,7 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
 
   this->any_owns_data_ = 0;
 
+  this->byte_order_ = byte_order;
   this->cdr_ = ACE_Message_Block::duplicate (mb);
   // We can save the decode operation if there's no need to extract
   // the object.
@@ -325,6 +311,7 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
 
 void
 CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
+                         int byte_order,
                          const ACE_Message_Block *mb,
                          CORBA::Boolean any_owns_data,
                          void* value,
@@ -349,6 +336,7 @@ CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc,
 
   this->any_owns_data_ = any_owns_data;
 
+  this->byte_order_ = byte_order;
   this->cdr_ = ACE_Message_Block::duplicate (mb);
   // We can save the decode operation if there's no need to extract
   // the object.
@@ -405,7 +393,7 @@ CORBA_Any::_tao_encode (TAO_OutputCDR &cdr,
     }
 
   TAO_InputCDR in (this->cdr_,
-                   TAO_ENCAP_BYTE_ORDER,
+                   this->byte_order_,
                    orb_core);
   cdr.append (this->type_,
               &in,
@@ -457,6 +445,7 @@ CORBA_Any::_tao_decode (TAO_InputCDR &cdr,
 
   // Stick it into the Any. It gets duplicated there.
   this->_tao_replace (this->type_,
+                      cdr.byte_order (),
                       &mb,
                       ACE_TRY_ENV);
   ACE_CHECK;
@@ -843,6 +832,7 @@ CORBA_Any::operator<<= (const CORBA_Exception &exception)
       ACE_TRY_CHECK;
 
       this->_tao_replace (exception._type (),
+                          TAO_ENCAP_BYTE_ORDER,
                           stream.begin (),
                           ACE_TRY_ENV);
       ACE_TRY_CHECK;
@@ -1048,7 +1038,8 @@ CORBA_Any::operator>>= (CORBA::Short &s) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_short (s);
             }
         }
@@ -1088,7 +1079,8 @@ CORBA_Any::operator>>= (CORBA::UShort &s) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_ushort (s);
             }
         }
@@ -1128,7 +1120,8 @@ CORBA_Any::operator>>= (CORBA::Long &l) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_long (l);
             }
         }
@@ -1168,7 +1161,8 @@ CORBA_Any::operator>>= (CORBA::ULong &l) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_ulong (l);
             }
         }
@@ -1208,7 +1202,8 @@ CORBA_Any::operator>>= (CORBA::LongLong &l) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_longlong (l);
             }
         }
@@ -1248,7 +1243,8 @@ CORBA_Any::operator>>= (CORBA::ULongLong &l) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_ulonglong (l);
             }
         }
@@ -1288,7 +1284,8 @@ CORBA_Any::operator>>= (CORBA::Float &f) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_float (f);
             }
         }
@@ -1328,7 +1325,8 @@ CORBA_Any::operator>>= (CORBA::Double &d) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               return stream.read_double (d);
             }
         }
@@ -1368,7 +1366,8 @@ CORBA_Any::operator>>= (CORBA::Any &a) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               // decode the CDR
               CORBA::TypeCode::traverse_status retval =
                 stream.decode (CORBA::_tc_any,
@@ -1421,7 +1420,8 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const
               ACE_NEW_RETURN (a,
                               CORBA::Any,
                               0);
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               // decode the CDR
               CORBA::TypeCode::traverse_status retval =
                 stream.decode (CORBA::_tc_any,
@@ -1439,7 +1439,7 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const
                   delete ACE_const_cast (CORBA::Any *&, a);
                   a = 0;
                   return 0;
-                }                                      
+                }
             }
         }
       else
@@ -1480,7 +1480,8 @@ CORBA_Any::operator>>= (char *&s) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               if (stream.read_string (s))
                 {
                   ACE_const_cast (CORBA_Any *,
@@ -1544,7 +1545,8 @@ CORBA_Any::operator>>= (const char *&s) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               if (stream.read_string ((char *&)s))
                 {
                   ACE_const_cast (CORBA_Any *,
@@ -1608,7 +1610,8 @@ CORBA_Any::operator>>= (CORBA::WChar *&ws) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               if (stream.read_wstring (ws))
                 {
                   ACE_const_cast (CORBA_Any *,
@@ -1672,7 +1675,8 @@ CORBA_Any::operator>>= (const CORBA::WChar *&ws) const
             }
           else
             {
-              TAO_InputCDR stream (this->cdr_);
+              TAO_InputCDR stream (this->cdr_,
+                                   this->byte_order_);
               if (stream.read_wstring ((CORBA::WChar *&)ws))
                 {
                   ACE_const_cast (CORBA_Any *,
@@ -1736,7 +1740,8 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const
             }
           else
             {
-              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
               CORBA::TypeCode::traverse_status retval =
                 stream.decode (CORBA::_tc_TypeCode,
                                &tc,
@@ -1786,7 +1791,8 @@ CORBA_Any::operator>>= (to_boolean b) const
             }
           else
             {
-              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
               return stream.read_boolean (b.ref_);
             }
         }
@@ -1826,7 +1832,8 @@ CORBA_Any::operator>>= (to_octet o) const
             }
           else
             {
-              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
               return stream.read_octet (o.ref_);
             }
         }
@@ -1866,7 +1873,8 @@ CORBA_Any::operator>>= (to_char c) const
             }
           else
             {
-              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
               return stream.read_char (c.ref_);
             }
         }
@@ -1906,7 +1914,8 @@ CORBA_Any::operator>>= (to_wchar wc) const
             }
           else
             {
-              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+              TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
               return stream.read_wchar (wc.ref_);
             }
         }
@@ -1950,7 +1959,8 @@ CORBA_Any::operator>>= (to_string s) const
                 }
               else
                 {
-                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
                   if (stream.read_string (s.val_))
                     {
                       ACE_const_cast (CORBA_Any *,
@@ -2008,7 +2018,8 @@ CORBA_Any::operator>>= (to_wstring ws) const
                 }
               else
                 {
-                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
+                  TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_,
+                                   this->byte_order_);
                   if (stream.read_wstring (ws.val_))
                     {
                       ACE_const_cast (CORBA_Any *,
@@ -2069,21 +2080,12 @@ CORBA_Any::operator>>= (to_object obj) const
               // demarshal objects (to create the right profiles for that
               // object), but the Any does not belong to any ORB.
               TAO_InputCDR stream (this->cdr_,
-                                   ACE_CDR_BYTE_ORDER,
+                                   this->byte_order_,
                                    TAO_ORB_Core_instance ());
 
-              CORBA::TypeCode::traverse_status status =
-                stream.decode (this->type_,
-                               &obj.ref_,
-                               0,
-                               ACE_TRY_ENV);
-              ACE_TRY_CHECK;
+              int result = stream >> obj.ref_;
 
-              // Because of the CORBA 2.3 change mentioned above, there is no
-              // need to assign to this->value_.
-              return (CORBA::Boolean) ((status == CORBA::TypeCode::TRAVERSE_CONTINUE)
-                                       ? 1
-                                       : 0);
+              return !result;
             }
         }
       else
@@ -2159,9 +2161,61 @@ CORBA_Any::operator<<= (const CORBA::WChar* s)
   ACE_CHECK;
 }
 
-// ----------------------------------------------------------------------
-// Any_var type
-// ----------------------------------------------------------------------
+CORBA::Boolean
+operator<< (TAO_OutputCDR& cdr,
+            const CORBA::Any &x)
+{
+  // @@ This function should *not* use the interpreter, there must be
+  // a way to do this with just CDR operations!!!!
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::TypeCode::traverse_status status =
+        TAO_MARSHAL_ANY::instance ()->encode (0,
+                                              &x,
+                                              0,
+                                              &cdr,
+                                              ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (status== CORBA::TypeCode::TRAVERSE_CONTINUE)
+        return 1;
+      // else return 0 at the end of the function
+    }
+  ACE_CATCH (CORBA_Exception, ex)
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+  return 0;
+}
+
+CORBA::Boolean
+operator>> (TAO_InputCDR &cdr,
+            CORBA::Any &x)
+{
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::TypeCode::traverse_status status =
+        TAO_MARSHAL_ANY::instance ()->decode (0,
+                                              &x,
+                                              0,
+                                              &cdr,
+                                              ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
+        return 0;
+    }
+  ACE_CATCH (CORBA_Exception, ex)
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+
+  return 1;
+}
+
+// ****************************************************************
 
 CORBA::Any_var &
 CORBA_Any_var::operator= (CORBA::Any *p)
@@ -2192,123 +2246,3 @@ CORBA_Any_var::operator= (const CORBA::Any_var& r)
 
   return *this;
 }
-
-// = Debugging method.
-
-// Prints the type and the value of the any value. Dumping is
-// supported only for standard data types.
-
-void
-CORBA_Any::dump (const CORBA::Any &any_value)
-{
-  // Get the typecode kind.
-  CORBA::TypeCode_var type = any_value.type ();
-  CORBA::TCKind kind = type->kind ();
-
-  switch (kind)
-    {
-      case CORBA::tk_null:
-        ACE_DEBUG ((LM_DEBUG,
-                    ASYS_TEXT ("Null\n")));
-        break;
-      case CORBA::tk_void:
-        ACE_DEBUG ((LM_DEBUG,
-                    ASYS_TEXT ("Void\n")));
-        break;
-      case CORBA::tk_short:
-        {
-          CORBA::Short s;
-          any_value >>= s;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("Short %d\n"),
-                     s));
-          break;
-        }
-      case CORBA::tk_long:
-        {
-          CORBA::Long l;
-          any_value >>= l;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("Long %d\n"),
-                      l));
-          break;
-        }
-      case CORBA::tk_ushort:
-        {
-          CORBA::UShort s;
-          any_value >>= s;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("UShort %d\n"),
-                      s));
-          break;
-        }
-      case CORBA::tk_ulong:
-        {
-          CORBA::ULong l;
-          any_value >>= l;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("ULong %d\n"),
-                      l));
-          break;
-        }
-      case CORBA::tk_float:
-        {
-          CORBA::Float f;
-          any_value >>= f;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("Float %f\n"),
-                      f));
-          break;
-        }
-      case CORBA::tk_double:
-        {
-          CORBA::Double d;
-          any_value >>= d;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("Double %f\n"),
-                      d));
-          break;
-        }
-      case CORBA::tk_boolean:
-        {
-          CORBA::Boolean b;
-          to_boolean tb (b);
-          any_value >>= tb;
-          if (b == 1)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ASYS_TEXT ("Boolean TRUE\n")));
-            }
-          else
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ASYS_TEXT ("Boolean FALSE\n")));
-            }
-          break;
-        }
-      case CORBA::tk_char:
-        {
-          CORBA::Char ch;
-          to_char tch (ch);
-          any_value >>= tch;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("Char %c\n"),
-                      ch));
-          break;
-        }
-      case CORBA::tk_string:
-        {
-          char* str;
-          any_value >>= str;
-          ACE_DEBUG ((LM_DEBUG,
-                      ASYS_TEXT ("String %s\n"),
-                      str));
-          break;
-        }
-      default:
-        ACE_DEBUG ((LM_DEBUG,
-                    ASYS_TEXT ("TCKind %d\n"),
-                    kind));
-        break;
-    }
-}
diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h
index 01c672e1181..20f09d06655 100644
--- a/TAO/tao/Any.h
+++ b/TAO/tao/Any.h
@@ -81,6 +81,7 @@ public:
   // = TAO extension
   CORBA_Any (CORBA::TypeCode_ptr type,
              CORBA::UShort dummy,
+             int byte_order,
              const ACE_Message_Block* mb);
   // Constructor. Used by DynAny and others to optimize Any activities
   // by using CDR. The dummy arg is to keep calls like CORBA_Any foo
@@ -301,12 +302,6 @@ public:
   // otherwise. TAO does *not* guarantee that this value may be casted
   // to the contained type safely.
 
-  // = Debugging method.
-
-  static void dump (const CORBA::Any &any_value);
-  // Prints the type and the value of the any value. Dumping is
-  // supported only for standard data types.
-
   // = TAO extensions
   CORBA::Boolean any_owns_data (void) const;
   // Reports whether the Any own the data or not. This is used by the
@@ -317,37 +312,36 @@ public:
 
   ACE_Message_Block* _tao_get_cdr (void) const;
   // Message block accessor.
+  int _tao_byte_order (void) const;
+  // Get the byte order inside the CDR stream.
 
   void _tao_replace (CORBA::TypeCode_ptr,
+                     int byte_order,
                      const ACE_Message_Block *mb,
-                     CORBA::Environment &ACE_TRY_ENV =
-                       TAO_default_environment ());
+                     CORBA::Environment &ACE_TRY_ENV);
   // Replace via message block instead of <value_>.
 
   void _tao_replace (CORBA::TypeCode_ptr type,
+                     int byte_order,
                      const ACE_Message_Block *mb,
                      CORBA::Boolean any_owns_data,
                      void* value,
-                     CORBA::Environment &ACE_TRY_ENV =
-                       TAO_default_environment ());
+                     CORBA::Environment &ACE_TRY_EN);
   // Replace all the contents of the any, used in the <<= operators.
 
   void _tao_replace (CORBA::TypeCode_ptr type,
                      CORBA::Boolean any_owns_data,
                      void* value,
-                     CORBA::Environment &ACE_TRY_ENV =
-                       TAO_default_environment ());
+                     CORBA::Environment &ACE_TRY_ENV);
   // Replace the value of the Any, used in the >>= operators.
 
   void _tao_encode (TAO_OutputCDR &cdr,
                     TAO_ORB_Core *orb_core,
-                    CORBA::Environment &ACE_TRY_ENV =
-                       TAO_default_environment ());
+                    CORBA::Environment &ACE_TRY_ENV);
   // Encode the contents of the Any into <cdr>
 
   void _tao_decode (TAO_InputCDR &cdr,
-                    CORBA::Environment &ACE_TRY_ENV =
-                       TAO_default_environment ());
+                    CORBA::Environment &ACE_TRY_ENV);
   // Decode the <cdr> using the typecode in the Any object.
 
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
@@ -367,6 +361,7 @@ private:
   void *value_;
   // Value for the <Any>.
 
+  int byte_order_;
   ACE_Message_Block *cdr_;
   // encoded value.
 
@@ -479,6 +474,12 @@ private:
   // assignment from _var disallowed
 };
 
+// These operators are too complex to be inline....
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
+                                      const CORBA::Any &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
+                                      CORBA::Any &x);
+
 #if defined (__ACE_INLINE__)
 # include "tao/Any.i"
 #else
diff --git a/TAO/tao/Any.i b/TAO/tao/Any.i
index fc8a58a8f91..370cd09cafa 100644
--- a/TAO/tao/Any.i
+++ b/TAO/tao/Any.i
@@ -3,7 +3,7 @@
 
 // Insertion from special types.
 
-ACE_INLINE 
+ACE_INLINE
 void
 CORBA_Any::replace (CORBA::TypeCode_ptr type,
                     const void *value,
@@ -17,20 +17,24 @@ CORBA_Any::replace (CORBA::TypeCode_ptr type,
                  ACE_TRY_ENV);
 }
 
-ACE_INLINE 
-CORBA::Boolean
+ACE_INLINE CORBA::Boolean
 CORBA_Any::any_owns_data (void) const
 {
   return (this->any_owns_data_ != 0 && this->value_ != 0);
 }
 
-ACE_INLINE 
-ACE_Message_Block*
+ACE_INLINE ACE_Message_Block*
 CORBA_Any::_tao_get_cdr (void) const
 {
   return this->cdr_;
 }
 
+ACE_INLINE int
+CORBA_Any::_tao_byte_order (void) const
+{
+  return this->byte_order_;
+}
+
 ACE_INLINE
 CORBA_Any::to_object::to_object (CORBA_Object_out obj)
   : ref_ (obj.ptr ())
diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp
index 8500557bba4..511f6ad2ea0 100644
--- a/TAO/tao/BoundsC.cpp
+++ b/TAO/tao/BoundsC.cpp
@@ -113,7 +113,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Bounds *&_tao_ele
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA::Bounds, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_Bounds, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/CDR.cpp b/TAO/tao/CDR.cpp
index 71b2fb542bb..3755ec6ffe6 100644
--- a/TAO/tao/CDR.cpp
+++ b/TAO/tao/CDR.cpp
@@ -144,61 +144,6 @@ TAO_OutputCDR::encode (CORBA::TypeCode_ptr tc,
                        ACE_TRY_ENV);
 }
 
-CORBA::Boolean
-operator<< (TAO_OutputCDR& cdr,
-            const CORBA::Any &x)
-{
-  // @@ This function should *not* use the interpreter, there must be
-  // a way to do this with just CDR operations!!!!
-  ACE_TRY_NEW_ENV
-    {
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_ANY::instance ()->encode (0,
-                                              &x,
-                                              0,
-                                              &cdr,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      if (status== CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 1;
-      // else return 0 at the end of the function
-    }
-  ACE_CATCH (CORBA_Exception, ex)
-    {
-      return 0;
-    }
-  ACE_ENDTRY;
-  return 0;
-}
-
-CORBA::Boolean
-operator<< (TAO_OutputCDR& cdr, const CORBA::TypeCode *x)
-{
-  ACE_TRY_NEW_ENV
-    {
-      // @@ This function should *not* use the interpreter, there must
-      // be a way to do this with just CDR operations!!!!
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_TYPECODE::instance ()->encode (0,
-                                                   &x,
-                                                   0,
-                                                   &cdr,
-                                                   ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      if (status == CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 1;
-      // else return 0 at the end of the function
-    }
-  ACE_CATCH (CORBA_Exception, ex)
-    {
-      return 0;
-    }
-  ACE_ENDTRY;
-  return 0;
-}
-
 CORBA::TypeCode::traverse_status
 TAO_OutputCDR::append (CORBA::TypeCode_ptr tc,
                        TAO_InputCDR *src,
@@ -282,54 +227,3 @@ TAO_InputCDR::skip (CORBA::TypeCode_ptr tc,
                      this,
                      ACE_TRY_ENV);
 }
-
-CORBA::Boolean
-operator>> (TAO_InputCDR &cdr,
-            CORBA::Any &x)
-{
-  ACE_TRY_NEW_ENV
-    {
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_ANY::instance ()->decode (0,
-                                              &x,
-                                              0,
-                                              &cdr,
-                                              ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 0;
-    }
-  ACE_CATCH (CORBA_Exception, ex)
-    {
-      return 0;
-    }
-  ACE_ENDTRY;
-
-  return 1;
-}
-
-CORBA::Boolean
-operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x)
-{
-  ACE_TRY_NEW_ENV
-    {
-      CORBA::TypeCode::traverse_status status =
-        TAO_MARSHAL_TYPECODE::instance ()->decode (0,
-                                                   &x,
-                                                   0,
-                                                   &cdr,
-                                                   ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
-        return 0;
-    }
-  ACE_CATCH (CORBA_Exception, ex)
-    {
-      return 0;
-    }
-  ACE_ENDTRY;
-
-  return 1;
-}
diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h
index 689e7022454..45f7ab8c271 100644
--- a/TAO/tao/CDR.h
+++ b/TAO/tao/CDR.h
@@ -250,17 +250,6 @@ private:
   // The ORB_Core, required to extract object references.
 };
 
-// This operators are too complex to be inline....
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
-                                      const CORBA::Any &x);
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
-                                      const CORBA::TypeCode *x);
-
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
-                                      CORBA::Any &x);
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
-                                      CORBA::TypeCode *&x);
-
 #if defined(__ACE_INLINE__)
 # include "tao/CDR.i"
 #else
diff --git a/TAO/tao/CONV_FRAMEC.cpp b/TAO/tao/CONV_FRAMEC.cpp
index 384e24cc16d..a20f0f0c2e9 100644
--- a/TAO/tao/CONV_FRAMEC.cpp
+++ b/TAO/tao/CONV_FRAMEC.cpp
@@ -309,7 +309,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo
     else
     {
       ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponent, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CONV_FRAME::_tc_CodeSetComponent, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -375,7 +376,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetCompo
     else
     {
       ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetComponentInfo, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CONV_FRAME::_tc_CodeSetComponentInfo, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -441,7 +443,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CONV_FRAME::CodeSetConte
     else
     {
       ACE_NEW_RETURN (_tao_elem, CONV_FRAME::CodeSetContext, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CONV_FRAME::_tc_CodeSetContext, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/CurrentC.cpp b/TAO/tao/CurrentC.cpp
index edc4f93b848..009f75238ff 100644
--- a/TAO/tao/CurrentC.cpp
+++ b/TAO/tao/CurrentC.cpp
@@ -51,7 +51,7 @@ CORBA_Current_ptr CORBA_Current::_narrow (
   ACE_NEW_RETURN (
       retval,
       POA_CORBA::_tao_collocated_Current (
-          ACE_reinterpret_cast (POA_CORBA::Current_ptr, 
+          ACE_reinterpret_cast (POA_CORBA::Current_ptr,
                                 servant),
           0
         ),
@@ -102,7 +102,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Current_ptr &_tao_
       if (eq == 0)
         return 0;
 
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       CORBA::Object_ptr *_tao_obj_ptr;
       ACE_NEW_RETURN (_tao_obj_ptr, CORBA::Object_ptr, 0);
       if (stream.decode (CORBA::_tc_Current, _tao_obj_ptr, 0, ACE_TRY_ENV)
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index 90e44490f94..5082b2d43b6 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -362,7 +362,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_DomainManager, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_DomainManager, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -424,7 +425,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ConstructionPolicy, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ConstructionPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -503,7 +505,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_DomainManagerList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_DomainManagerList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/DynArray_i.cpp b/TAO/tao/DynArray_i.cpp
index 337c9503b34..a2c7db9d9e5 100644
--- a/TAO/tao/DynArray_i.cpp
+++ b/TAO/tao/DynArray_i.cpp
@@ -51,7 +51,8 @@ TAO_DynArray_i::TAO_DynArray_i (const CORBA_Any& any)
           // Get the CDR stream of the argument.
           ACE_Message_Block* mb = any._tao_get_cdr ();
 
-          TAO_InputCDR cdr (mb);
+          TAO_InputCDR cdr (mb,
+                            any._tao_byte_order ());
 
           CORBA::TypeCode_var field_tc =
             this->get_element_type (ACE_TRY_ENV);
@@ -62,6 +63,7 @@ TAO_DynArray_i::TAO_DynArray_i (const CORBA_Any& any)
               // This Any constructor is a TAO extension.
               CORBA_Any field_any (field_tc.in (),
                                    0,
+                                   cdr.byte_order (),
                                    cdr.start ());
 
               // This recursive step will call the correct constructor
@@ -275,7 +277,8 @@ TAO_DynArray_i::from_any (const CORBA_Any& any,
     {
       // Get the CDR stream of the argument.
       ACE_Message_Block* mb = any._tao_get_cdr ();
-      TAO_InputCDR cdr (mb);
+      TAO_InputCDR cdr (mb,
+                        any._tao_byte_order ());
 
       CORBA::ULong length = this->da_members_.size ();
       CORBA::ULong arg_length = this->get_arg_length (any.type (),
@@ -295,6 +298,7 @@ TAO_DynArray_i::from_any (const CORBA_Any& any,
           // This Any constructor is a TAO extension.
           CORBA_Any field_any (field_tc.in (),
                                0,
+                               cdr.byte_order (),
                                cdr.start ());
 
           if (!CORBA::is_nil (this->da_members_[i].in ()))
@@ -343,7 +347,8 @@ TAO_DynArray_i::to_any (CORBA::Environment& ACE_TRY_ENV)
 
       ACE_Message_Block* field_mb = field_any->_tao_get_cdr ();
 
-      TAO_InputCDR field_cdr (field_mb);
+      TAO_InputCDR field_cdr (field_mb,
+                              field_any->_tao_byte_order ());
 
       out_cdr.append (field_tc.in (),
                       &field_cdr,
@@ -361,6 +366,7 @@ TAO_DynArray_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_NEW_THROW_EX (retval,
                     CORBA_Any (my_tc,
                                0,
+                               in_cdr.byte_order (),
                                in_cdr.start ()),
                     CORBA::NO_MEMORY ());
   ACE_CHECK_RETURN (0);
@@ -1432,7 +1438,7 @@ TAO_DynArray_i::get_any (CORBA::Environment &ACE_TRY_ENV)
 CORBA::TypeCode_ptr
 TAO_DynArray_i::get_element_type (CORBA::Environment& ACE_TRY_ENV)
 {
-  CORBA::TypeCode_var element_type = 
+  CORBA::TypeCode_var element_type =
     CORBA_TypeCode::_duplicate (this->type_.in ());
 
   // Strip away aliases (if any) on top of the outer type
diff --git a/TAO/tao/DynEnum_i.cpp b/TAO/tao/DynEnum_i.cpp
index ef3a0c50acc..927314ffb1d 100644
--- a/TAO/tao/DynEnum_i.cpp
+++ b/TAO/tao/DynEnum_i.cpp
@@ -42,7 +42,8 @@ TAO_DynEnum_i::TAO_DynEnum_i (const CORBA_Any &any)
           // Get the CDR stream of the argument.
           ACE_Message_Block* mb = any._tao_get_cdr ();
 
-          TAO_InputCDR cdr (mb);
+          TAO_InputCDR cdr (mb,
+                            any._tao_byte_order ());
 
           cdr.read_ulong (this->value_);
         }
@@ -216,7 +217,8 @@ TAO_DynEnum_i::from_any (const CORBA_Any& any,
       // Get the CDR stream of the argument.
       ACE_Message_Block* mb = any._tao_get_cdr ();
 
-      TAO_InputCDR cdr (mb);
+      TAO_InputCDR cdr (mb,
+                        any._tao_byte_order ());
 
       cdr.read_ulong (this->value_);
     }
@@ -237,6 +239,7 @@ TAO_DynEnum_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_NEW_THROW_EX (retval,
                     CORBA_Any (this->type_.in (),
                                0,
+                               TAO_ENCAP_BYTE_ORDER,
                                out_cdr.begin ()),
                     CORBA::NO_MEMORY ());
   ACE_CHECK_RETURN (0);
diff --git a/TAO/tao/DynSequence_i.cpp b/TAO/tao/DynSequence_i.cpp
index 14f940bf548..a8e1a120baa 100644
--- a/TAO/tao/DynSequence_i.cpp
+++ b/TAO/tao/DynSequence_i.cpp
@@ -45,7 +45,8 @@ TAO_DynSequence_i::TAO_DynSequence_i (const CORBA_Any& any)
           // Get the CDR stream of the argument.
           ACE_Message_Block *mb = any._tao_get_cdr ();
 
-          TAO_InputCDR cdr (mb);
+          TAO_InputCDR cdr (mb,
+                            any._tao_byte_order ());
 
           CORBA::ULong length;
 
@@ -66,6 +67,7 @@ TAO_DynSequence_i::TAO_DynSequence_i (const CORBA_Any& any)
               // This Any constructor is a TAO extension.
               CORBA_Any field_any (field_tc.in (),
                                    0,
+                                   cdr.byte_order (),
                                    cdr.start ());
 
               // This recursive step will call the correct constructor
@@ -285,7 +287,8 @@ TAO_DynSequence_i::from_any (const CORBA_Any& any,
       // Get the CDR stream of the argument.
       ACE_Message_Block *mb = any._tao_get_cdr ();
 
-      TAO_InputCDR cdr (mb);
+      TAO_InputCDR cdr (mb,
+                        any._tao_byte_order ());
 
       CORBA::ULong arg_length;
 
@@ -316,6 +319,7 @@ TAO_DynSequence_i::from_any (const CORBA_Any& any,
           // This Any constructor is a TAO extension.
           CORBA_Any field_any (field_tc.in (),
                                0,
+                               cdr.byte_order (),
                                cdr.start ());
 
           if (!CORBA::is_nil (this->da_members_[i].in ()))
@@ -366,7 +370,8 @@ TAO_DynSequence_i::to_any (CORBA::Environment& ACE_TRY_ENV)
       ACE_Message_Block *field_mb =
         field_any->_tao_get_cdr ();
 
-      TAO_InputCDR field_cdr (field_mb);
+      TAO_InputCDR field_cdr (field_mb,
+                              field_any->_tao_byte_order ());
 
       out_cdr.append (field_tc.in (),
                       &field_cdr,
@@ -384,6 +389,7 @@ TAO_DynSequence_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_NEW_THROW_EX (retval,
                     CORBA_Any (tc,
                                0,
+                               in_cdr.byte_order (),
                                in_cdr.start ()),
                     CORBA::NO_MEMORY ());
   ACE_CHECK_RETURN (0);
diff --git a/TAO/tao/DynStruct_i.cpp b/TAO/tao/DynStruct_i.cpp
index 7814fe30020..318ba8a45ad 100644
--- a/TAO/tao/DynStruct_i.cpp
+++ b/TAO/tao/DynStruct_i.cpp
@@ -51,7 +51,8 @@ TAO_DynStruct_i::TAO_DynStruct_i (const CORBA_Any& any)
           // Get the CDR stream of the argument.
           ACE_Message_Block *mb = any._tao_get_cdr ();
 
-          TAO_InputCDR cdr (mb);
+          TAO_InputCDR cdr (mb,
+                            any._tao_byte_order ());
 
           for (CORBA::ULong i = 0; i < numfields; i++)
             {
@@ -62,8 +63,9 @@ TAO_DynStruct_i::TAO_DynStruct_i (const CORBA_Any& any)
 
               // This Any constructor is a TAO extension.
               CORBA_Any field_any (field_tc.in (),
-                                  0,
-                                  cdr.start ());
+                                   0,
+                                   cdr.byte_order (),
+                                   cdr.start ());
 
               // This recursive step will call the correct constructor
               // based on the type of field_any.
@@ -300,18 +302,19 @@ TAO_DynStruct_i::from_any (const CORBA_Any& any,
     {
       // Get the CDR stream of the argument.
       ACE_Message_Block* mb = any._tao_get_cdr ();
-      TAO_InputCDR cdr (mb);
+      TAO_InputCDR cdr (mb,
+                        any._tao_byte_order ());
 
       // If we have an exception type, unmarshal the repository ID.
-	    CORBA::TCKind kind = TAO_DynAny_i::unalias (this->type_.in (),
+      CORBA::TCKind kind = TAO_DynAny_i::unalias (this->type_.in (),
                                                   ACE_TRY_ENV);
-	    ACE_CHECK;
+      ACE_CHECK;
 
-	    if (kind == CORBA::tk_except) 
+      if (kind == CORBA::tk_except)
         {
-	        CORBA::String_var str;
-	        cdr >> str.out();
-	      }
+          CORBA::String_var str;
+          cdr >> str.out();
+        }
 
       for (CORBA::ULong i = 0;
            i < this->da_members_.size ();
@@ -325,6 +328,7 @@ TAO_DynStruct_i::from_any (const CORBA_Any& any,
           // This Any constructor is a TAO extension.
           CORBA_Any field_any (field_tc.in (),
                                0,
+                               cdr.byte_order (),
                                cdr.start ());
 
           if (!CORBA::is_nil (this->da_members_[i].in ()))
@@ -358,7 +362,7 @@ TAO_DynStruct_i::to_any (CORBA::Environment& ACE_TRY_ENV)
                                               ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
 
-  if (kind == CORBA::tk_except) 
+  if (kind == CORBA::tk_except)
     {
       out_cdr << this->type_->id ();
     }
@@ -385,7 +389,8 @@ TAO_DynStruct_i::to_any (CORBA::Environment& ACE_TRY_ENV)
 
       ACE_Message_Block *field_mb = field_any->_tao_get_cdr ();
 
-      TAO_InputCDR field_cdr (field_mb);
+      TAO_InputCDR field_cdr (field_mb,
+                              field_any->_tao_byte_order ());
 
       out_cdr.append (field_tc,
                       &field_cdr,
@@ -403,6 +408,7 @@ TAO_DynStruct_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_NEW_THROW_EX (retval,
                     CORBA_Any (tc,
                                0,
+                               in_cdr.byte_order (),
                                in_cdr.start ()),
                     CORBA::NO_MEMORY ());
   ACE_CHECK_RETURN (0);
@@ -536,7 +542,7 @@ void
 TAO_DynStruct_i::insert_char (CORBA::Char value,
                               CORBA::Environment &ACE_TRY_ENV)
 {
-  
+
   CORBA::TypeCode_var tc = this->type_.in ()->member_type (this->current_index_);
   CORBA::TCKind kind =
     TAO_DynAny_i::unalias (tc.in (), ACE_TRY_ENV);
diff --git a/TAO/tao/DynUnion_i.cpp b/TAO/tao/DynUnion_i.cpp
index 8b84053d4c2..35021bfccc5 100644
--- a/TAO/tao/DynUnion_i.cpp
+++ b/TAO/tao/DynUnion_i.cpp
@@ -340,7 +340,8 @@ TAO_DynUnion_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_Message_Block *disc_mb =
     disc_any->_tao_get_cdr ();
 
-  TAO_InputCDR disc_cdr (disc_mb);
+  TAO_InputCDR disc_cdr (disc_mb,
+                         disc_any->_tao_byte_order ());
 
   out_cdr.append (disc_tc,
                   &disc_cdr,
@@ -360,7 +361,8 @@ TAO_DynUnion_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_Message_Block *member_mb =
     member_any->_tao_get_cdr ();
 
-  TAO_InputCDR member_cdr (member_mb);
+  TAO_InputCDR member_cdr (member_mb,
+                           member_any->_tao_byte_order ());
 
   out_cdr.append (member_tc,
                   &member_cdr,
@@ -377,6 +379,7 @@ TAO_DynUnion_i::to_any (CORBA::Environment& ACE_TRY_ENV)
   ACE_NEW_THROW_EX (retval,
                     CORBA_Any (tc,
                                0,
+                               in_cdr.byte_order (),
                                in_cdr.start ()),
                     CORBA::NO_MEMORY ());
   ACE_CHECK_RETURN (0);
@@ -2004,14 +2007,16 @@ TAO_DynUnion_i::Enum_extractor::check_match (const CORBA_Any &inside_any,
   // Get the CDR stream of one argument...
   ACE_Message_Block *mb = inside_any._tao_get_cdr ();
 
-  TAO_InputCDR inside_cdr (mb);
+  TAO_InputCDR inside_cdr (mb,
+                           inside_any._tao_byte_order ());
 
   inside_cdr.read_ulong (this->member_index_);
 
   // And of the other...
   mb = outside_any._tao_get_cdr ();
 
-  TAO_InputCDR outside_cdr (mb);
+  TAO_InputCDR outside_cdr (mb,
+                            outside_any._tao_byte_order ());
 
   outside_cdr.read_ulong (this->arg_index_);
 
@@ -2107,7 +2112,8 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
   // Get the CDR stream of the argument.
   ACE_Message_Block* mb = any._tao_get_cdr ();
 
-  TAO_InputCDR cdr (mb);
+  TAO_InputCDR cdr (mb,
+                    any._tao_byte_order ());
 
   CORBA_TypeCode_ptr disc_tc =
     any.type ()->discriminator_type (ACE_TRY_ENV);
@@ -2115,6 +2121,7 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
 
   CORBA_Any disc_any (disc_tc,
                       0,
+                      cdr.byte_order (),
                       cdr.start ());
 
   if (!CORBA::is_nil (this->discriminator_.in ()))
@@ -2190,6 +2197,7 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
 
       CORBA_Any member_any (member_tc.in (),
                             0,
+                            cdr.byte_order (),
                             cdr.start ());
 
       if (!CORBA::is_nil (this->member_.in ()))
diff --git a/TAO/tao/GIOPC.cpp b/TAO/tao/GIOPC.cpp
index 6fd506855ab..b6b569dfbac 100644
--- a/TAO/tao/GIOPC.cpp
+++ b/TAO/tao/GIOPC.cpp
@@ -69,7 +69,7 @@ static const CORBA::Long _oc_GIOP_IORAddressingInfo[] =
     4, ACE_NTOHL (0x494f5200),  // name = IOR
     2, // member count
     8, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f696400),  // name = type_id
-    CORBA::tk_string, 
+    CORBA::tk_string,
     0U, // string length
     9, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c6573), ACE_NTOHL (0x0),  // name = profiles
     CORBA::tk_sequence, // typecode kind
@@ -119,30 +119,30 @@ TAO_NAMESPACE_END
 GIOP::TargetAddress::_tao_seq_Octet::_tao_seq_Octet (void)
 {}
 GIOP::TargetAddress::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 GIOP::TargetAddress::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 GIOP::TargetAddress::_tao_seq_Octet::_tao_seq_Octet (const _tao_seq_Octet &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 GIOP::TargetAddress::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor
@@ -347,7 +347,7 @@ static const CORBA::Long _oc_GIOP_TargetAddress[] =
       4, ACE_NTOHL (0x494f5200),  // name = IOR
       2, // member count
       8, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f696400),  // name = type_id
-      CORBA::tk_string, 
+      CORBA::tk_string,
       0U, // string length
       9, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c6573), ACE_NTOHL (0x0),  // name = profiles
       CORBA::tk_sequence, // typecode kind
@@ -431,7 +431,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo
     else
     {
       ACE_NEW_RETURN (_tao_elem, GIOP::IORAddressingInfo, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (GIOP::_tc_IORAddressingInfo, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -448,7 +449,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -467,6 +468,7 @@ void operator<<= (
     stream << *_any_val;
     _tao_any._tao_replace (
         GIOP::_tc_TargetAddress,
+        TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
         _any_val,
@@ -492,6 +494,7 @@ void operator<<= (
     stream << *_tao_elem;
     _tao_any._tao_replace (
         GIOP::_tc_TargetAddress,
+        TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
         _tao_elem,
@@ -522,7 +525,8 @@ CORBA::Boolean operator>>= (
     else
     {
       ACE_NEW_RETURN (_tao_elem, GIOP::TargetAddress, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       stream >> *_tao_elem;
       ((CORBA::Any *)&_tao_any)->_tao_replace (
           GIOP::_tc_TargetAddress,
@@ -531,7 +535,7 @@ CORBA::Boolean operator>>= (
           ACE_TRY_ENV
         );
       ACE_TRY_CHECK;
-      
+
       return 1;
     }
   }
@@ -554,20 +558,20 @@ CORBA::Boolean operator<< (
   if (strm << _tao_sequence.length ())
   {
     // encode all elements
-    
+
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
     {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
+      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
         ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (GIOP::TargetAddress::_tao_seq_Octet *)&_tao_sequence);
       if (oseq->mb ())
         return strm.write_octet_array_mb (oseq->mb ());
       else
         return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
     }
-    
+
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
     return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-  
+
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
   }
   return 0; // error
@@ -584,11 +588,11 @@ CORBA::Boolean operator>> (
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
     // retrieve all the elements
-    
+
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
     if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
     {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
+      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
         ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
       oseq->replace (_tao_seq_len, strm.start ());
       oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
@@ -597,14 +601,13 @@ CORBA::Boolean operator>> (
     }
     else
       return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
-    
+
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
     return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-  
+
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
   }
   return 0; // error
 }
 
 #endif /* _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_CPP_ */
-
diff --git a/TAO/tao/GIOP_Server_Request.cpp b/TAO/tao/GIOP_Server_Request.cpp
index 0a8a2d19ec6..12c9c6e15cb 100644
--- a/TAO/tao/GIOP_Server_Request.cpp
+++ b/TAO/tao/GIOP_Server_Request.cpp
@@ -415,7 +415,8 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV)
             }
           else
             {
-              TAO_InputCDR cdr (retval_->_tao_get_cdr ());
+              TAO_InputCDR cdr (this->retval_->_tao_get_cdr (),
+                                this->retval_->_tao_byte_order ());
               (void) this->outgoing_->append (tc.in (), &cdr,
                                               ACE_TRY_ENV);
               ACE_CHECK;
@@ -707,7 +708,8 @@ TAO_GIOP_ServerRequest::init_reply (CORBA::Environment &ACE_TRY_ENV)
       this->outgoing_->write_ulong (this->exception_type_);
 
       // we use the any's ACE_Message_Block
-      TAO_InputCDR cdr (this->exception_->_tao_get_cdr ());
+      TAO_InputCDR cdr (this->exception_->_tao_get_cdr (),
+                        this->exception_->_tao_byte_order ());
       (void) this->outgoing_->append (except_tc, &cdr, ACE_TRY_ENV);
     }
 }
diff --git a/TAO/tao/IOPC.cpp b/TAO/tao/IOPC.cpp
index e6074797507..821dd36b645 100644
--- a/TAO/tao/IOPC.cpp
+++ b/TAO/tao/IOPC.cpp
@@ -578,7 +578,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedProfile *&_ta
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::TaggedProfile, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_TaggedProfile, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -644,7 +645,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::IOR *&_tao_elem)
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::IOR, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_IOR, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -710,7 +712,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::TaggedComponent *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::TaggedComponent, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_TaggedComponent, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -779,7 +782,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::MultipleComponentPr
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::MultipleComponentProfile, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_MultipleComponentProfile, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -845,7 +849,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContext *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::ServiceContext, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_ServiceContext, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -914,7 +919,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IOP::ServiceContextList
     else
     {
       ACE_NEW_RETURN (_tao_elem, IOP::ServiceContextList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (IOP::_tc_ServiceContextList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/IORC.cpp b/TAO/tao/IORC.cpp
index 741bd640d66..f0e4083fe78 100644
--- a/TAO/tao/IORC.cpp
+++ b/TAO/tao/IORC.cpp
@@ -419,7 +419,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (TAO_IOP::_tc_TAO_IOR_Manipulation, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (TAO_IOP::_tc_TAO_IOR_Manipulation, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -493,7 +494,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_EmptyProfileList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -558,7 +560,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::NotFound, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_NotFound, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -623,7 +626,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Duplicate, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_Duplicate, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -688,7 +692,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_Invalid_IOR, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -757,7 +762,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::TAO_IOR_Manipul
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO_IOP::TAO_IOR_Manipulation::IORList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO_IOP::TAO_IOR_Manipulation::_tc_IORList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/ImplRepoC.cpp b/TAO/tao/ImplRepoC.cpp
index 7e15c2ed3c0..3419c7825af 100644
--- a/TAO/tao/ImplRepoC.cpp
+++ b/TAO/tao/ImplRepoC.cpp
@@ -46,7 +46,7 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec
   return TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-ImplementationRepository::ServerObject_ptr 
+ImplementationRepository::ServerObject_ptr
 ImplementationRepository::ServerObject::_duplicate (ImplementationRepository::ServerObject_ptr obj)
 {
   if (!CORBA::is_nil (obj))
@@ -61,15 +61,15 @@ void ImplementationRepository::ServerObject::ping (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "ping",
@@ -124,7 +124,7 @@ void ImplementationRepository::ServerObject::ping (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -139,10 +139,10 @@ void ImplementationRepository::ServerObject::ping (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -169,15 +169,15 @@ void ImplementationRepository::ServerObject::shutdown (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "shutdown",
@@ -232,7 +232,7 @@ void ImplementationRepository::ServerObject::shutdown (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -247,10 +247,10 @@ void ImplementationRepository::ServerObject::shutdown (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -344,7 +344,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
       // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
       // invoked in the destructor of the class too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
@@ -364,10 +364,10 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor
   // Verify that an <proxy_factory_> is available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1), 
+        TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1),
          0);
-      
-    
+
+
   return this->proxy_factory_->create_proxy (proxy);
 }
 
@@ -431,10 +431,10 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] =
   20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
   2, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
   6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_EnvironmentVariable), (char *) &_oc_ImplementationRepository_EnvironmentVariable, 0, sizeof (ImplementationRepository::EnvironmentVariable));
@@ -447,7 +447,7 @@ static const CORBA::Long _oc_ImplementationRepository_Address[] =
   TAO_ENCAP_BYTE_ORDER, // byte order
   41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
   8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Address (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_Address), (char *) &_oc_ImplementationRepository_Address, 0, sizeof (ImplementationRepository::Address));
@@ -457,7 +457,7 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_Implementati
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
 #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
 
@@ -466,43 +466,43 @@ TAO_NAMESPACE_END
   {
     ImplementationRepository::EnvironmentVariable* tmp = 0;
     tmp = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length);
-    
+
     if (this->buffer_ != 0)
     {
       ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
-      
+
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-      
+
       if (this->release_)
         ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old);
-      
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    
+
     ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
-    
+
     ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
 #define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
@@ -514,30 +514,30 @@ TAO_NAMESPACE_END
 ImplementationRepository::EnvironmentList::EnvironmentList (void)
 {}
 ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::EnvironmentVariable *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 ImplementationRepository::EnvironmentList::~EnvironmentList (void) // dtor
@@ -561,10 +561,10 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] =
       20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
       2, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_string, 
+      CORBA::tk_string,
       0U, // string length
       6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-      CORBA::tk_string, 
+      CORBA::tk_string,
       0U, // string length
 
     0U,
@@ -598,7 +598,7 @@ static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] =
   15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
   4, // member count
   13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
   12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
   CORBA::tk_alias, // typecode kind for typedefs
@@ -616,17 +616,17 @@ static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] =
         20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
         2, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_string, 
+        CORBA::tk_string,
         0U, // string length
         6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-        CORBA::tk_string, 
+        CORBA::tk_string,
         0U, // string length
 
       0U,
 
 
   18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
   11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
   CORBA::tk_enum, // typecode kind
@@ -653,10 +653,10 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
   18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000),  // name = ServerInformation
   4, // member count
   15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = logical_server
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
   7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = server
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
   8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000),  // name = startup
   CORBA::tk_struct, // typecode kind
@@ -666,7 +666,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
     15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
     4, // member count
     13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
-    CORBA::tk_string, 
+    CORBA::tk_string,
     0U, // string length
     12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
     CORBA::tk_alias, // typecode kind for typedefs
@@ -684,17 +684,17 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
           20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
           2, // member count
           5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-          CORBA::tk_string, 
+          CORBA::tk_string,
           0U, // string length
           6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-          CORBA::tk_string, 
+          CORBA::tk_string,
           0U, // string length
 
         0U,
 
 
     18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
-    CORBA::tk_string, 
+    CORBA::tk_string,
     0U, // string length
     11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
     CORBA::tk_enum, // typecode kind
@@ -715,7 +715,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
     TAO_ENCAP_BYTE_ORDER, // byte order
     41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
     8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
-    CORBA::tk_string, 
+    CORBA::tk_string,
     0U, // string length
 
 };
@@ -726,7 +726,7 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformation, &_tc_TAO_tc_Im
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
 #define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
 
@@ -735,43 +735,43 @@ TAO_NAMESPACE_END
   {
     ImplementationRepository::ServerInformation* tmp = 0;
     tmp = ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length);
-    
+
     if (this->buffer_ != 0)
     {
       ImplementationRepository::ServerInformation *old = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
-      
+
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-      
+
       if (this->release_)
         ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old);
-      
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    
+
     ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
-    
+
     ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::~_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
 #define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
@@ -783,30 +783,30 @@ TAO_NAMESPACE_END
 ImplementationRepository::ServerInformationList::ServerInformationList (void)
 {}
 ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::ServerInformation *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 ImplementationRepository::ServerInformationList::ServerInformationList (const ServerInformationList &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor
@@ -830,10 +830,10 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
       18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000),  // name = ServerInformation
       4, // member count
       15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = logical_server
-      CORBA::tk_string, 
+      CORBA::tk_string,
       0U, // string length
       7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = server
-      CORBA::tk_string, 
+      CORBA::tk_string,
       0U, // string length
       8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000),  // name = startup
       CORBA::tk_struct, // typecode kind
@@ -843,7 +843,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
         15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
         4, // member count
         13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
-        CORBA::tk_string, 
+        CORBA::tk_string,
         0U, // string length
         12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
         CORBA::tk_alias, // typecode kind for typedefs
@@ -861,17 +861,17 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
               20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
               2, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_string, 
+              CORBA::tk_string,
               0U, // string length
               6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-              CORBA::tk_string, 
+              CORBA::tk_string,
               0U, // string length
 
             0U,
 
 
         18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
-        CORBA::tk_string, 
+        CORBA::tk_string,
         0U, // string length
         11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
         CORBA::tk_enum, // typecode kind
@@ -892,7 +892,7 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
         TAO_ENCAP_BYTE_ORDER, // byte order
         41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
         8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
-        CORBA::tk_string, 
+        CORBA::tk_string,
         0U, // string length
 
 
@@ -937,7 +937,7 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr
   return TAO_ImplementationRepository_Administration_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-ImplementationRepository::Administration_ptr 
+ImplementationRepository::Administration_ptr
 ImplementationRepository::Administration::_duplicate (ImplementationRepository::Administration_ptr obj)
 {
   if (!CORBA::is_nil (obj))
@@ -972,7 +972,7 @@ ImplementationRepository::Administration::AlreadyRegistered::operator= (const Im
 }
 
 // narrow
-ImplementationRepository::Administration::AlreadyRegistered_ptr 
+ImplementationRepository::Administration::AlreadyRegistered_ptr
 ImplementationRepository::Administration::AlreadyRegistered::_narrow (CORBA::Exception *exc)
 {
   if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0", exc->_id ())) // same type
@@ -1034,7 +1034,7 @@ ImplementationRepository::Administration::CannotActivate::operator= (const Imple
 }
 
 // narrow
-ImplementationRepository::Administration::CannotActivate_ptr 
+ImplementationRepository::Administration::CannotActivate_ptr
 ImplementationRepository::Administration::CannotActivate::_narrow (CORBA::Exception *exc)
 {
   if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/CannotActivate:1.0", exc->_id ())) // same type
@@ -1072,7 +1072,7 @@ static const CORBA::Long _oc_ImplementationRepository_Administration_CannotActiv
   15, ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74650000),  // name = CannotActivate
   1, // member count
   7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000),  // name = reason
-  CORBA::tk_string, 
+  CORBA::tk_string,
   0U, // string length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_CannotActivate (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_CannotActivate), (char *) &_oc_ImplementationRepository_Administration_CannotActivate, 0, sizeof (ImplementationRepository::Administration::CannotActivate));
@@ -1105,7 +1105,7 @@ ImplementationRepository::Administration::NotFound::operator= (const Implementat
 }
 
 // narrow
-ImplementationRepository::Administration::NotFound_ptr 
+ImplementationRepository::Administration::NotFound_ptr
 ImplementationRepository::Administration::NotFound::_narrow (CORBA::Exception *exc)
 {
   if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/NotFound:1.0", exc->_id ())) // same type
@@ -1148,21 +1148,21 @@ void ImplementationRepository::Administration::activate_server (
     ImplementationRepository::Administration::CannotActivate
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc},
     {ImplementationRepository::Administration::_tc_CannotActivate, ImplementationRepository::Administration::CannotActivate::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "activate_server",
@@ -1222,7 +1222,7 @@ void ImplementationRepository::Administration::activate_server (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1237,10 +1237,10 @@ void ImplementationRepository::Administration::activate_server (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1270,20 +1270,20 @@ void ImplementationRepository::Administration::register_server (
     ImplementationRepository::Administration::AlreadyRegistered
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_AlreadyRegistered, ImplementationRepository::Administration::AlreadyRegistered::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "register_server",
@@ -1344,7 +1344,7 @@ void ImplementationRepository::Administration::register_server (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1359,10 +1359,10 @@ void ImplementationRepository::Administration::register_server (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1391,15 +1391,15 @@ void ImplementationRepository::Administration::reregister_server (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "reregister_server",
@@ -1460,7 +1460,7 @@ void ImplementationRepository::Administration::reregister_server (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1475,10 +1475,10 @@ void ImplementationRepository::Administration::reregister_server (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1507,20 +1507,20 @@ void ImplementationRepository::Administration::remove_server (
     ImplementationRepository::Administration::NotFound
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "remove_server",
@@ -1580,7 +1580,7 @@ void ImplementationRepository::Administration::remove_server (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1595,10 +1595,10 @@ void ImplementationRepository::Administration::remove_server (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1627,20 +1627,20 @@ void ImplementationRepository::Administration::shutdown_server (
     ImplementationRepository::Administration::NotFound
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "shutdown_server",
@@ -1700,7 +1700,7 @@ void ImplementationRepository::Administration::shutdown_server (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1715,10 +1715,10 @@ void ImplementationRepository::Administration::shutdown_server (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1749,20 +1749,20 @@ char * ImplementationRepository::Administration::server_is_running (
     ImplementationRepository::Administration::NotFound
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
 
   CORBA::String_var _tao_safe_retval;
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "server_is_running",
@@ -1846,10 +1846,10 @@ char * ImplementationRepository::Administration::server_is_running (
           );
         TAO_INTERCEPTOR_CHECK_RETURN (0);
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1878,20 +1878,20 @@ void ImplementationRepository::Administration::server_is_shutting_down (
     ImplementationRepository::Administration::NotFound
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "server_is_shutting_down",
@@ -1951,7 +1951,7 @@ void ImplementationRepository::Administration::server_is_shutting_down (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -1966,10 +1966,10 @@ void ImplementationRepository::Administration::server_is_shutting_down (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -1999,20 +1999,20 @@ void ImplementationRepository::Administration::find (
     ImplementationRepository::Administration::NotFound
   ))
 {
-  
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] = 
+
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] =
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
 
 
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   ACE_NEW (info.ptr (), ImplementationRepository::ServerInformation);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
@@ -2060,7 +2060,7 @@ void ImplementationRepository::Administration::find (
 
         TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
         if (!(
-              (_tao_out << server)              
+              (_tao_out << server)
           ))
           TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
         int _invoke_status =
@@ -2092,10 +2092,10 @@ void ImplementationRepository::Administration::find (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -2125,15 +2125,15 @@ void ImplementationRepository::Administration::list (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   ACE_NEW (server_list.ptr (), ImplementationRepository::ServerInformationList);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
@@ -2181,7 +2181,7 @@ void ImplementationRepository::Administration::list (
 
         TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
         if (!(
-              (_tao_out << how_many)                            
+              (_tao_out << how_many)
           ))
           TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
         int _invoke_status =
@@ -2214,10 +2214,10 @@ void ImplementationRepository::Administration::list (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -2311,7 +2311,7 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
       // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
       // invoked in the destructor of the class too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
@@ -2331,10 +2331,10 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
   // Verify that an <proxy_factory_> is available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1), 
+        TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1),
          0);
-      
-    
+
+
   return this->proxy_factory_->create_proxy (proxy);
 }
 
@@ -2555,7 +2555,7 @@ ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository
   return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-ImplementationRepository::ServerInformationIterator_ptr 
+ImplementationRepository::ServerInformationIterator_ptr
 ImplementationRepository::ServerInformationIterator::_duplicate (ImplementationRepository::ServerInformationIterator_ptr obj)
 {
   if (!CORBA::is_nil (obj))
@@ -2572,15 +2572,15 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
     CORBA::SystemException
   ))
 {
-  
+
   CORBA::Boolean _tao_retval = 0;
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-  
+
   ACE_NEW_RETURN (server_list.ptr (), ImplementationRepository::ServerInformationList, _tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
@@ -2628,7 +2628,7 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
 
         TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
         if (!(
-              (_tao_out << how_many)              
+              (_tao_out << how_many)
           ))
           TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
 
@@ -2664,10 +2664,10 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
           );
         TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -2694,15 +2694,15 @@ void ImplementationRepository::ServerInformationIterator::destroy (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "destroy",
@@ -2757,7 +2757,7 @@ void ImplementationRepository::ServerInformationIterator::destroy (
         {
           TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
         }
-        
+
         TAO_INTERCEPTOR (
             _tao_vfr.postinvoke (
                 _tao_call.request_id (),
@@ -2772,10 +2772,10 @@ void ImplementationRepository::ServerInformationIterator::destroy (
           );
         TAO_INTERCEPTOR_CHECK;
         break;
-        
+
       }
 #if defined (TAO_HAS_INTERCEPTORS)
-      
+
     }
   ACE_CATCHANY
     {
@@ -2869,7 +2869,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
       // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
       // invoked in the destructor of the class too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
@@ -2889,10 +2889,10 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
   // Verify that an <proxy_factory_> is available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1), 
+        TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1),
          0);
-      
-    
+
+
   return this->proxy_factory_->create_proxy (proxy);
 }
 
@@ -2982,7 +2982,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (ImplementationRepository::_tc_ServerObject, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -3058,7 +3059,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentVariable, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::_tc_EnvironmentVariable, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3075,7 +3077,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3092,7 +3094,7 @@ void operator<<= (
   ACE_TRY_NEW_ENV
   {
     _tao_any.replace (ImplementationRepository::_tc_EnvironmentList, _tao_any_val, 1, ACE_TRY_ENV); // copy the value
-    ACE_TRY_CHECK; 
+    ACE_TRY_CHECK;
   }
   ACE_CATCHANY
   {
@@ -3127,7 +3129,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::EnvironmentList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::_tc_EnvironmentList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3175,7 +3178,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ActivationMode, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     if (stream.decode (ImplementationRepository::_tc_ActivationMode, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -3232,7 +3236,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::StartupOptions, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::_tc_StartupOptions, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3249,7 +3254,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3298,7 +3303,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformation, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::_tc_ServerInformation, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3315,7 +3321,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -3332,7 +3338,7 @@ void operator<<= (
   ACE_TRY_NEW_ENV
   {
     _tao_any.replace (ImplementationRepository::_tc_ServerInformationList, _tao_any_val, 1, ACE_TRY_ENV); // copy the value
-    ACE_TRY_CHECK; 
+    ACE_TRY_CHECK;
   }
   ACE_CATCHANY
   {
@@ -3367,7 +3373,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::ServerInformationList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::_tc_ServerInformationList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3419,7 +3426,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_Administration, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (ImplementationRepository::_tc_Administration, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -3461,7 +3469,7 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ
     _tao_any.replace (ImplementationRepository::Administration::_tc_AlreadyRegistered, _tao_any_val, 1, ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -3494,7 +3502,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::AlreadyRegistered, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::Administration::_tc_AlreadyRegistered, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3526,7 +3535,7 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ
     _tao_any.replace (ImplementationRepository::Administration::_tc_CannotActivate, _tao_any_val, 1, ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -3559,7 +3568,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::CannotActivate, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::Administration::_tc_CannotActivate, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3591,7 +3601,7 @@ void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administ
     _tao_any.replace (ImplementationRepository::Administration::_tc_NotFound, _tao_any_val, 1, ACE_TRY_ENV);
     ACE_TRY_CHECK;
   }
-  ACE_CATCHANY 
+  ACE_CATCHANY
   {
     delete _tao_any_val;
   }
@@ -3624,7 +3634,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     else
     {
       ACE_NEW_RETURN (_tao_elem, ImplementationRepository::Administration::NotFound, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (ImplementationRepository::Administration::_tc_NotFound, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3676,7 +3687,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ServerInformationIterator, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (ImplementationRepository::_tc_ServerInformationIterator, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -3786,4 +3798,3 @@ CORBA::Boolean operator>> (
   }
   return 0; // error
 }
-
diff --git a/TAO/tao/InterceptorC.cpp b/TAO/tao/InterceptorC.cpp
index b94c259ca11..c10168780fc 100644
--- a/TAO/tao/InterceptorC.cpp
+++ b/TAO/tao/InterceptorC.cpp
@@ -462,7 +462,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (PortableInterceptor::_tc_Cookie, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (PortableInterceptor::_tc_Cookie, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -540,7 +541,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Coo
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableInterceptor::Cookies, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableInterceptor::_tc_Cookies, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -589,7 +591,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Int
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (PortableInterceptor::_tc_Interceptor, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (PortableInterceptor::_tc_Interceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -647,7 +650,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Ser
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (PortableInterceptor::_tc_ServerRequestInterceptor, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (PortableInterceptor::_tc_ServerRequestInterceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -705,7 +709,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableInterceptor::Cli
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (PortableInterceptor::_tc_ClientRequestInterceptor, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (PortableInterceptor::_tc_ClientRequestInterceptor, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
diff --git a/TAO/tao/InterfaceC.cpp b/TAO/tao/InterfaceC.cpp
index d415f783852..1849ed31dae 100644
--- a/TAO/tao/InterfaceC.cpp
+++ b/TAO/tao/InterfaceC.cpp
@@ -13693,7 +13693,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::DefinitionKind &_t
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_DefinitionKind, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_DefinitionKind, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -13736,7 +13737,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_IRObject_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_IRObject, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_IRObject, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -13797,7 +13799,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Contained_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_Contained, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_Contained, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -13872,7 +13875,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Contained::Descript
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_Contained::Description, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_Contained::_tc_Description, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -13941,7 +13945,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDefSeq *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDefSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_InterfaceDefSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14010,7 +14015,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDefSeq *&_tao_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ValueDefSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ValueDefSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14079,7 +14085,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ContainedSeq *&_tao
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ContainedSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ContainedSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14145,7 +14152,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructMember *&_tao
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_StructMember, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_StructMember, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14214,7 +14222,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructMemberSeq *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_StructMemberSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_StructMemberSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14280,7 +14289,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Initializer *&_tao_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_Initializer, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_Initializer, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14349,7 +14359,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InitializerSeq *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_InitializerSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_InitializerSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14415,7 +14426,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionMember *&_tao_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_UnionMember, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_UnionMember, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14484,7 +14496,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionMemberSeq *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_UnionMemberSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_UnionMemberSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14553,7 +14566,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_EnumMemberSeq *&_ta
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_EnumMemberSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_EnumMemberSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14605,7 +14619,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_Container, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_Container, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -14680,7 +14695,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container::Descript
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_Container::Description, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_Container::_tc_Description, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14749,7 +14765,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Container::Descript
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_Container::DescriptionSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_Container::_tc_DescriptionSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -14801,7 +14818,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_IDLType_ptr &_tao_e
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_IDLType, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_IDLType, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -14858,7 +14876,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::PrimitiveKind &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_PrimitiveKind, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_PrimitiveKind, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -14901,7 +14920,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_Repository_ptr &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_Repository, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_Repository, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -14962,7 +14982,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ModuleDef_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ModuleDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ModuleDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15037,7 +15058,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ModuleDescription *
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ModuleDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ModuleDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -15089,7 +15111,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ConstantDef_ptr &_t
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ConstantDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ConstantDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15164,7 +15187,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ConstantDescription
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ConstantDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ConstantDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -15216,7 +15240,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_TypedefDef_ptr &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_TypedefDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_TypedefDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15291,7 +15316,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_TypeDescription *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_TypeDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_TypeDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -15343,7 +15369,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StructDef_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_StructDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_StructDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15404,7 +15431,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_UnionDef_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_UnionDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_UnionDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15465,7 +15493,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_EnumDef_ptr &_tao_e
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_EnumDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_EnumDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15526,7 +15555,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AliasDef_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_AliasDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_AliasDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15587,7 +15617,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_PrimitiveDef_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_PrimitiveDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_PrimitiveDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15648,7 +15679,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_StringDef_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_StringDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_StringDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15709,7 +15741,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_WstringDef_ptr &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_WstringDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_WstringDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15770,7 +15803,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_FixedDef_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_FixedDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_FixedDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15831,7 +15865,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_SequenceDef_ptr &_t
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_SequenceDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_SequenceDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15892,7 +15927,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ArrayDef_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ArrayDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ArrayDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -15953,7 +15989,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDef_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ExceptionDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ExceptionDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -16028,7 +16065,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDescriptio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ExceptionDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ExceptionDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16076,7 +16114,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::AttributeMode &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_AttributeMode, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_AttributeMode, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -16119,7 +16158,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttributeDef_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_AttributeDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_AttributeDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -16194,7 +16234,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttributeDescriptio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_AttributeDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_AttributeDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16242,7 +16283,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::OperationMode &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_OperationMode, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_OperationMode, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -16281,7 +16323,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA::ParameterMode &_ta
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ParameterMode, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_ParameterMode, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
@@ -16338,7 +16381,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ParameterDescriptio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ParameterDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ParameterDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16407,7 +16451,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ParDescriptionSeq *
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ParDescriptionSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ParDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16476,7 +16521,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ContextIdSeq *&_tao
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ContextIdSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ContextIdSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16545,7 +16591,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExceptionDefSeq *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ExceptionDefSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ExceptionDefSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16614,7 +16661,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ExcDescriptionSeq *
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ExcDescriptionSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ExcDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16666,7 +16714,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OperationDef_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_OperationDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_OperationDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -16741,7 +16790,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OperationDescriptio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_OperationDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_OperationDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16810,7 +16860,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_RepositoryIdSeq *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_RepositoryIdSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_RepositoryIdSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16879,7 +16930,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_OpDescriptionSeq *&
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_OpDescriptionSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_OpDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -16948,7 +17000,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_AttrDescriptionSeq
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_AttrDescriptionSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_AttrDescriptionSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17000,7 +17053,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDef_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_InterfaceDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_InterfaceDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -17075,7 +17129,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDef::FullI
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDef::FullInterfaceDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_InterfaceDef::_tc_FullInterfaceDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17141,7 +17196,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_InterfaceDescriptio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_InterfaceDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_InterfaceDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17207,7 +17263,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMember *&_tao_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ValueMember, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ValueMember, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17276,7 +17333,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMemberSeq *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ValueMemberSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ValueMemberSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17328,7 +17386,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueMemberDef_ptr
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ValueMemberDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ValueMemberDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -17389,7 +17448,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDef_ptr &_tao_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ValueDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ValueDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -17464,7 +17524,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDef::FullValue
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ValueDef::FullValueDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_ValueDef::_tc_FullValueDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17530,7 +17591,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueDescription *&
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ValueDescription, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ValueDescription, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -17582,7 +17644,8 @@ CORBA::Boolean operator>>= (const CORBA_Any &_tao_any, CORBA_ValueBoxDef_ptr &_t
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_ValueBoxDef, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA_Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA_Object_ptr, 0);
     if (stream.decode (CORBA::_tc_ValueBoxDef, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp
index d83fdb81c26..ccf4a72c359 100644
--- a/TAO/tao/Invocation.cpp
+++ b/TAO/tao/Invocation.cpp
@@ -599,7 +599,9 @@ TAO_GIOP_Twoway_Invocation::invoke (CORBA::ExceptionList &exceptions,
 
           const ACE_Message_Block* cdr =
             this->inp_stream ().start ();
-          CORBA_Any any (tcp, 0, cdr);
+          CORBA_Any any (tcp, 0,
+                         this->inp_stream ().byte_order (),
+                         cdr);
           CORBA_Exception *exception;
 
           ACE_NEW_THROW_EX (exception,
diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp
index b40a702d1a1..5bf8c2c8604 100644
--- a/TAO/tao/MessagingC.cpp
+++ b/TAO/tao/MessagingC.cpp
@@ -2109,7 +2109,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange
     else
     {
       ACE_NEW_RETURN (_tao_elem, Messaging::PriorityRange, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (Messaging::_tc_PriorityRange, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2177,7 +2178,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRa
     else
     {
       ACE_NEW_RETURN (_tao_elem, Messaging::RoutingTypeRange, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (Messaging::_tc_RoutingTypeRange, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2245,7 +2247,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue *
     else
     {
       ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValue, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (Messaging::_tc_PolicyValue, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2316,7 +2319,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSe
     else
     {
       ACE_NEW_RETURN (_tao_elem, Messaging::PolicyValueSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (Messaging::_tc_PolicyValueSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2373,7 +2377,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (Messaging::_tc_ReplyHandler, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (Messaging::_tc_ReplyHandler, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -2429,7 +2434,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::Poller_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (Messaging::_tc_Poller, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (Messaging::_tc_Poller, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp
index 8e266bf50b7..90baedd7f5b 100644
--- a/TAO/tao/NVList.cpp
+++ b/TAO/tao/NVList.cpp
@@ -158,6 +158,7 @@ CORBA_NVList::add_value (const char *name,
           else
             {
               nv->any_._tao_replace (value.type_,
+                                     value.byte_order_,
                                      value.cdr_,
                                      ACE_TRY_ENV);
             }
diff --git a/TAO/tao/ObjectIDList.cpp b/TAO/tao/ObjectIDList.cpp
index a1d777074a1..4432a72ec46 100644
--- a/TAO/tao/ObjectIDList.cpp
+++ b/TAO/tao/ObjectIDList.cpp
@@ -161,7 +161,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_ORB_ObjectIdList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp
index 182c77f7da5..a70192cd541 100644
--- a/TAO/tao/POAC.cpp
+++ b/TAO/tao/POAC.cpp
@@ -173,7 +173,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::ForwardRequest, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::_tc_ForwardRequest, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -1534,7 +1535,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POAManager::AdapterInactive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POAManager::_tc_AdapterInactive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2037,7 +2039,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterAlreadyExists, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_AdapterAlreadyExists, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2171,7 +2174,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterInactive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_AdapterInactive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2305,7 +2309,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::AdapterNonExistent, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_AdapterNonExistent, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2446,7 +2451,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Inv
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::InvalidPolicy, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_InvalidPolicy, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2583,7 +2589,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::NoS
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::NoServant, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_NoServant, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2719,7 +2726,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectAlreadyActive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_ObjectAlreadyActive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2851,7 +2859,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ObjectNotActive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_ObjectNotActive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -2983,7 +2992,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantAlreadyActive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_ServantAlreadyActive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3115,7 +3125,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::ServantNotActive, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_ServantNotActive, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3247,7 +3258,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongAdapter, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_WrongAdapter, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3379,7 +3391,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::POA::WrongPolicy, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::POA::_tc_WrongPolicy, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -3584,7 +3597,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current:
     else
     {
       ACE_NEW_RETURN (_tao_elem, PortableServer::Current::NoContext, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (PortableServer::Current::_tc_NoContext, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index dd5be304cd6..1722ccd8b78 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -617,7 +617,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_PolicyError, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_PolicyError, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -684,7 +685,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_InvalidPolicies, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_InvalidPolicies, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -733,7 +735,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_e
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_Policy, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_Policy, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -805,7 +808,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_PolicyList, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_PolicyList, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -874,7 +878,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_PolicyTypeSeq, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_PolicyTypeSeq, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -922,7 +927,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     if (stream.decode (CORBA::_tc_SetOverrideType, &_tao_elem, 0, ACE_TRY_ENV)
       == CORBA::TypeCode::TRAVERSE_CONTINUE)
       return 1;
diff --git a/TAO/tao/PollableC.cpp b/TAO/tao/PollableC.cpp
index 2d8af8c59ff..cc0b875fa23 100644
--- a/TAO/tao/PollableC.cpp
+++ b/TAO/tao/PollableC.cpp
@@ -876,7 +876,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Pollable_ptr &_tao
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_Pollable, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_Pollable, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -934,7 +935,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DIIPollable_ptr &
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_DIIPollable, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_DIIPollable, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -992,7 +994,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet_ptr &_
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (CORBA::_tc_PollableSet, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (CORBA::_tc_PollableSet, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -1068,7 +1071,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet::NoPos
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_PollableSet::NoPossiblePollable, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_PollableSet::_tc_NoPossiblePollable, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -1135,7 +1139,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet::Unkno
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA_PollableSet::UnknownPollable, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA_PollableSet::_tc_UnknownPollable, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/Services.cpp b/TAO/tao/Services.cpp
index b917c859520..9151bf96840 100644
--- a/TAO/tao/Services.cpp
+++ b/TAO/tao/Services.cpp
@@ -28,30 +28,30 @@
 CORBA::ServiceDetail::_tao_seq_Octet::_tao_seq_Octet (void)
 {}
 CORBA::ServiceDetail::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 CORBA::ServiceDetail::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 CORBA::ServiceDetail::_tao_seq_Octet::_tao_seq_Octet (const _tao_seq_Octet &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 CORBA::ServiceDetail::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor
@@ -72,7 +72,7 @@ CORBA::TypeCode_ptr CORBA::ServiceDetail::_tc__tao_seq_Octet = &_tc_TAO_tc_CORBA
 
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CS_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CS_
 
@@ -80,43 +80,43 @@ CORBA::TypeCode_ptr CORBA::ServiceDetail::_tc__tao_seq_Octet = &_tc_TAO_tc_CORBA
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ULong* tmp = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (length);
-    
+
     if (this->buffer_ != 0)
     {
       CORBA::ULong *old = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
-      
+
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-      
+
       if (this->release_)
         CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::freebuf (old);
-      
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    
+
     CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
-    
+
     CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::~_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CS_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CS_
@@ -128,30 +128,30 @@ CORBA::TypeCode_ptr CORBA::ServiceDetail::_tc__tao_seq_Octet = &_tc_TAO_tc_CORBA
 CORBA::ServiceInformation::_tao_seq_ServiceOption::_tao_seq_ServiceOption (void)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceOption::_tao_seq_ServiceOption (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceOption::_tao_seq_ServiceOption (CORBA::ULong max, CORBA::ULong length, CORBA::ULong *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceOption::_tao_seq_ServiceOption (const _tao_seq_ServiceOption &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceOption::~_tao_seq_ServiceOption (void) // dtor
@@ -162,7 +162,7 @@ CORBA::ServiceInformation::_tao_seq_ServiceOption::~_tao_seq_ServiceOption (void
 
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CS_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CS_
 
@@ -170,43 +170,43 @@ CORBA::ServiceInformation::_tao_seq_ServiceOption::~_tao_seq_ServiceOption (void
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ServiceDetail* tmp = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (length);
-    
+
     if (this->buffer_ != 0)
     {
       CORBA::ServiceDetail *old = ACE_reinterpret_cast (CORBA::ServiceDetail *,this->buffer_);
-      
+
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-      
+
       if (this->release_)
         CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::freebuf (old);
-      
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    
+
     CORBA::ServiceDetail *tmp = ACE_reinterpret_cast (CORBA::ServiceDetail *,this->buffer_);
-    
+
     CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::~_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CS_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CS_
@@ -218,30 +218,30 @@ CORBA::ServiceInformation::_tao_seq_ServiceOption::~_tao_seq_ServiceOption (void
 CORBA::ServiceInformation::_tao_seq_ServiceDetail::_tao_seq_ServiceDetail (void)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceDetail::_tao_seq_ServiceDetail (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ServiceDetail>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceDetail::_tao_seq_ServiceDetail (CORBA::ULong max, CORBA::ULong length, CORBA::ServiceDetail *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ServiceDetail>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceDetail::_tao_seq_ServiceDetail (const _tao_seq_ServiceDetail &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ServiceDetail>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 CORBA::ServiceInformation::_tao_seq_ServiceDetail::~_tao_seq_ServiceDetail (void) // dtor
@@ -293,7 +293,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA::ServiceDetail, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ServiceDetail, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -310,7 +311,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -359,7 +360,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio
     else
     {
       ACE_NEW_RETURN (_tao_elem, CORBA::ServiceInformation, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (CORBA::_tc_ServiceInformation, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -376,7 +378,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio
   ACE_CATCHANY
   {
     delete _tao_elem;
-    return 0; 
+    return 0;
   }
   ACE_ENDTRY;
   return 0;
@@ -390,20 +392,20 @@ ACE_INLINE CORBA::Boolean operator<< (
   if (strm << _tao_sequence.length ())
   {
     // encode all elements
-    
+
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
     {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
+      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
         ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA_ServiceDetail::_tao_seq_Octet *)&_tao_sequence);
       if (oseq->mb ())
         return strm.write_octet_array_mb (oseq->mb ());
       else
         return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
     }
-    
+
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
     return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-  
+
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
   }
   return 0; // error
@@ -417,11 +419,11 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
     // retrieve all the elements
-    
+
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
     if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
     {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
+      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
         ACE_dynamic_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
       oseq->replace (_tao_seq_len, strm.start ());
       oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
@@ -430,16 +432,16 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_
     }
     else
       return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
-    
+
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
     return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-  
+
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
   }
   return 0; // error
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 operator<< (TAO_OutputCDR &strm, const CORBA_ServiceDetail &_tao_aggregate)
 {
   if (
@@ -449,10 +451,10 @@ operator<< (TAO_OutputCDR &strm, const CORBA_ServiceDetail &_tao_aggregate)
     return 1;
   else
     return 0;
-  
+
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail &_tao_aggregate)
 {
   if (
@@ -462,10 +464,10 @@ operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail &_tao_aggregate)
     return 1;
   else
     return 0;
-  
+
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 operator<< (
             TAO_OutputCDR &strm,
             const CORBA_ServiceInformation::_tao_seq_ServiceOption &_tao_sequence
@@ -479,8 +481,8 @@ operator<< (
   return 0; // error
 }
 
-CORBA::Boolean 
-operator>> (TAO_InputCDR &strm, 
+CORBA::Boolean
+operator>> (TAO_InputCDR &strm,
             CORBA_ServiceInformation::_tao_seq_ServiceOption &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
@@ -494,7 +496,7 @@ operator>> (TAO_InputCDR &strm,
   return 0; // error
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 operator<< (
             TAO_OutputCDR &strm,
             const CORBA_ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence
@@ -511,8 +513,8 @@ operator<< (
   return 0; // error
 }
 
-CORBA::Boolean 
-operator>> (TAO_InputCDR &strm, 
+CORBA::Boolean
+operator>> (TAO_InputCDR &strm,
             CORBA_ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
@@ -529,8 +531,8 @@ operator>> (TAO_InputCDR &strm,
   return 0; // error
 }
 
-CORBA::Boolean 
-operator<< (TAO_OutputCDR &strm, 
+CORBA::Boolean
+operator<< (TAO_OutputCDR &strm,
             const CORBA_ServiceInformation &_tao_aggregate)
 {
   if (
@@ -540,10 +542,10 @@ operator<< (TAO_OutputCDR &strm,
     return 1;
   else
     return 0;
-  
+
 }
 
-CORBA::Boolean operator>> (TAO_InputCDR &strm, 
+CORBA::Boolean operator>> (TAO_InputCDR &strm,
                            CORBA_ServiceInformation &_tao_aggregate)
 {
   if (
@@ -553,6 +555,5 @@ CORBA::Boolean operator>> (TAO_InputCDR &strm,
     return 1;
   else
     return 0;
-  
-}
 
+}
diff --git a/TAO/tao/TAOC.cpp b/TAO/tao/TAOC.cpp
index 5481a52e65a..d683dfc6e6c 100644
--- a/TAO/tao/TAOC.cpp
+++ b/TAO/tao/TAOC.cpp
@@ -185,7 +185,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::PrioritySpecificati
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO::PrioritySpecification, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO::_tc_PrioritySpecification, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -234,7 +235,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::ClientPriorityPolic
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (TAO::_tc_ClientPriorityPolicy, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (TAO::_tc_ClientPriorityPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
@@ -447,7 +449,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint
     else
     {
       ACE_NEW_RETURN (_tao_elem, TAO::BufferingConstraint, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TAO::_tc_BufferingConstraint, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -496,7 +499,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO::BufferingConstraint
     CORBA::TypeCode_var type = _tao_any.type ();
     if (!type->equal (TAO::_tc_BufferingConstraintPolicy, ACE_TRY_ENV)) return 0; // not equal
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+    TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                         _tao_any._tao_byte_order ());
     CORBA::Object_var _tao_obj_var;
     ACE_NEW_RETURN (tmp, CORBA::Object_ptr, 0);
     if (stream.decode (TAO::_tc_BufferingConstraintPolicy, &_tao_obj_var.out (), 0, ACE_TRY_ENV)
diff --git a/TAO/tao/TimeBaseC.cpp b/TAO/tao/TimeBaseC.cpp
index 7cc9f733ca1..ec2f84b51b3 100644
--- a/TAO/tao/TimeBaseC.cpp
+++ b/TAO/tao/TimeBaseC.cpp
@@ -174,7 +174,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::UtcT *&_tao_el
     else
     {
       ACE_NEW_RETURN (_tao_elem, TimeBase::UtcT, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TimeBase::_tc_UtcT, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
@@ -240,7 +241,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TimeBase::IntervalT *&_t
     else
     {
       ACE_NEW_RETURN (_tao_elem, TimeBase::IntervalT, 0);
-      TAO_InputCDR stream (_tao_any._tao_get_cdr ());
+      TAO_InputCDR stream (_tao_any._tao_get_cdr (),
+                           _tao_any._tao_byte_order ());
       if (stream.decode (TimeBase::_tc_IntervalT, _tao_elem, 0, ACE_TRY_ENV)
         == CORBA::TypeCode::TRAVERSE_CONTINUE)
       {
diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp
index e62bace6906..ee99cd97eb2 100644
--- a/TAO/tao/Typecode.cpp
+++ b/TAO/tao/Typecode.cpp
@@ -18,6 +18,7 @@
 #include "tao/Exception.h"
 #include "tao/CDR_Interpreter.h"
 #include "tao/Principal.h"
+#include "tao/singletons.h"
 #include "tao/debug.h"
 
 #if !defined (__ACE_INLINE__)
@@ -649,7 +650,7 @@ TC_Private_State::~TC_Private_State (void)
 }
 
 // Point of recursion for equal() and equivalent().
-CORBA::Boolean 
+CORBA::Boolean
 CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
                             CORBA::Boolean equiv_only,
                             CORBA::Environment &ACE_TRY_ENV) const
@@ -660,8 +661,8 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
 
   if (equiv_only)
     {
-      CORBA::TypeCode_var rcvr = 
-        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *, 
+      CORBA::TypeCode_var rcvr =
+        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *,
                                                      this));
 
       CORBA::Boolean status = (this->kind_ == CORBA::tk_alias);
@@ -680,8 +681,8 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
 
       // Added by Bala to check for leaks as content_type duplicates the
       // pointers
-      CORBA::TypeCode_var tcvar = 
-        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *, 
+      CORBA::TypeCode_var tcvar =
+        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *,
                                                      tc));
 
       while (status)
@@ -709,9 +710,9 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
         return 0;
       else
         // typecode kinds are same
-        return this->private_equal (tc, 
+        return this->private_equal (tc,
                                     equiv_only,
-				                            ACE_TRY_ENV);
+                                                            ACE_TRY_ENV);
     }
 }
 
@@ -749,44 +750,44 @@ CORBA_TypeCode::private_equal (CORBA::TypeCode_ptr tc,
       // the kind_ field
       return 1;
     case CORBA::tk_objref:
-      return this->private_equal_objref (tc, 
-                                         equiv_only, 
+      return this->private_equal_objref (tc,
+                                         equiv_only,
                                          ACE_TRY_ENV);
     case CORBA::tk_struct:
-      return this->private_equal_struct (tc, 
-                                         equiv_only, 
+      return this->private_equal_struct (tc,
+                                         equiv_only,
                                          ACE_TRY_ENV);
     case CORBA::tk_union:
-      return this->private_equal_union (tc, 
-                                        equiv_only, 
+      return this->private_equal_union (tc,
+                                        equiv_only,
                                         ACE_TRY_ENV);
     case CORBA::tk_enum:
-      return this->private_equal_enum (tc, 
-                                       equiv_only, 
+      return this->private_equal_enum (tc,
+                                       equiv_only,
                                        ACE_TRY_ENV);
     case CORBA::tk_string:
-      return this->private_equal_string (tc, 
-                                         equiv_only, 
+      return this->private_equal_string (tc,
+                                         equiv_only,
                                          ACE_TRY_ENV);
     case CORBA::tk_wstring:
-      return this->private_equal_wstring (tc, 
-                                          equiv_only, 
+      return this->private_equal_wstring (tc,
+                                          equiv_only,
                                           ACE_TRY_ENV);
     case CORBA::tk_sequence:
-      return this->private_equal_sequence (tc, 
-                                           equiv_only, 
+      return this->private_equal_sequence (tc,
+                                           equiv_only,
                                            ACE_TRY_ENV);
     case CORBA::tk_array:
-      return this->private_equal_array (tc, 
-                                        equiv_only, 
+      return this->private_equal_array (tc,
+                                        equiv_only,
                                         ACE_TRY_ENV);
     case CORBA::tk_alias:
-      return this->private_equal_alias (tc, 
-                                        equiv_only, 
+      return this->private_equal_alias (tc,
+                                        equiv_only,
                                         ACE_TRY_ENV);
     case CORBA::tk_except:
-      return this->private_equal_except (tc, 
-                                         equiv_only, 
+      return this->private_equal_except (tc,
+                                         equiv_only,
                                          ACE_TRY_ENV);
     case ~0u: // indirection
       {
@@ -933,17 +934,17 @@ CORBA_TypeCode::private_equal_struct (CORBA::TypeCode_ptr tc,
 
           if (ACE_OS::strlen (my_member_name) > 1
               && ACE_OS::strlen (tc_member_name) > 1
-              && ACE_OS::strcmp (my_member_name, 
+              && ACE_OS::strcmp (my_member_name,
                                  tc_member_name)) // not same
             return 0;
         }
 
       // now compare the typecodes of the members
-      CORBA::TypeCode_var my_member_tc = this->member_type (i, 
+      CORBA::TypeCode_var my_member_tc = this->member_type (i,
                                                             ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
 
-      CORBA::TypeCode_var tc_member_tc = tc->member_type (i, 
+      CORBA::TypeCode_var tc_member_tc = tc->member_type (i,
                                                           ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
 
@@ -955,7 +956,7 @@ CORBA_TypeCode::private_equal_struct (CORBA::TypeCode_ptr tc,
         continue;
 
       CORBA::Boolean flag =
-        my_member_tc->equ_common (tc_member_tc.in (), 
+        my_member_tc->equ_common (tc_member_tc.in (),
                                   equiv_only,
                                   ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
@@ -1007,7 +1008,7 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
       // Compare names if they exist.
       if (ACE_OS::strlen (my_name) > 1
           && ACE_OS::strlen (tc_name) > 1
-          && ACE_OS::strcmp (my_name, 
+          && ACE_OS::strcmp (my_name,
                              tc_name)) // not same
         return 0;
     }
@@ -1019,7 +1020,7 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
   CORBA::TypeCode_var tc_discrim = tc->discriminator_type (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
 
-  CORBA::Boolean status = my_discrim->equ_common (tc_discrim.in (), 
+  CORBA::Boolean status = my_discrim->equ_common (tc_discrim.in (),
                                                   equiv_only,
                                                   ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
@@ -1074,27 +1075,27 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i, 
+          const char *my_member_name = this->member_name (i,
                                                           ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i, 
+          const char *tc_member_name = tc->member_name (i,
                                                         ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          if (ACE_OS::strlen (my_member_name) > 1 
+          if (ACE_OS::strlen (my_member_name) > 1
               && ACE_OS::strlen (tc_member_name) > 1
-              && ACE_OS::strcmp (my_member_name, 
+              && ACE_OS::strcmp (my_member_name,
                                  tc_member_name)) // not same
             return 0;
         }
 
       // now compare the typecodes of the members
-      CORBA::TypeCode_var my_member_tc = this->member_type (i, 
+      CORBA::TypeCode_var my_member_tc = this->member_type (i,
                                                             ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
 
-      CORBA::TypeCode_var tc_member_tc = tc->member_type (i, 
+      CORBA::TypeCode_var tc_member_tc = tc->member_type (i,
                                                           ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
 
@@ -1105,7 +1106,7 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
           && my_member_tc->root_tc_base_ == tc_member_tc->root_tc_base_)
         continue;
 
-      CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (), 
+      CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (),
                                                       equiv_only,
                                                       ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
@@ -1157,7 +1158,7 @@ CORBA_TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
       // Compare names if they exist.
       if (ACE_OS::strlen (my_name) > 1
           && ACE_OS::strlen (tc_name) > 1
-          && ACE_OS::strcmp (my_name, 
+          && ACE_OS::strcmp (my_name,
                              tc_name)) // not same
         return 0;
     }
@@ -1177,17 +1178,17 @@ CORBA_TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i, 
+          const char *my_member_name = this->member_name (i,
                                                           ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i, 
+          const char *tc_member_name = tc->member_name (i,
                                                         ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          if (ACE_OS::strlen (my_member_name) > 1 
+          if (ACE_OS::strlen (my_member_name) > 1
               && ACE_OS::strlen (tc_member_name) > 1
-              && ACE_OS::strcmp (my_member_name, 
+              && ACE_OS::strcmp (my_member_name,
                                  tc_member_name)) // not same
             return 0;
         }
@@ -1239,7 +1240,7 @@ CORBA_TypeCode::private_equal_sequence (CORBA::TypeCode_ptr tc,
   CORBA::TypeCode_var tc_elem = tc->content_type (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
 
-  CORBA::Boolean status = my_elem->equ_common (tc_elem.in (), 
+  CORBA::Boolean status = my_elem->equ_common (tc_elem.in (),
                                                equiv_only,
                                                ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
@@ -1263,7 +1264,7 @@ CORBA_TypeCode::private_equal_array (CORBA::TypeCode_ptr tc,
                                      CORBA::Environment &ACE_TRY_ENV) const
 {
   // exactly like sequence
-  return this->private_equal_sequence (tc, 
+  return this->private_equal_sequence (tc,
                                        equiv_only,
                                        ACE_TRY_ENV);
 }
@@ -1304,7 +1305,7 @@ CORBA_TypeCode::private_equal_alias (CORBA::TypeCode_ptr tc,
   CORBA::TypeCode_var tc_elem = tc->content_type (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
 
-  return my_elem->equ_common (tc_elem.in (), 
+  return my_elem->equ_common (tc_elem.in (),
                               equiv_only,
                               ACE_TRY_ENV);
 }
@@ -1345,7 +1346,7 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
       // Compare names if they exist.
       if (ACE_OS::strlen (my_name) > 1
           && ACE_OS::strlen (tc_name) > 1
-          && ACE_OS::strcmp (my_name, 
+          && ACE_OS::strcmp (my_name,
                              tc_name)) // not same
         return 0;
     }
@@ -1365,17 +1366,17 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i, 
+          const char *my_member_name = this->member_name (i,
                                                           ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i, 
+          const char *tc_member_name = tc->member_name (i,
                                                         ACE_TRY_ENV);
           ACE_CHECK_RETURN (0);
 
-          if (ACE_OS::strlen (my_member_name) > 1 
+          if (ACE_OS::strlen (my_member_name) > 1
               && ACE_OS::strlen (tc_member_name) > 1
-              && ACE_OS::strcmp (my_member_name, 
+              && ACE_OS::strcmp (my_member_name,
                                  tc_member_name)) // not same
             return 0;
         }
@@ -1387,7 +1388,7 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
       CORBA::TypeCode_var tc_member_tc = tc->member_type (i, ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
 
-      CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (), 
+      CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (),
                                                       equiv_only,
                                                       ACE_TRY_ENV);
       ACE_CHECK_RETURN (0);
@@ -2009,7 +2010,10 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n,
         return 0;
 
       ACE_NEW_THROW_EX (label_list[i],
-                        CORBA::Any (tc.in (), 0, out.begin ()),
+                        CORBA::Any (tc.in (),
+                                    0,
+                                    ACE_CDR_BYTE_ORDER,
+                                    out.begin ()),
                         CORBA::NO_MEMORY ());
       ACE_CHECK_RETURN (0);
 
@@ -2394,6 +2398,60 @@ CORBA::TypeCode::private_alignment (CORBA::Environment &ACE_TRY_ENV)
   return alignment;
 }
 
+// ****************************************************************
+
+CORBA::Boolean
+operator<< (TAO_OutputCDR& cdr, const CORBA::TypeCode *x)
+{
+  ACE_TRY_NEW_ENV
+    {
+      // @@ This function should *not* use the interpreter, there must
+      // be a way to do this with just CDR operations!!!!
+      CORBA::TypeCode::traverse_status status =
+        TAO_MARSHAL_TYPECODE::instance ()->encode (0,
+                                                   &x,
+                                                   0,
+                                                   &cdr,
+                                                   ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (status == CORBA::TypeCode::TRAVERSE_CONTINUE)
+        return 1;
+      // else return 0 at the end of the function
+    }
+  ACE_CATCH (CORBA_Exception, ex)
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+  return 0;
+}
+
+CORBA::Boolean
+operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x)
+{
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::TypeCode::traverse_status status =
+        TAO_MARSHAL_TYPECODE::instance ()->decode (0,
+                                                   &x,
+                                                   0,
+                                                   &cdr,
+                                                   ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
+        return 0;
+    }
+  ACE_CATCH (CORBA_Exception, ex)
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+
+  return 1;
+}
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
 template class TAO_Pseudo_Object_Manager<CORBA_TypeCode,CORBA_TypeCode_var>;
diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h
index 8872251d8af..2dd47a85350 100644
--- a/TAO/tao/Typecode.h
+++ b/TAO/tao/Typecode.h
@@ -30,6 +30,7 @@
 
 // Forward decl.
 class TAO_InputCDR;
+class TAO_OutputCDR;
 
 // A TypeCode describes data.  This one's as thin a wrapper around CDR
 // octet sequences as is practical.  There are guesses here about how
@@ -283,7 +284,7 @@ private:
                              CORBA::Boolean equiv_only,
                              CORBA_Environment &ACE_TRY_ENV =
                                 TAO_default_environment ()) const;
-  // equal() and equivalent() must both recurse, but their 
+  // equal() and equivalent() must both recurse, but their
   // behavior is somewhat different (as defined in CORBA 2.3).
   // This function allows us to reuse the same code by acting
   // as the point of recursion and by adding the equiv_only
@@ -581,6 +582,12 @@ public:
 
 };
 
+// These operators are too complex to be inline....
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
+                                      const CORBA::TypeCode *x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
+                                      CORBA::TypeCode *&x);
+
 #if defined (__ACE_INLINE__)
 # include "tao/Typecode.i"
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/tao/append.cpp b/TAO/tao/append.cpp
index 4ec66535ec4..050ff0d5d71 100644
--- a/TAO/tao/append.cpp
+++ b/TAO/tao/append.cpp
@@ -446,7 +446,8 @@ TAO_Marshal_Union::append (CORBA::TypeCode_ptr  tc,
                 case CORBA::tk_enum:
                   {
                     CORBA::Long l;
-                    TAO_InputCDR stream (member_label->_tao_get_cdr ());
+                    TAO_InputCDR stream (member_label->_tao_get_cdr (),
+                                         member_label->_tao_byte_order ());
                     (void)stream.decode (discrim_tc, &l, 0, ACE_TRY_ENV);
                     if (l == *(CORBA::Long *) &discrim_val)
                       discrim_matched = 1;
diff --git a/TAO/tao/decode.cpp b/TAO/tao/decode.cpp
index f9392425bc4..8882e2717a5 100644
--- a/TAO/tao/decode.cpp
+++ b/TAO/tao/decode.cpp
@@ -209,6 +209,7 @@ TAO_Marshal_Any::decode (CORBA::TypeCode_ptr,
     DEEP_FREE (any->type_, any->value_, 0, ACE_TRY_ENV);
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
+  any->byte_order_ = stream->byte_order ();
   any->cdr_ = ACE_Message_Block::duplicate (out.begin ());
   any->value_ = 0;
 
@@ -799,7 +800,8 @@ TAO_Marshal_Union::decode (CORBA::TypeCode_ptr  tc,
           {
             CORBA::ULong ul;
             TAO_InputCDR stream ((ACE_Message_Block *)
-                                 member_label->_tao_get_cdr ());
+                                 member_label->_tao_get_cdr (),
+                                 member_label->_tao_byte_order ());
             (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV);
             //@@EXC@@ Rethrow CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_MAYBE)?
             ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
diff --git a/TAO/tao/deep_free.cpp b/TAO/tao/deep_free.cpp
index 39bb3a3b134..f0b502d15e3 100644
--- a/TAO/tao/deep_free.cpp
+++ b/TAO/tao/deep_free.cpp
@@ -95,11 +95,11 @@ DEEP_FREE (CORBA::TypeCode_ptr  param,
       retval = TAO_Marshal_Sequence::deep_free (param, source, dest, ACE_TRY_ENV);
       // @@ (JP) This takes care of a memory leak we had for recursive unions
       // and unions that contain an anonymous sequence. For unions that contain
-      // typedef'd sequences and other cases where the union member is a 
+      // typedef'd sequences and other cases where the union member is a
       // pointer, we still have leaks. These are not so easy to fix for all
       // cases. What we need is Carlos' _tao_destroy() method in the stubs.
-      delete ACE_reinterpret_cast (TAO_Base_Sequence *, 
-                                   ACE_const_cast (void *, 
+      delete ACE_reinterpret_cast (TAO_Base_Sequence *,
+                                   ACE_const_cast (void *,
                                                    source));
       break;
     case CORBA::tk_array:
@@ -186,7 +186,7 @@ TAO_Marshal_Struct::deep_free (CORBA::TypeCode_ptr  tc,
     }
 
   // In case this hasn't been done yet.
-  source = ptr_align_binary (source, 
+  source = ptr_align_binary (source,
                              tc->alignment (ACE_TRY_ENV));
   ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
 
@@ -368,6 +368,8 @@ TAO_Marshal_Union::deep_free (CORBA::TypeCode_ptr  tc,
       CORBA::TypeCode_var type = member_label->type ();
       switch (type->kind (ACE_TRY_ENV))
         {
+          // @@ This is not going to work, it assumes that the CDR
+          // stream is in the same byte order.
         case CORBA::tk_short:
           if (*(CORBA::Short *)member_label->_tao_get_cdr ()->base () ==
               *(CORBA::Short *)discrim_val)
diff --git a/TAO/tao/encode.cpp b/TAO/tao/encode.cpp
index e5f1cbf6c32..8157b33905f 100644
--- a/TAO/tao/encode.cpp
+++ b/TAO/tao/encode.cpp
@@ -510,7 +510,8 @@ TAO_Marshal_Union::encode (CORBA::TypeCode_ptr tc,
         case CORBA::tk_enum:
           {
             CORBA::ULong ul;
-            TAO_InputCDR stream (member_label->_tao_get_cdr ());
+            TAO_InputCDR stream (member_label->_tao_get_cdr (),
+                                 member_label->_tao_byte_order ());
             (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV);
             ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP);
             if (ul == *(CORBA::ULong *) discrim_val)
diff --git a/TAO/tao/skip.cpp b/TAO/tao/skip.cpp
index 74e6dcabd53..de8d3194ef1 100644
--- a/TAO/tao/skip.cpp
+++ b/TAO/tao/skip.cpp
@@ -442,7 +442,8 @@ TAO_Marshal_Union::skip (CORBA::TypeCode_ptr  tc,
             case CORBA::tk_enum:
               {
                 CORBA::ULong ul;
-                TAO_InputCDR stream (member_label->_tao_get_cdr ());
+                TAO_InputCDR stream (member_label->_tao_get_cdr (),
+                                     member_label->_tao_byte_order ());
                 (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV);
                 if (ul == *(CORBA::ULong *) &discrim_val)
                   discrim_matched = 1;