New diffs

3 files changed, 2478 insertions, 0 deletions

diff --git a/TAO/tao/IORManipulation/diffs/IORC.cpp.diff b/TAO/tao/IORManipulation/diffs/IORC.cpp.diff
new file mode 100644
index 00000000000..1aa3b1df64d
--- /dev/null
+++ b/TAO/tao/IORManipulation/diffs/IORC.cpp.diff
@@ -0,0 +1,1163 @@
+1c1
+< /* -*- C++ -*- $Id$ */
+---
+> /* -*- C++ -*- $Id$ */
+11,13d10
+< #include "tao/Typecode.h"
+< #include "tao/Any.h"
+< #include  "tao/ORB.h"
+18a16
+> 
+20,23c18,19
+< TAO_IOP::EmptyProfileList::EmptyProfileList (void)
+<   : CORBA_UserException ("IDL:TAO_IOP/EmptyProfileList:1.0")
+< {
+< }
+---
+> TAO_IOP::TAO_IOR_Manipulation::TAO_IOR_Manipulation (void)
+> {}
+25,28c21,23
+< // destructor - all members are of self managing types
+< TAO_IOP::EmptyProfileList::~EmptyProfileList (void)
+< {
+< }
+---
+> // destructor
+> TAO_IOP::TAO_IOR_Manipulation::~TAO_IOR_Manipulation (void)
+> {}
+30,69c25,26
+< void TAO_IOP::EmptyProfileList::_tao_any_destructor (void *x)
+< {
+<   EmptyProfileList *tmp = ACE_static_cast (EmptyProfileList*,x);
+<   delete tmp;
+< }
+< 
+< // copy constructor
+< TAO_IOP::EmptyProfileList::EmptyProfileList (const ::TAO_IOP::EmptyProfileList &_tao_excp)
+<   : CORBA_UserException (_tao_excp._id ())
+< {
+< }
+< 
+< // assignment operator
+< TAO_IOP::EmptyProfileList&
+< TAO_IOP::EmptyProfileList::operator= (const ::TAO_IOP::EmptyProfileList &_tao_excp)
+< {
+< 
+<   this->CORBA_UserException::operator= (_tao_excp);
+<   return *this;
+< }
+< 
+< // narrow
+< TAO_IOP::EmptyProfileList *
+< TAO_IOP::EmptyProfileList::_downcast (CORBA::Exception *exc)
+< {
+<   if (!ACE_OS::strcmp ("IDL:TAO_IOP/EmptyProfileList:1.0", exc->_id ())) // same type
+<     return ACE_dynamic_cast (EmptyProfileList *, exc);
+<   else
+<     return 0;
+< }
+< 
+< 
+< void TAO_IOP::EmptyProfileList::_raise ()
+< {
+<   TAO_RAISE(*this);
+< }
+< 
+< 
+< void TAO_IOP::EmptyProfileList::_tao_encode (
+<     TAO_OutputCDR &cdr,
+---
+> TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_narrow (
+>     CORBA::Object_ptr obj,
+71c28
+<   ) const
+---
+>   )
+73,75c30
+<   if (cdr << *this)
+<     return;
+<   ACE_THROW (CORBA::MARSHAL ());
+---
+>   return TAO_IOR_Manipulation::_unchecked_narrow (obj, ACE_TRY_ENV);
+78,81c33,35
+< 
+< void TAO_IOP::EmptyProfileList::_tao_decode (
+<     TAO_InputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+---
+> TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_unchecked_narrow (
+>     CORBA::Object_ptr obj,
+>     CORBA::Environment &
+84,86c38,52
+<   if (cdr >> *this)
+<     return;
+<   ACE_THROW (CORBA::MARSHAL ());
+---
+>   if (CORBA::is_nil (obj))
+>     return TAO_IOR_Manipulation::_nil ();
+>   return
+>       ACE_reinterpret_cast
+>         (
+>           TAO_IOR_Manipulation_ptr,
+>             obj->_tao_QueryInterface
+>               (
+>                 ACE_reinterpret_cast
+>                   (
+>                     ptr_arith_t,
+>                     &TAO_IOR_Manipulation::_narrow
+>                   )
+>               )
+>         );
+89,90c55,56
+< // TAO extension - the _alloc method
+< CORBA::Exception *TAO_IOP::EmptyProfileList::_alloc (void)
+---
+> TAO_IOP::TAO_IOR_Manipulation_ptr
+> TAO_IOP::TAO_IOR_Manipulation::_duplicate (TAO_IOR_Manipulation_ptr obj)
+92,94c58,60
+<   CORBA::Exception *retval = 0;
+<   ACE_NEW_RETURN (retval, ::TAO_IOP::EmptyProfileList, 0);
+<   return retval;
+---
+>   if (!CORBA::is_nil (obj))
+>     obj->_add_ref ();
+>   return obj;
+97,115d62
+< static const CORBA::Long _oc_TAO_IOP_EmptyProfileList[] =
+< {
+<   TAO_ENCAP_BYTE_ORDER, // byte order
+<   33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f5f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x456d7074), ACE_NTOHL (0x7950726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:TAO_IOP/EmptyProfileList:1.0
+<   17, ACE_NTOHL (0x456d7074), ACE_NTOHL (0x7950726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x0),  // name = EmptyProfileList
+<   0, // member count
+< };
+< static CORBA::TypeCode _tc_TAO_tc_TAO_IOP_EmptyProfileList (CORBA::tk_except, sizeof (_oc_TAO_IOP_EmptyProfileList), (char *) &_oc_TAO_IOP_EmptyProfileList, 0, sizeof (TAO_IOP::EmptyProfileList));
+< TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+< TAO_NAMESPACE_BEGIN (TAO_IOP)
+< TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmptyProfileList, &_tc_TAO_tc_TAO_IOP_EmptyProfileList)
+< TAO_NAMESPACE_END
+< 
+< // TAO extension - the virtual _type method
+< CORBA::TypeCode_ptr TAO_IOP::EmptyProfileList::_type (void) const
+< {
+<   return ::TAO_IOP::_tc_EmptyProfileList;
+< }
+< 
+117,118c64
+< TAO_IOP::NotFound::NotFound (void)
+<   : CORBA_UserException ("IDL:TAO_IOP/NotFound:1.0")
+---
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::EmptyProfileList (void)
+123c69
+< TAO_IOP::NotFound::~NotFound (void)
+---
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::~EmptyProfileList (void)
+127,132d72
+< void TAO_IOP::NotFound::_tao_any_destructor (void *x)
+< {
+<   NotFound *tmp = ACE_static_cast (NotFound*,x);
+<   delete tmp;
+< }
+< 
+134c74
+< TAO_IOP::NotFound::NotFound (const ::TAO_IOP::NotFound &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::EmptyProfileList (const ::TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &_tao_excp)
+140,141c80,81
+< TAO_IOP::NotFound&
+< TAO_IOP::NotFound::operator= (const ::TAO_IOP::NotFound &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList&
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::operator= (const ::TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &_tao_excp)
+149,150c89,90
+< TAO_IOP::NotFound *
+< TAO_IOP::NotFound::_downcast (CORBA::Exception *exc)
+---
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *
+> TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_downcast (CORBA::Exception *exc)
+152,153c92,93
+<   if (!ACE_OS::strcmp ("IDL:TAO_IOP/NotFound:1.0", exc->_id ())) // same type
+<     return ACE_dynamic_cast (NotFound *, exc);
+---
+>   if (!ACE_OS::strcmp ("IDL:TAO_IOP/TAO_IOR_Manipulation/EmptyProfileList:1.0", exc->_id ())) // same type
+>     return ACE_dynamic_cast (EmptyProfileList *, exc);
+159c99
+< void TAO_IOP::NotFound::_raise ()
+---
+> void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_raise ()
+165,168c105,107
+< void TAO_IOP::NotFound::_tao_encode (
+<     TAO_OutputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   ) const
+---
+> void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV) const
+170,171d108
+<   if (cdr << *this)
+<     return;
+176,179c113,115
+< void TAO_IOP::NotFound::_tao_decode (
+<     TAO_InputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+---
+> void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV)
+181,182d116
+<   if (cdr >> *this)
+<     return;
+187c121
+< CORBA::Exception *TAO_IOP::NotFound::_alloc (void)
+---
+> CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_alloc (void)
+190c124
+<   ACE_NEW_RETURN (retval, ::TAO_IOP::NotFound, 0);
+---
+>   ACE_NEW_RETURN (retval, ::TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList, 0);
+194,212d127
+< static const CORBA::Long _oc_TAO_IOP_NotFound[] =
+< {
+<   TAO_ENCAP_BYTE_ORDER, // byte order
+<   25, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f5f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:TAO_IOP/NotFound:1.0
+<   9, ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x0),  // name = NotFound
+<   0, // member count
+< };
+< static CORBA::TypeCode _tc_TAO_tc_TAO_IOP_NotFound (CORBA::tk_except, sizeof (_oc_TAO_IOP_NotFound), (char *) &_oc_TAO_IOP_NotFound, 0, sizeof (TAO_IOP::NotFound));
+< TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+< TAO_NAMESPACE_BEGIN (TAO_IOP)
+< TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NotFound, &_tc_TAO_tc_TAO_IOP_NotFound)
+< TAO_NAMESPACE_END
+< 
+< // TAO extension - the virtual _type method
+< CORBA::TypeCode_ptr TAO_IOP::NotFound::_type (void) const
+< {
+<   return ::TAO_IOP::_tc_NotFound;
+< }
+< 
+214,215c129
+< TAO_IOP::Duplicate::Duplicate (void)
+<   : CORBA_UserException ("IDL:TAO_IOP/Duplicate:1.0")
+---
+> TAO_IOP::TAO_IOR_Manipulation::NotFound::NotFound (void)
+220c134
+< TAO_IOP::Duplicate::~Duplicate (void)
+---
+> TAO_IOP::TAO_IOR_Manipulation::NotFound::~NotFound (void)
+224,229d137
+< void TAO_IOP::Duplicate::_tao_any_destructor (void *x)
+< {
+<   Duplicate *tmp = ACE_static_cast (Duplicate*,x);
+<   delete tmp;
+< }
+< 
+231c139
+< TAO_IOP::Duplicate::Duplicate (const ::TAO_IOP::Duplicate &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::NotFound::NotFound (const ::TAO_IOP::TAO_IOR_Manipulation::NotFound &_tao_excp)
+237,238c145,146
+< TAO_IOP::Duplicate&
+< TAO_IOP::Duplicate::operator= (const ::TAO_IOP::Duplicate &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::NotFound&
+> TAO_IOP::TAO_IOR_Manipulation::NotFound::operator= (const ::TAO_IOP::TAO_IOR_Manipulation::NotFound &_tao_excp)
+246,247c154,155
+< TAO_IOP::Duplicate *
+< TAO_IOP::Duplicate::_downcast (CORBA::Exception *exc)
+---
+> TAO_IOP::TAO_IOR_Manipulation::NotFound *
+> TAO_IOP::TAO_IOR_Manipulation::NotFound::_downcast (CORBA::Exception *exc)
+249,250c157,158
+<   if (!ACE_OS::strcmp ("IDL:TAO_IOP/Duplicate:1.0", exc->_id ())) // same type
+<     return ACE_dynamic_cast (Duplicate *, exc);
+---
+>   if (!ACE_OS::strcmp ("IDL:TAO_IOP/TAO_IOR_Manipulation/NotFound:1.0", exc->_id ())) // same type
+>     return ACE_dynamic_cast (NotFound *, exc);
+256c164
+< void TAO_IOP::Duplicate::_raise ()
+---
+> void TAO_IOP::TAO_IOR_Manipulation::NotFound::_raise ()
+262,265c170,172
+< void TAO_IOP::Duplicate::_tao_encode (
+<     TAO_OutputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   ) const
+---
+> void TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV) const
+267,268d173
+<   if (cdr << *this)
+<     return;
+273,276c178,180
+< void TAO_IOP::Duplicate::_tao_decode (
+<     TAO_InputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+---
+> void TAO_IOP::TAO_IOR_Manipulation::NotFound::_tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV)
+278,279d181
+<   if (cdr >> *this)
+<     return;
+284c186
+< CORBA::Exception *TAO_IOP::Duplicate::_alloc (void)
+---
+> CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::NotFound::_alloc (void)
+287c189
+<   ACE_NEW_RETURN (retval, ::TAO_IOP::Duplicate, 0);
+---
+>   ACE_NEW_RETURN (retval, ::TAO_IOP::TAO_IOR_Manipulation::NotFound, 0);
+291,309d192
+< static const CORBA::Long _oc_TAO_IOP_Duplicate[] =
+< {
+<   TAO_ENCAP_BYTE_ORDER, // byte order
+<   26, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f5f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x4475706c), ACE_NTOHL (0x69636174), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:TAO_IOP/Duplicate:1.0
+<   10, ACE_NTOHL (0x4475706c), ACE_NTOHL (0x69636174), ACE_NTOHL (0x65000000),  // name = Duplicate
+<   0, // member count
+< };
+< static CORBA::TypeCode _tc_TAO_tc_TAO_IOP_Duplicate (CORBA::tk_except, sizeof (_oc_TAO_IOP_Duplicate), (char *) &_oc_TAO_IOP_Duplicate, 0, sizeof (TAO_IOP::Duplicate));
+< TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+< TAO_NAMESPACE_BEGIN (TAO_IOP)
+< TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Duplicate, &_tc_TAO_tc_TAO_IOP_Duplicate)
+< TAO_NAMESPACE_END
+< 
+< // TAO extension - the virtual _type method
+< CORBA::TypeCode_ptr TAO_IOP::Duplicate::_type (void) const
+< {
+<   return ::TAO_IOP::_tc_Duplicate;
+< }
+< 
+311,312c194
+< TAO_IOP::Invalid_IOR::Invalid_IOR (void)
+<   : CORBA_UserException ("IDL:TAO_IOP/Invalid_IOR:1.0")
+---
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate::Duplicate (void)
+317c199
+< TAO_IOP::Invalid_IOR::~Invalid_IOR (void)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate::~Duplicate (void)
+321,326d202
+< void TAO_IOP::Invalid_IOR::_tao_any_destructor (void *x)
+< {
+<   Invalid_IOR *tmp = ACE_static_cast (Invalid_IOR*,x);
+<   delete tmp;
+< }
+< 
+328c204
+< TAO_IOP::Invalid_IOR::Invalid_IOR (const ::TAO_IOP::Invalid_IOR &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate::Duplicate (const ::TAO_IOP::TAO_IOR_Manipulation::Duplicate &_tao_excp)
+334,335c210,211
+< TAO_IOP::Invalid_IOR&
+< TAO_IOP::Invalid_IOR::operator= (const ::TAO_IOP::Invalid_IOR &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate&
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate::operator= (const ::TAO_IOP::TAO_IOR_Manipulation::Duplicate &_tao_excp)
+343,344c219,220
+< TAO_IOP::Invalid_IOR *
+< TAO_IOP::Invalid_IOR::_downcast (CORBA::Exception *exc)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate *
+> TAO_IOP::TAO_IOR_Manipulation::Duplicate::_downcast (CORBA::Exception *exc)
+346,347c222,223
+<   if (!ACE_OS::strcmp ("IDL:TAO_IOP/Invalid_IOR:1.0", exc->_id ())) // same type
+<     return ACE_dynamic_cast (Invalid_IOR *, exc);
+---
+>   if (!ACE_OS::strcmp ("IDL:TAO_IOP/TAO_IOR_Manipulation/Duplicate:1.0", exc->_id ())) // same type
+>     return ACE_dynamic_cast (Duplicate *, exc);
+353c229
+< void TAO_IOP::Invalid_IOR::_raise ()
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_raise ()
+359,362c235,237
+< void TAO_IOP::Invalid_IOR::_tao_encode (
+<     TAO_OutputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   ) const
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV) const
+364,365d238
+<   if (cdr << *this)
+<     return;
+370,373c243,245
+< void TAO_IOP::Invalid_IOR::_tao_decode (
+<     TAO_InputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV)
+375,376d246
+<   if (cdr >> *this)
+<     return;
+381c251
+< CORBA::Exception *TAO_IOP::Invalid_IOR::_alloc (void)
+---
+> CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Duplicate::_alloc (void)
+384c254
+<   ACE_NEW_RETURN (retval, ::TAO_IOP::Invalid_IOR, 0);
+---
+>   ACE_NEW_RETURN (retval, ::TAO_IOP::TAO_IOR_Manipulation::Duplicate, 0);
+388,406d257
+< static const CORBA::Long _oc_TAO_IOP_Invalid_IOR[] =
+< {
+<   TAO_ENCAP_BYTE_ORDER, // byte order
+<   28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f5f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x496e7661), ACE_NTOHL (0x6c69645f), ACE_NTOHL (0x494f523a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:TAO_IOP/Invalid_IOR:1.0
+<   12, ACE_NTOHL (0x496e7661), ACE_NTOHL (0x6c69645f), ACE_NTOHL (0x494f5200),  // name = Invalid_IOR
+<   0, // member count
+< };
+< static CORBA::TypeCode _tc_TAO_tc_TAO_IOP_Invalid_IOR (CORBA::tk_except, sizeof (_oc_TAO_IOP_Invalid_IOR), (char *) &_oc_TAO_IOP_Invalid_IOR, 0, sizeof (TAO_IOP::Invalid_IOR));
+< TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+< TAO_NAMESPACE_BEGIN (TAO_IOP)
+< TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Invalid_IOR, &_tc_TAO_tc_TAO_IOP_Invalid_IOR)
+< TAO_NAMESPACE_END
+< 
+< // TAO extension - the virtual _type method
+< CORBA::TypeCode_ptr TAO_IOP::Invalid_IOR::_type (void) const
+< {
+<   return ::TAO_IOP::_tc_Invalid_IOR;
+< }
+< 
+408,409c259
+< TAO_IOP::MultiProfileList::MultiProfileList (void)
+<   : CORBA_UserException ("IDL:TAO_IOP/MultiProfileList:1.0")
+---
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::Invalid_IOR (void)
+414c264
+< TAO_IOP::MultiProfileList::~MultiProfileList (void)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::~Invalid_IOR (void)
+418,423d267
+< void TAO_IOP::MultiProfileList::_tao_any_destructor (void *x)
+< {
+<   MultiProfileList *tmp = ACE_static_cast (MultiProfileList*,x);
+<   delete tmp;
+< }
+< 
+425c269
+< TAO_IOP::MultiProfileList::MultiProfileList (const ::TAO_IOP::MultiProfileList &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::Invalid_IOR (const ::TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &_tao_excp)
+431,432c275,276
+< TAO_IOP::MultiProfileList&
+< TAO_IOP::MultiProfileList::operator= (const ::TAO_IOP::MultiProfileList &_tao_excp)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR&
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::operator= (const ::TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &_tao_excp)
+440,441c284,285
+< TAO_IOP::MultiProfileList *
+< TAO_IOP::MultiProfileList::_downcast (CORBA::Exception *exc)
+---
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *
+> TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_downcast (CORBA::Exception *exc)
+443,444c287,288
+<   if (!ACE_OS::strcmp ("IDL:TAO_IOP/MultiProfileList:1.0", exc->_id ())) // same type
+<     return ACE_dynamic_cast (MultiProfileList *, exc);
+---
+>   if (!ACE_OS::strcmp ("IDL:TAO_IOP/TAO_IOR_Manipulation/Invalid_IOR:1.0", exc->_id ())) // same type
+>     return ACE_dynamic_cast (Invalid_IOR *, exc);
+450c294
+< void TAO_IOP::MultiProfileList::_raise ()
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_raise ()
+456,459c300,302
+< void TAO_IOP::MultiProfileList::_tao_encode (
+<     TAO_OutputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   ) const
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV) const
+461,462d303
+<   if (cdr << *this)
+<     return;
+467,470c308,310
+< void TAO_IOP::MultiProfileList::_tao_decode (
+<     TAO_InputCDR &cdr,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+---
+> void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &ACE_TRY_ENV)
+472,473d311
+<   if (cdr >> *this)
+<     return;
+478c316
+< CORBA::Exception *TAO_IOP::MultiProfileList::_alloc (void)
+---
+> CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_alloc (void)
+481c319
+<   ACE_NEW_RETURN (retval, ::TAO_IOP::MultiProfileList, 0);
+---
+>   ACE_NEW_RETURN (retval, ::TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR, 0);
+485,496d322
+< static const CORBA::Long _oc_TAO_IOP_MultiProfileList[] =
+< {
+<   TAO_ENCAP_BYTE_ORDER, // byte order
+<   33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f5f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x4d756c74), ACE_NTOHL (0x6950726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:TAO_IOP/MultiProfileList:1.0
+<   17, ACE_NTOHL (0x4d756c74), ACE_NTOHL (0x6950726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x0),  // name = MultiProfileList
+<   0, // member count
+< };
+< static CORBA::TypeCode _tc_TAO_tc_TAO_IOP_MultiProfileList (CORBA::tk_except, sizeof (_oc_TAO_IOP_MultiProfileList), (char *) &_oc_TAO_IOP_MultiProfileList, 0, sizeof (TAO_IOP::MultiProfileList));
+< TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+< TAO_NAMESPACE_BEGIN (TAO_IOP)
+< TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_MultiProfileList, &_tc_TAO_tc_TAO_IOP_MultiProfileList)
+< TAO_NAMESPACE_END
+498,621d323
+< // TAO extension - the virtual _type method
+< CORBA::TypeCode_ptr TAO_IOP::MultiProfileList::_type (void) const
+< {
+<   return ::TAO_IOP::_tc_MultiProfileList;
+< }
+< 
+< 
+< // default constructor
+< TAO_IOP::TAO_IOR_Property::TAO_IOR_Property (void)
+< {}
+< 
+< // destructor
+< TAO_IOP::TAO_IOR_Property::~TAO_IOR_Property (void)
+< {}
+< 
+< TAO_IOP::TAO_IOR_Property_ptr TAO_IOP::TAO_IOR_Property::_narrow (
+<     CORBA::Object_ptr obj,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+< {
+<   return TAO_IOR_Property::_unchecked_narrow (obj, ACE_TRY_ENV);
+< }
+< 
+< TAO_IOP::TAO_IOR_Property_ptr TAO_IOP::TAO_IOR_Property::_unchecked_narrow (
+<     CORBA::Object_ptr obj,
+<     CORBA::Environment &
+<   )
+< {
+<   if (CORBA::is_nil (obj))
+<     return TAO_IOR_Property::_nil ();
+<   return
+<       ACE_reinterpret_cast
+<         (
+<           TAO_IOR_Property_ptr,
+<             obj->_tao_QueryInterface
+<               (
+<                 ACE_reinterpret_cast
+<                   (
+<                     ptr_arith_t,
+<                     &TAO_IOR_Property::_narrow
+<                   )
+<               )
+<         );
+< }
+< 
+< TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property::_duplicate (TAO_IOR_Property_ptr obj)
+< {
+<   if (!CORBA::is_nil (obj))
+<     obj->_add_ref ();
+<   return obj;
+< }
+< 
+< void *TAO_IOP::TAO_IOR_Property::_tao_QueryInterface (ptr_arith_t type)
+< {
+<   void *retv = 0;
+<   if (type == ACE_reinterpret_cast
+<     (ptr_arith_t,
+<       &ACE_NESTED_CLASS (::TAO_IOP, TAO_IOR_Property)::_narrow))
+<     retv = ACE_reinterpret_cast (void*, this);
+<   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+<     retv = ACE_reinterpret_cast (void *,
+<       ACE_static_cast (CORBA::Object_ptr, this));
+< 
+<   if (retv)
+<     this->_add_ref ();
+<   return retv;
+< }
+< 
+< const char* TAO_IOP::TAO_IOR_Property::_interface_repository_id (void) const
+< {
+<   return "IDL:TAO_IOP/TAO_IOR_Property:1.0";
+< }
+< 
+< 
+< 
+< 
+< // default constructor
+< TAO_IOP::TAO_IOR_Manipulation::TAO_IOR_Manipulation (void)
+< {}
+< 
+< // destructor
+< TAO_IOP::TAO_IOR_Manipulation::~TAO_IOR_Manipulation (void)
+< {}
+< 
+< TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_narrow (
+<     CORBA::Object_ptr obj,
+<     CORBA::Environment &ACE_TRY_ENV
+<   )
+< {
+<   return TAO_IOR_Manipulation::_unchecked_narrow (obj, ACE_TRY_ENV);
+< }
+< 
+< TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_unchecked_narrow (
+<     CORBA::Object_ptr obj,
+<     CORBA::Environment &
+<   )
+< {
+<   if (CORBA::is_nil (obj))
+<     return TAO_IOR_Manipulation::_nil ();
+<   return
+<       ACE_reinterpret_cast
+<         (
+<           TAO_IOR_Manipulation_ptr,
+<             obj->_tao_QueryInterface
+<               (
+<                 ACE_reinterpret_cast
+<                   (
+<                     ptr_arith_t,
+<                     &TAO_IOR_Manipulation::_narrow
+<                   )
+<               )
+<         );
+< }
+< 
+< TAO_IOP::TAO_IOR_Manipulation_ptr
+< TAO_IOP::TAO_IOR_Manipulation::_duplicate (TAO_IOR_Manipulation_ptr obj)
+< {
+<   if (!CORBA::is_nil (obj))
+<     obj->_add_ref ();
+<   return obj;
+< }
+< 
+< 
+623c325
+< 
+---
+>   
+633c335
+< 
+---
+>     
+642c344
+< 
+---
+>         
+645c347
+< 
+---
+>       
+649c351
+< 
+---
+>   
+664c366
+< 
+---
+>   
+669c371
+< 
+---
+>   
+674c376
+< 
+---
+>     
+681c383
+<   void
+---
+>   void 
+698c400
+< 
+---
+>   
+702c404
+< #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+---
+> #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+714c416
+<   :
+---
+>   : 
+719c421
+< #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+---
+> #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+723c425
+<   :
+---
+>   : 
+728c430
+< #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+---
+> #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+732c434
+<   :
+---
+>   : 
+737c439
+< #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+---
+> #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+761c463
+< 
+---
+>     
+772,1213d473
+< 
+< 
+< void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::EmptyProfileList &_tao_elem) // copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << _tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_EmptyProfileList,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin ()
+<     );
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, TAO_IOP::EmptyProfileList *_tao_elem) // non copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << *_tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_EmptyProfileList,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin (),
+<       1,
+<       _tao_elem,
+<       TAO_IOP::EmptyProfileList::_tao_any_destructor
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::EmptyProfileList *&_tao_elem)
+< {
+<   return _tao_any >>= ACE_const_cast(
+<       const TAO_IOP::EmptyProfileList*&,
+<       _tao_elem
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO_IOP::EmptyProfileList *&_tao_elem)
+< {
+<   _tao_elem = 0;
+<   ACE_TRY_NEW_ENV
+<   {
+<     CORBA::TypeCode_var type = _tao_any.type ();
+<     if (!type->equivalent (TAO_IOP::_tc_EmptyProfileList, ACE_TRY_ENV)) // not equal
+<       {
+<         return 0;
+<       }
+<     ACE_TRY_CHECK;
+<     if (_tao_any.any_owns_data ())
+<     {
+<       _tao_elem = (TAO_IOP::EmptyProfileList *)_tao_any.value ();
+<       return 1;
+<     }
+<     else
+<     {
+<       TAO_IOP::EmptyProfileList *tmp;
+<       ACE_NEW_RETURN (tmp, TAO_IOP::EmptyProfileList, 0);
+<       TAO_InputCDR stream (
+<           _tao_any._tao_get_cdr (),
+<           _tao_any._tao_byte_order ()
+<         );
+<       CORBA::String_var interface_repository_id;
+<       if (!(stream >> interface_repository_id.out ()))
+<         return 0;
+<       if (ACE_OS::strcmp (
+<           interface_repository_id.in (),
+<           "IDL:TAO_IOP/EmptyProfileList:1.0"))
+<         return 0;
+<       if (stream >> *tmp)
+<       {
+<         ((CORBA::Any *)&_tao_any)->_tao_replace (
+<             TAO_IOP::_tc_EmptyProfileList,
+<             1,
+<             tmp,
+<             TAO_IOP::EmptyProfileList::_tao_any_destructor
+<           );
+<         _tao_elem = tmp;
+<         return 1;
+<       }
+<       else
+<       {
+<         delete tmp;
+<       }
+<     }
+<   }
+<   ACE_CATCHANY
+<   {
+<   }
+<   ACE_ENDTRY;
+<   return 0;
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::NotFound &_tao_elem) // copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << _tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_NotFound,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin ()
+<     );
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, TAO_IOP::NotFound *_tao_elem) // non copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << *_tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_NotFound,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin (),
+<       1,
+<       _tao_elem,
+<       TAO_IOP::NotFound::_tao_any_destructor
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::NotFound *&_tao_elem)
+< {
+<   return _tao_any >>= ACE_const_cast(
+<       const TAO_IOP::NotFound*&,
+<       _tao_elem
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO_IOP::NotFound *&_tao_elem)
+< {
+<   _tao_elem = 0;
+<   ACE_TRY_NEW_ENV
+<   {
+<     CORBA::TypeCode_var type = _tao_any.type ();
+<     if (!type->equivalent (TAO_IOP::_tc_NotFound, ACE_TRY_ENV)) // not equal
+<       {
+<         return 0;
+<       }
+<     ACE_TRY_CHECK;
+<     if (_tao_any.any_owns_data ())
+<     {
+<       _tao_elem = (TAO_IOP::NotFound *)_tao_any.value ();
+<       return 1;
+<     }
+<     else
+<     {
+<       TAO_IOP::NotFound *tmp;
+<       ACE_NEW_RETURN (tmp, TAO_IOP::NotFound, 0);
+<       TAO_InputCDR stream (
+<           _tao_any._tao_get_cdr (),
+<           _tao_any._tao_byte_order ()
+<         );
+<       CORBA::String_var interface_repository_id;
+<       if (!(stream >> interface_repository_id.out ()))
+<         return 0;
+<       if (ACE_OS::strcmp (
+<           interface_repository_id.in (),
+<           "IDL:TAO_IOP/NotFound:1.0"))
+<         return 0;
+<       if (stream >> *tmp)
+<       {
+<         ((CORBA::Any *)&_tao_any)->_tao_replace (
+<             TAO_IOP::_tc_NotFound,
+<             1,
+<             tmp,
+<             TAO_IOP::NotFound::_tao_any_destructor
+<           );
+<         _tao_elem = tmp;
+<         return 1;
+<       }
+<       else
+<       {
+<         delete tmp;
+<       }
+<     }
+<   }
+<   ACE_CATCHANY
+<   {
+<   }
+<   ACE_ENDTRY;
+<   return 0;
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::Duplicate &_tao_elem) // copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << _tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_Duplicate,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin ()
+<     );
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, TAO_IOP::Duplicate *_tao_elem) // non copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << *_tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_Duplicate,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin (),
+<       1,
+<       _tao_elem,
+<       TAO_IOP::Duplicate::_tao_any_destructor
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::Duplicate *&_tao_elem)
+< {
+<   return _tao_any >>= ACE_const_cast(
+<       const TAO_IOP::Duplicate*&,
+<       _tao_elem
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO_IOP::Duplicate *&_tao_elem)
+< {
+<   _tao_elem = 0;
+<   ACE_TRY_NEW_ENV
+<   {
+<     CORBA::TypeCode_var type = _tao_any.type ();
+<     if (!type->equivalent (TAO_IOP::_tc_Duplicate, ACE_TRY_ENV)) // not equal
+<       {
+<         return 0;
+<       }
+<     ACE_TRY_CHECK;
+<     if (_tao_any.any_owns_data ())
+<     {
+<       _tao_elem = (TAO_IOP::Duplicate *)_tao_any.value ();
+<       return 1;
+<     }
+<     else
+<     {
+<       TAO_IOP::Duplicate *tmp;
+<       ACE_NEW_RETURN (tmp, TAO_IOP::Duplicate, 0);
+<       TAO_InputCDR stream (
+<           _tao_any._tao_get_cdr (),
+<           _tao_any._tao_byte_order ()
+<         );
+<       CORBA::String_var interface_repository_id;
+<       if (!(stream >> interface_repository_id.out ()))
+<         return 0;
+<       if (ACE_OS::strcmp (
+<           interface_repository_id.in (),
+<           "IDL:TAO_IOP/Duplicate:1.0"))
+<         return 0;
+<       if (stream >> *tmp)
+<       {
+<         ((CORBA::Any *)&_tao_any)->_tao_replace (
+<             TAO_IOP::_tc_Duplicate,
+<             1,
+<             tmp,
+<             TAO_IOP::Duplicate::_tao_any_destructor
+<           );
+<         _tao_elem = tmp;
+<         return 1;
+<       }
+<       else
+<       {
+<         delete tmp;
+<       }
+<     }
+<   }
+<   ACE_CATCHANY
+<   {
+<   }
+<   ACE_ENDTRY;
+<   return 0;
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::Invalid_IOR &_tao_elem) // copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << _tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_Invalid_IOR,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin ()
+<     );
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, TAO_IOP::Invalid_IOR *_tao_elem) // non copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << *_tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_Invalid_IOR,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin (),
+<       1,
+<       _tao_elem,
+<       TAO_IOP::Invalid_IOR::_tao_any_destructor
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::Invalid_IOR *&_tao_elem)
+< {
+<   return _tao_any >>= ACE_const_cast(
+<       const TAO_IOP::Invalid_IOR*&,
+<       _tao_elem
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO_IOP::Invalid_IOR *&_tao_elem)
+< {
+<   _tao_elem = 0;
+<   ACE_TRY_NEW_ENV
+<   {
+<     CORBA::TypeCode_var type = _tao_any.type ();
+<     if (!type->equivalent (TAO_IOP::_tc_Invalid_IOR, ACE_TRY_ENV)) // not equal
+<       {
+<         return 0;
+<       }
+<     ACE_TRY_CHECK;
+<     if (_tao_any.any_owns_data ())
+<     {
+<       _tao_elem = (TAO_IOP::Invalid_IOR *)_tao_any.value ();
+<       return 1;
+<     }
+<     else
+<     {
+<       TAO_IOP::Invalid_IOR *tmp;
+<       ACE_NEW_RETURN (tmp, TAO_IOP::Invalid_IOR, 0);
+<       TAO_InputCDR stream (
+<           _tao_any._tao_get_cdr (),
+<           _tao_any._tao_byte_order ()
+<         );
+<       CORBA::String_var interface_repository_id;
+<       if (!(stream >> interface_repository_id.out ()))
+<         return 0;
+<       if (ACE_OS::strcmp (
+<           interface_repository_id.in (),
+<           "IDL:TAO_IOP/Invalid_IOR:1.0"))
+<         return 0;
+<       if (stream >> *tmp)
+<       {
+<         ((CORBA::Any *)&_tao_any)->_tao_replace (
+<             TAO_IOP::_tc_Invalid_IOR,
+<             1,
+<             tmp,
+<             TAO_IOP::Invalid_IOR::_tao_any_destructor
+<           );
+<         _tao_elem = tmp;
+<         return 1;
+<       }
+<       else
+<       {
+<         delete tmp;
+<       }
+<     }
+<   }
+<   ACE_CATCHANY
+<   {
+<   }
+<   ACE_ENDTRY;
+<   return 0;
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, const TAO_IOP::MultiProfileList &_tao_elem) // copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << _tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_MultiProfileList,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin ()
+<     );
+< }
+< 
+< void operator<<= (CORBA::Any &_tao_any, TAO_IOP::MultiProfileList *_tao_elem) // non copying
+< {
+<   TAO_OutputCDR stream;
+<   stream << *_tao_elem;
+<   _tao_any._tao_replace (
+<       TAO_IOP::_tc_MultiProfileList,
+<       TAO_ENCAP_BYTE_ORDER,
+<       stream.begin (),
+<       1,
+<       _tao_elem,
+<       TAO_IOP::MultiProfileList::_tao_any_destructor
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, TAO_IOP::MultiProfileList *&_tao_elem)
+< {
+<   return _tao_any >>= ACE_const_cast(
+<       const TAO_IOP::MultiProfileList*&,
+<       _tao_elem
+<     );
+< }
+< 
+< CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const TAO_IOP::MultiProfileList *&_tao_elem)
+< {
+<   _tao_elem = 0;
+<   ACE_TRY_NEW_ENV
+<   {
+<     CORBA::TypeCode_var type = _tao_any.type ();
+<     if (!type->equivalent (TAO_IOP::_tc_MultiProfileList, ACE_TRY_ENV)) // not equal
+<       {
+<         return 0;
+<       }
+<     ACE_TRY_CHECK;
+<     if (_tao_any.any_owns_data ())
+<     {
+<       _tao_elem = (TAO_IOP::MultiProfileList *)_tao_any.value ();
+<       return 1;
+<     }
+<     else
+<     {
+<       TAO_IOP::MultiProfileList *tmp;
+<       ACE_NEW_RETURN (tmp, TAO_IOP::MultiProfileList, 0);
+<       TAO_InputCDR stream (
+<           _tao_any._tao_get_cdr (),
+<           _tao_any._tao_byte_order ()
+<         );
+<       CORBA::String_var interface_repository_id;
+<       if (!(stream >> interface_repository_id.out ()))
+<         return 0;
+<       if (ACE_OS::strcmp (
+<           interface_repository_id.in (),
+<           "IDL:TAO_IOP/MultiProfileList:1.0"))
+<         return 0;
+<       if (stream >> *tmp)
+<       {
+<         ((CORBA::Any *)&_tao_any)->_tao_replace (
+<             TAO_IOP::_tc_MultiProfileList,
+<             1,
+<             tmp,
+<             TAO_IOP::MultiProfileList::_tao_any_destructor
+<           );
+<         _tao_elem = tmp;
+<         return 1;
+<       }
+<       else
+<       {
+<         delete tmp;
+<       }
+<     }
+<   }
+<   ACE_CATCHANY
+<   {
+<   }
+<   ACE_ENDTRY;
+<   return 0;
+< }
+< 
+1216,1222d475
+<     template class TAO_Object_Manager<TAO_IOP::TAO_IOR_Property,TAO_IOP::TAO_IOR_Property_var>;
+<   #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+<   #  pragma instantiate TAO_Object_Manager<TAO_IOP::TAO_IOR_Property,TAO_IOP::TAO_IOR_Property_var>
+< #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+< 
+< #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+<     defined (ACE_HAS_GNU_REPO)
+1226a480
+> 
diff --git a/TAO/tao/IORManipulation/diffs/IORC.h.diff b/TAO/tao/IORManipulation/diffs/IORC.h.diff
new file mode 100644
index 00000000000..3f4845df567
--- /dev/null
+++ b/TAO/tao/IORManipulation/diffs/IORC.h.diff
@@ -0,0 +1,1044 @@
+1c1
+< /* -*- C++ -*- $Id$ */
+---
+> /* -*- C++ -*- $Id$ */
+13d12
+< #include "ace/pre.h"
+14a14,17
+> #include "tao/Object.h"
+> #include "tao/Exception.h"
+> #include "tao/Environment.h"
+> #include "tao/Sequence.h"
+15a19,21
+> #if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION)
+> #include "ace/streams.h"
+> #endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */
+21,26d26
+< #include "ior_manip_export.h"
+< #include "tao/Exception.h"
+< #include "tao/Object.h"
+< #include "tao/Environment.h"
+< #include "tao/Sequence.h"
+< #include "tao/CDR.h"
+31c31
+< #define TAO_EXPORT_MACRO TAO_IORManip_Export
+---
+> #define TAO_EXPORT_MACRO TAO_Export
+37c37
+< #  define TAO_EXPORT_NESTED_MACRO TAO_IORManip_Export
+---
+> #  define TAO_EXPORT_NESTED_MACRO TAO_Export
+50,51c50,51
+< #if !defined (_TAO_IOP_EMPTYPROFILELIST_CH_)
+< #define _TAO_IOP_EMPTYPROFILELIST_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___PTR_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION___PTR_CH_
+53,55c53,54
+<   class TAO_IORManip_Export EmptyProfileList : public CORBA::UserException
+<   {
+<   public:
+---
+>   class TAO_IOR_Manipulation;
+>   typedef TAO_IOR_Manipulation *TAO_IOR_Manipulation_ptr;
+57,83d55
+<     EmptyProfileList (void); // default ctor
+<     EmptyProfileList (const EmptyProfileList &); // copy ctor
+<     ~EmptyProfileList (void);
+<     static void _tao_any_destructor (void*);
+<     EmptyProfileList &operator= (const EmptyProfileList &);
+< 
+< 
+<     virtual void _raise (void);
+< 
+<     virtual void _tao_encode (
+<         TAO_OutputCDR &,
+<         CORBA::Environment &) const;
+<     virtual void _tao_decode (
+<         TAO_InputCDR &,
+<         CORBA::Environment &);
+< 
+<     static EmptyProfileList *_downcast (CORBA::Exception *);
+< 
+< 
+<     // = TAO extension
+<     static CORBA::Exception *_alloc (void);
+<     virtual CORBA::TypeCode_ptr _type (void) const;
+<   }; // exception TAO_IOP::EmptyProfileList
+< 
+<     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmptyProfileList;
+< 
+< 
+87,88c59,60
+< #if !defined (_TAO_IOP_NOTFOUND_CH_)
+< #define _TAO_IOP_NOTFOUND_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___VAR_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION___VAR_CH_
+90c62
+<   class TAO_IORManip_Export NotFound : public CORBA::UserException
+---
+>   class TAO_Export TAO_IOR_Manipulation_var : public TAO_Base_var
+92a65,68
+>     TAO_IOR_Manipulation_var (void); // default constructor
+>     TAO_IOR_Manipulation_var (TAO_IOR_Manipulation_ptr p) : ptr_ (p) {}
+>     TAO_IOR_Manipulation_var (const TAO_IOR_Manipulation_var &); // copy constructor
+>     ~TAO_IOR_Manipulation_var (void); // destructor
+94,98c70,72
+<     NotFound (void); // default ctor
+<     NotFound (const NotFound &); // copy ctor
+<     ~NotFound (void);
+<     static void _tao_any_destructor (void*);
+<     NotFound &operator= (const NotFound &);
+---
+>     TAO_IOR_Manipulation_var &operator= (TAO_IOR_Manipulation_ptr);
+>     TAO_IOR_Manipulation_var &operator= (const TAO_IOR_Manipulation_var &);
+>     TAO_IOR_Manipulation_ptr operator-> (void) const;
+99a74,81
+>     operator const TAO_IOR_Manipulation_ptr &() const;
+>     operator TAO_IOR_Manipulation_ptr &();
+>     // in, inout, out, _retn
+>     TAO_IOR_Manipulation_ptr in (void) const;
+>     TAO_IOR_Manipulation_ptr &inout (void);
+>     TAO_IOR_Manipulation_ptr &out (void);
+>     TAO_IOR_Manipulation_ptr _retn (void);
+>     TAO_IOR_Manipulation_ptr ptr (void) const;
+101c83,88
+<     virtual void _raise (void);
+---
+>   private:
+>     TAO_IOR_Manipulation_ptr ptr_;
+>     // Unimplemented - prevents widening assignment.
+>     TAO_IOR_Manipulation_var (const TAO_Base_var &rhs);
+>     TAO_IOR_Manipulation_var &operator= (const TAO_Base_var &rhs);
+>   };
+103,108d89
+<     virtual void _tao_encode (
+<         TAO_OutputCDR &,
+<         CORBA::Environment &) const;
+<     virtual void _tao_decode (
+<         TAO_InputCDR &,
+<         CORBA::Environment &);
+110,120d90
+<     static NotFound *_downcast (CORBA::Exception *);
+< 
+< 
+<     // = TAO extension
+<     static CORBA::Exception *_alloc (void);
+<     virtual CORBA::TypeCode_ptr _type (void) const;
+<   }; // exception TAO_IOP::NotFound
+< 
+<     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NotFound;
+< 
+< 
+124,125c94,95
+< #if !defined (_TAO_IOP_DUPLICATE_CH_)
+< #define _TAO_IOP_DUPLICATE_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___OUT_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION___OUT_CH_
+127c97
+<   class TAO_IORManip_Export Duplicate : public CORBA::UserException
+---
+>   class TAO_Export TAO_IOR_Manipulation_out
+129a100,108
+>     TAO_IOR_Manipulation_out (TAO_IOR_Manipulation_ptr &);
+>     TAO_IOR_Manipulation_out (TAO_IOR_Manipulation_var &);
+>     TAO_IOR_Manipulation_out (const TAO_IOR_Manipulation_out &);
+>     TAO_IOR_Manipulation_out &operator= (const TAO_IOR_Manipulation_out &);
+>     TAO_IOR_Manipulation_out &operator= (const TAO_IOR_Manipulation_var &);
+>     TAO_IOR_Manipulation_out &operator= (TAO_IOR_Manipulation_ptr);
+>     operator TAO_IOR_Manipulation_ptr &();
+>     TAO_IOR_Manipulation_ptr &ptr (void);
+>     TAO_IOR_Manipulation_ptr operator-> (void);
+131,135c110,112
+<     Duplicate (void); // default ctor
+<     Duplicate (const Duplicate &); // copy ctor
+<     ~Duplicate (void);
+<     static void _tao_any_destructor (void*);
+<     Duplicate &operator= (const Duplicate &);
+---
+>   private:
+>     TAO_IOR_Manipulation_ptr &ptr_;
+>   };
+138,157d114
+<     virtual void _raise (void);
+< 
+<     virtual void _tao_encode (
+<         TAO_OutputCDR &,
+<         CORBA::Environment &) const;
+<     virtual void _tao_decode (
+<         TAO_InputCDR &,
+<         CORBA::Environment &);
+< 
+<     static Duplicate *_downcast (CORBA::Exception *);
+< 
+< 
+<     // = TAO extension
+<     static CORBA::Exception *_alloc (void);
+<     virtual CORBA::TypeCode_ptr _type (void) const;
+<   }; // exception TAO_IOP::Duplicate
+< 
+<     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Duplicate;
+< 
+< 
+161,162c118,119
+< #if !defined (_TAO_IOP_INVALID_IOR_CH_)
+< #define _TAO_IOP_INVALID_IOR_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION_CH_
+164c121
+<   class TAO_IORManip_Export Invalid_IOR : public CORBA::UserException
+---
+> class TAO_Export TAO_IOR_Manipulation : public virtual CORBA_Object
+166a124,127
+>   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+>     typedef TAO_IOR_Manipulation_ptr _ptr_type;
+>     typedef TAO_IOR_Manipulation_var _var_type;
+>   #endif /* ! __GNUC__ || g++ >= 2.8 */
+168,172c129,144
+<     Invalid_IOR (void); // default ctor
+<     Invalid_IOR (const Invalid_IOR &); // copy ctor
+<     ~Invalid_IOR (void);
+<     static void _tao_any_destructor (void*);
+<     Invalid_IOR &operator= (const Invalid_IOR &);
+---
+>     // the static operations
+>     static TAO_IOR_Manipulation_ptr _duplicate (TAO_IOR_Manipulation_ptr obj);
+>     static TAO_IOR_Manipulation_ptr _narrow (
+>         CORBA::Object_ptr obj,
+>         CORBA::Environment &ACE_TRY_ENV =
+>           TAO_default_environment ()
+>       );
+>     static TAO_IOR_Manipulation_ptr _unchecked_narrow (
+>         CORBA::Object_ptr obj,
+>         CORBA::Environment &ACE_TRY_ENV =
+>           TAO_default_environment ()
+>       );
+>     static TAO_IOR_Manipulation_ptr _nil (void)
+>       {
+>         return (TAO_IOR_Manipulation_ptr)0;
+>       }
+175c147,148
+<     virtual void _raise (void);
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_EMPTYPROFILELIST_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION_EMPTYPROFILELIST_CH_
+177,182c150,152
+<     virtual void _tao_encode (
+<         TAO_OutputCDR &,
+<         CORBA::Environment &) const;
+<     virtual void _tao_decode (
+<         TAO_InputCDR &,
+<         CORBA::Environment &);
+---
+>     class TAO_Export EmptyProfileList : public CORBA::UserException
+>     {
+>     public:
+184d153
+<     static Invalid_IOR *_downcast (CORBA::Exception *);
+185a155,158
+>     EmptyProfileList (void); // default ctor
+>     EmptyProfileList (const EmptyProfileList &); // copy ctor
+>     ~EmptyProfileList (void);
+>     EmptyProfileList &operator= (const EmptyProfileList &);
+187,190d159
+<     // = TAO extension
+<     static CORBA::Exception *_alloc (void);
+<     virtual CORBA::TypeCode_ptr _type (void) const;
+<   }; // exception TAO_IOP::Invalid_IOR
+192,211d160
+<     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Invalid_IOR;
+< 
+< 
+< #endif /* end #if !defined */
+< 
+< 
+< #if !defined (_TAO_IOP_MULTIPROFILELIST_CH_)
+< #define _TAO_IOP_MULTIPROFILELIST_CH_
+< 
+<   class TAO_IORManip_Export MultiProfileList : public CORBA::UserException
+<   {
+<   public:
+< 
+<     MultiProfileList (void); // default ctor
+<     MultiProfileList (const MultiProfileList &); // copy ctor
+<     ~MultiProfileList (void);
+<     static void _tao_any_destructor (void*);
+<     MultiProfileList &operator= (const MultiProfileList &);
+< 
+< 
+221c170
+<     static MultiProfileList *_downcast (CORBA::Exception *);
+---
+>     static EmptyProfileList *_downcast (CORBA::Exception *);
+226,227d174
+<     virtual CORBA::TypeCode_ptr _type (void) const;
+<   }; // exception TAO_IOP::MultiProfileList
+229c176
+<     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_MultiProfileList;
+---
+>   }; // exception TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList
+235,236c182,183
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY___PTR_CH_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY___PTR_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_NOTFOUND_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION_NOTFOUND_CH_
+238,247c185
+<   class TAO_IOR_Property;
+<   typedef TAO_IOR_Property *TAO_IOR_Property_ptr;
+< 
+< #endif /* end #if !defined */
+< 
+< 
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY___VAR_CH_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY___VAR_CH_
+< 
+<   class TAO_IORManip_Export TAO_IOR_Property_var : public TAO_Base_var
+---
+>   class TAO_Export NotFound : public CORBA::UserException
+250,253d187
+<     TAO_IOR_Property_var (void); // default constructor
+<     TAO_IOR_Property_var (TAO_IOR_Property_ptr p) : ptr_ (p) {}
+<     TAO_IOR_Property_var (const TAO_IOR_Property_var &); // copy constructor
+<     ~TAO_IOR_Property_var (void); // destructor
+255,257d188
+<     TAO_IOR_Property_var &operator= (TAO_IOR_Property_ptr);
+<     TAO_IOR_Property_var &operator= (const TAO_IOR_Property_var &);
+<     TAO_IOR_Property_ptr operator-> (void) const;
+259,266c190,193
+<     operator const TAO_IOR_Property_ptr &() const;
+<     operator TAO_IOR_Property_ptr &();
+<     // in, inout, out, _retn
+<     TAO_IOR_Property_ptr in (void) const;
+<     TAO_IOR_Property_ptr &inout (void);
+<     TAO_IOR_Property_ptr &out (void);
+<     TAO_IOR_Property_ptr _retn (void);
+<     TAO_IOR_Property_ptr ptr (void) const;
+---
+>   NotFound (void); // default ctor
+>   NotFound (const NotFound &); // copy ctor
+>   ~NotFound (void);
+>   NotFound &operator= (const NotFound &);
+268,273d194
+<   private:
+<     TAO_IOR_Property_ptr ptr_;
+<     // Unimplemented - prevents widening assignment.
+<     TAO_IOR_Property_var (const TAO_Base_var &rhs);
+<     TAO_IOR_Property_var &operator= (const TAO_Base_var &rhs);
+<   };
+274a196
+>   virtual void _raise (void);
+276c198,203
+< #endif /* end #if !defined */
+---
+>   virtual void _tao_encode (
+>       TAO_OutputCDR &,
+>       CORBA::Environment &) const;
+>   virtual void _tao_decode (
+>       TAO_InputCDR &,
+>       CORBA::Environment &);
+277a205
+>   static NotFound *_downcast (CORBA::Exception *);
+279,280d206
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY___OUT_CH_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY___OUT_CH_
+282,293c208,209
+<   class TAO_IORManip_Export TAO_IOR_Property_out
+<   {
+<   public:
+<     TAO_IOR_Property_out (TAO_IOR_Property_ptr &);
+<     TAO_IOR_Property_out (TAO_IOR_Property_var &);
+<     TAO_IOR_Property_out (const TAO_IOR_Property_out &);
+<     TAO_IOR_Property_out &operator= (const TAO_IOR_Property_out &);
+<     TAO_IOR_Property_out &operator= (const TAO_IOR_Property_var &);
+<     TAO_IOR_Property_out &operator= (TAO_IOR_Property_ptr);
+<     operator TAO_IOR_Property_ptr &();
+<     TAO_IOR_Property_ptr &ptr (void);
+<     TAO_IOR_Property_ptr operator-> (void);
+---
+>   // = TAO extension
+>   static CORBA::Exception *_alloc (void);
+295,297c211
+<   private:
+<     TAO_IOR_Property_ptr &ptr_;
+<   };
+---
+> }; // exception TAO_IOP::TAO_IOR_Manipulation::NotFound
+303,304c217,218
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY_CH_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_DUPLICATE_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION_DUPLICATE_CH_
+306,312c220,222
+< class TAO_IORManip_Export TAO_IOR_Property : public virtual CORBA_Object
+<   {
+<   public:
+<   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+<     typedef TAO_IOR_Property_ptr _ptr_type;
+<     typedef TAO_IOR_Property_var _var_type;
+<   #endif /* ! __GNUC__ || g++ >= 2.8 */
+---
+> class TAO_Export Duplicate : public CORBA::UserException
+> {
+> public:
+314,329d223
+<     // the static operations
+<     static TAO_IOR_Property_ptr _duplicate (TAO_IOR_Property_ptr obj);
+<     static TAO_IOR_Property_ptr _narrow (
+<         CORBA::Object_ptr obj,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       );
+<     static TAO_IOR_Property_ptr _unchecked_narrow (
+<         CORBA::Object_ptr obj,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       );
+<     static TAO_IOR_Property_ptr _nil (void)
+<       {
+<         return (TAO_IOR_Property_ptr)0;
+<       }
+331,339c225,228
+<     virtual CORBA::Boolean set_property (
+<         CORBA::Object_ptr ior,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       )
+<       ACE_THROW_SPEC ((
+<         CORBA::SystemException,
+<         TAO_IOP::Invalid_IOR
+<       )) = 0;
+---
+> Duplicate (void); // default ctor
+> Duplicate (const Duplicate &); // copy ctor
+> ~Duplicate (void);
+> Duplicate &operator= (const Duplicate &);
+341,350d229
+<     virtual CORBA::Boolean set_primary (
+<         CORBA::Object_ptr ior1,
+<         CORBA::Object_ptr ior2,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       )
+<       ACE_THROW_SPEC ((
+<         CORBA::SystemException,
+<         TAO_IOP::Duplicate
+<       )) = 0;
+352,360c231
+<     virtual CORBA::Object_ptr get_primary (
+<         CORBA::Object_ptr ior,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       )
+<       ACE_THROW_SPEC ((
+<         CORBA::SystemException,
+<         TAO_IOP::NotFound
+<       )) = 0;
+---
+> virtual void _raise (void);
+362,369c233,238
+<     virtual CORBA::Boolean is_primary_set (
+<         CORBA::Object_ptr ior,
+<         CORBA::Environment &ACE_TRY_ENV =
+<           TAO_default_environment ()
+<       )
+<       ACE_THROW_SPEC ((
+<         CORBA::SystemException
+<       )) = 0;
+---
+> virtual void _tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &) const;
+> virtual void _tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &);
+371c240
+<     virtual void *_tao_QueryInterface (ptr_arith_t type);
+---
+> static Duplicate *_downcast (CORBA::Exception *);
+373d241
+<     virtual const char* _interface_repository_id (void) const;
+375,381c243,244
+<   protected:
+<     TAO_IOR_Property (void);
+<     virtual ~TAO_IOR_Property (void);
+<   private:
+<     TAO_IOR_Property (const TAO_IOR_Property &);
+<     void operator= (const TAO_IOR_Property &);
+< };
+---
+> // = TAO extension
+> static CORBA::Exception *_alloc (void);
+382a246
+> }; // exception TAO_IOP::TAO_IOR_Manipulation::Duplicate
+384d247
+< #endif /* end #if !defined */
+386,392d248
+< 
+< #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___PTR_CH_)
+< #define _TAO_IOP_TAO_IOR_MANIPULATION___PTR_CH_
+< 
+< class TAO_IOR_Manipulation;
+< typedef TAO_IOR_Manipulation *TAO_IOR_Manipulation_ptr;
+< 
+396,397c252,253
+< #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___VAR_CH_)
+< #define _TAO_IOP_TAO_IOR_MANIPULATION___VAR_CH_
+---
+> #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_INVALID_IOR_CH_)
+> #define _TAO_IOP_TAO_IOR_MANIPULATION_INVALID_IOR_CH_
+399c255
+< class TAO_IORManip_Export TAO_IOR_Manipulation_var : public TAO_Base_var
+---
+> class TAO_Export Invalid_IOR : public CORBA::UserException
+402,405d257
+<   TAO_IOR_Manipulation_var (void); // default constructor
+<   TAO_IOR_Manipulation_var (TAO_IOR_Manipulation_ptr p) : ptr_ (p) {}
+<   TAO_IOR_Manipulation_var (const TAO_IOR_Manipulation_var &); // copy constructor
+<   ~TAO_IOR_Manipulation_var (void); // destructor
+407,409d258
+<   TAO_IOR_Manipulation_var &operator= (TAO_IOR_Manipulation_ptr);
+<   TAO_IOR_Manipulation_var &operator= (const TAO_IOR_Manipulation_var &);
+<   TAO_IOR_Manipulation_ptr operator-> (void) const;
+411,418c260,263
+<   operator const TAO_IOR_Manipulation_ptr &() const;
+<   operator TAO_IOR_Manipulation_ptr &();
+<   // in, inout, out, _retn
+<   TAO_IOR_Manipulation_ptr in (void) const;
+<   TAO_IOR_Manipulation_ptr &inout (void);
+<   TAO_IOR_Manipulation_ptr &out (void);
+<   TAO_IOR_Manipulation_ptr _retn (void);
+<   TAO_IOR_Manipulation_ptr ptr (void) const;
+---
+> Invalid_IOR (void); // default ctor
+> Invalid_IOR (const Invalid_IOR &); // copy ctor
+> ~Invalid_IOR (void);
+> Invalid_IOR &operator= (const Invalid_IOR &);
+420,425d264
+< private:
+<   TAO_IOR_Manipulation_ptr ptr_;
+<   // Unimplemented - prevents widening assignment.
+<   TAO_IOR_Manipulation_var (const TAO_Base_var &rhs);
+<   TAO_IOR_Manipulation_var &operator= (const TAO_Base_var &rhs);
+< };
+426a266
+> virtual void _raise (void);
+428c268,273
+< #endif /* end #if !defined */
+---
+> virtual void _tao_encode (
+>     TAO_OutputCDR &,
+>     CORBA::Environment &) const;
+> virtual void _tao_decode (
+>     TAO_InputCDR &,
+>     CORBA::Environment &);
+429a275
+> static Invalid_IOR *_downcast (CORBA::Exception *);
+431,432d276
+< #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION___OUT_CH_)
+< #define _TAO_IOP_TAO_IOR_MANIPULATION___OUT_CH_
+434,445c278,279
+< class TAO_IORManip_Export TAO_IOR_Manipulation_out
+< {
+< public:
+<   TAO_IOR_Manipulation_out (TAO_IOR_Manipulation_ptr &);
+<   TAO_IOR_Manipulation_out (TAO_IOR_Manipulation_var &);
+<   TAO_IOR_Manipulation_out (const TAO_IOR_Manipulation_out &);
+<   TAO_IOR_Manipulation_out &operator= (const TAO_IOR_Manipulation_out &);
+<   TAO_IOR_Manipulation_out &operator= (const TAO_IOR_Manipulation_var &);
+<   TAO_IOR_Manipulation_out &operator= (TAO_IOR_Manipulation_ptr);
+<   operator TAO_IOR_Manipulation_ptr &();
+<   TAO_IOR_Manipulation_ptr &ptr (void);
+<   TAO_IOR_Manipulation_ptr operator-> (void);
+---
+> // = TAO extension
+> static CORBA::Exception *_alloc (void);
+447,449c281
+< private:
+<   TAO_IOR_Manipulation_ptr &ptr_;
+< };
+---
+> }; // exception TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR
+455,483d286
+< #if !defined (_TAO_IOP_TAO_IOR_MANIPULATION_CH_)
+< #define _TAO_IOP_TAO_IOR_MANIPULATION_CH_
+< 
+< class TAO_IORManip_Export TAO_IOR_Manipulation : public virtual CORBA_Object
+< {
+< public:
+< #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+<   typedef TAO_IOR_Manipulation_ptr _ptr_type;
+<   typedef TAO_IOR_Manipulation_var _var_type;
+< #endif /* ! __GNUC__ || g++ >= 2.8 */
+< 
+<   // the static operations
+<   static TAO_IOR_Manipulation_ptr _duplicate (TAO_IOR_Manipulation_ptr obj);
+<   static TAO_IOR_Manipulation_ptr _narrow (
+<       CORBA::Object_ptr obj,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     );
+<   static TAO_IOR_Manipulation_ptr _unchecked_narrow (
+<       CORBA::Object_ptr obj,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     );
+<   static TAO_IOR_Manipulation_ptr _nil (void)
+<     {
+<       return (TAO_IOR_Manipulation_ptr)0;
+<     }
+< 
+< 
+489,492c292,295
+<     class _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList : public TAO_Unbounded_Base_Sequence
+<     {
+<     public:
+<       // = Initialization and termination methods.
+---
+>   class _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList : public TAO_Unbounded_Base_Sequence
+>   {
+>   public:
+>     // = Initialization and termination methods.
+494,518c297,321
+<       _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (void);
+<       _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (CORBA::ULong maximum);
+<       _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (CORBA::ULong maximum,
+<         CORBA::ULong length,
+<         CORBA::Object* *value,
+<         CORBA::Boolean release = 0);
+<       _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList(const _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &rhs);
+<       virtual ~_TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (void);
+<       _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &operator= (const _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &rhs);
+<       TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index) const;
+<       static CORBA::Object **allocbuf (CORBA::ULong nelems);
+<       static void freebuf (CORBA::Object **buffer);
+<       // The Base_Sequence functions, please see tao/Sequence.h
+<       virtual void _allocate_buffer (CORBA::ULong length);
+<       virtual void _deallocate_buffer (void);
+<       CORBA::Object* *get_buffer (CORBA::Boolean orphan = 0);
+<       const CORBA::Object* *get_buffer (void) const;
+<       virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+<       virtual void _downcast (
+<           void* target,
+<           CORBA_Object *src,
+<           CORBA_Environment &ACE_TRY_ENV =
+<             TAO_default_environment ()
+<         );
+<       virtual CORBA_Object* _upcast (void *src) const;
+---
+>     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (void);
+>     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (CORBA::ULong maximum);
+>     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (CORBA::ULong maximum,
+>       CORBA::ULong length,
+>       CORBA::Object* *value,
+>       CORBA::Boolean release = 0);
+>     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList(const _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &rhs);
+>     virtual ~_TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList (void);
+>     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &operator= (const _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList &rhs);
+>     TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index) const;
+>     static CORBA::Object **allocbuf (CORBA::ULong nelems);
+>     static void freebuf (CORBA::Object **buffer);
+>     // The Base_Sequence functions, please see tao/Sequence.h
+>     virtual void _allocate_buffer (CORBA::ULong length);
+>     virtual void _deallocate_buffer (void);
+>     CORBA::Object* *get_buffer (CORBA::Boolean orphan = 0);
+>     const CORBA::Object* *get_buffer (void) const;
+>     virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+>     virtual void _downcast (
+>         void* target,
+>         CORBA_Object *src,
+>         CORBA_Environment &ACE_TRY_ENV =
+>           TAO_default_environment ()
+>       );
+>     virtual CORBA_Object* _upcast (void *src) const;
+520c323
+<     };
+---
+>   };
+530,531c333,334
+<   class IORList;
+<   class IORList_var;
+---
+> class IORList;
+> class IORList_var;
+533,535c336,338
+<   // *************************************************************
+<   // IORList
+<   // *************************************************************
+---
+> // *************************************************************
+> // IORList
+> // *************************************************************
+537c340
+<   class TAO_IORManip_Export IORList : public
+---
+> class TAO_Export IORList : public
+539c342
+<     _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList
+---
+>   _TAO_Unbounded_Object_Sequence_TAO_IOP_TAO_IOR_Manipulation_IORList
+541c344
+<     TAO_Unbounded_Object_Sequence<CORBA::Object,CORBA::Object_var>
+---
+>   TAO_Unbounded_Object_Sequence<CORBA::Object,CORBA::Object_var>
+543,555c346,358
+<   {
+<   public:
+<     IORList (void); // default ctor
+<     IORList (CORBA::ULong max); // uses max size
+<     IORList (
+<       CORBA::ULong max,
+<       CORBA::ULong length,
+<       CORBA::Object_ptr *buffer,
+<       CORBA::Boolean release=0
+<     );
+<     IORList (const IORList &); // copy ctor
+<     ~IORList (void);
+<     static void _tao_any_destructor (void*);
+---
+> {
+> public:
+>   IORList (void); // default ctor
+>   IORList (CORBA::ULong max); // uses max size
+>   IORList (
+>     CORBA::ULong max,
+>     CORBA::ULong length,
+>     CORBA::Object_ptr *buffer,
+>     CORBA::Boolean release=0
+>   );
+>   IORList (const IORList &); // copy ctor
+>   ~IORList (void);
+>   static void _tao_any_destructor (void*);
+558c361
+<     typedef IORList_var _var_type;
+---
+>   typedef IORList_var _var_type;
+561c364
+<   };
+---
+> };
+569,571c372,374
+<   // *************************************************************
+<   // class TAO_IOP::TAO_IOR_Manipulation::IORList_var
+<   // *************************************************************
+---
+> // *************************************************************
+> // class TAO_IOP::TAO_IOR_Manipulation::IORList_var
+> // *************************************************************
+573,579c376,382
+<   class TAO_IORManip_Export IORList_var
+<   {
+<   public:
+<     IORList_var (void); // default constructor
+<     IORList_var (IORList *);
+<     IORList_var (const IORList_var &); // copy constructor
+<     ~IORList_var (void); // destructor
+---
+> class TAO_Export IORList_var
+> {
+> public:
+>   IORList_var (void); // default constructor
+>   IORList_var (IORList *);
+>   IORList_var (const IORList_var &); // copy constructor
+>   ~IORList_var (void); // destructor
+581,584c384,387
+<     IORList_var &operator= (IORList *);
+<     IORList_var &operator= (const IORList_var &);
+<     IORList *operator-> (void);
+<     const IORList *operator-> (void) const;
+---
+>   IORList_var &operator= (IORList *);
+>   IORList_var &operator= (const IORList_var &);
+>   IORList *operator-> (void);
+>   const IORList *operator-> (void) const;
+586,589c389,392
+<     operator const IORList &() const;
+<     operator IORList &();
+<     operator IORList &() const;
+<     operator IORList *&(); // variable-size base types only
+---
+>   operator const IORList &() const;
+>   operator IORList &();
+>   operator IORList &() const;
+>   operator IORList *&(); // variable-size base types only
+591,597c394,400
+<     TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index);
+<     // in, inout, out, _retn
+<     const IORList &in (void) const;
+<     IORList &inout (void);
+<     IORList *&out (void);
+<     IORList *_retn (void);
+<     IORList *ptr (void) const;
+---
+>   TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index);
+>   // in, inout, out, _retn
+>   const IORList &in (void) const;
+>   IORList &inout (void);
+>   IORList *&out (void);
+>   IORList *_retn (void);
+>   IORList *ptr (void) const;
+599,601c402,404
+<   private:
+<     IORList *ptr_;
+<   };
+---
+> private:
+>   IORList *ptr_;
+> };
+610,621c413,424
+<   class TAO_IORManip_Export IORList_out
+<   {
+<   public:
+<     IORList_out (IORList *&);
+<     IORList_out (IORList_var &);
+<     IORList_out (const IORList_out &);
+<     IORList_out &operator= (const IORList_out &);
+<     IORList_out &operator= (IORList *);
+<     operator IORList *&();
+<     IORList *&ptr (void);
+<     IORList *operator-> (void);
+<     TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index);
+---
+> class TAO_Export IORList_out
+> {
+> public:
+>   IORList_out (IORList *&);
+>   IORList_out (IORList_var &);
+>   IORList_out (const IORList_out &);
+>   IORList_out &operator= (const IORList_out &);
+>   IORList_out &operator= (IORList *);
+>   operator IORList *&();
+>   IORList *&ptr (void);
+>   IORList *operator-> (void);
+>   TAO_Object_Manager<CORBA::Object,CORBA::Object_var> operator[] (CORBA::ULong index);
+623,627c426,430
+<   private:
+<     IORList *&ptr_;
+<     // assignment from T_var not allowed
+<     void operator= (const IORList_var &);
+<   };
+---
+> private:
+>   IORList *&ptr_;
+>   // assignment from T_var not allowed
+>   void operator= (const IORList_var &);
+> };
+632,642c435,445
+<   virtual CORBA::Object_ptr merge_iors (
+<       const TAO_IOP::TAO_IOR_Manipulation::IORList & iors,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::EmptyProfileList,
+<       TAO_IOP::Duplicate,
+<       TAO_IOP::Invalid_IOR
+<     )) = 0;
+---
+> virtual CORBA::Object_ptr merge_iors (
+>     const TAO_IOP::TAO_IOR_Manipulation::IORList & iors,
+>     CORBA::Environment &ACE_TRY_ENV =
+>       TAO_default_environment ()
+>   )
+>   ACE_THROW_SPEC ((
+>     CORBA::SystemException,
+>     TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList,
+>     TAO_IOP::TAO_IOR_Manipulation::Duplicate,
+>     TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR
+>   )) = 0;
+644,655c447,458
+<   virtual CORBA::Object_ptr add_profiles (
+<       CORBA::Object_ptr ior1,
+<       CORBA::Object_ptr ior2,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::EmptyProfileList,
+<       TAO_IOP::Duplicate,
+<       TAO_IOP::Invalid_IOR
+<     )) = 0;
+---
+> virtual CORBA::Object_ptr add_profiles (
+>     CORBA::Object_ptr ior1,
+>     CORBA::Object_ptr ior2,
+>     CORBA::Environment &ACE_TRY_ENV =
+>       TAO_default_environment ()
+>   )
+>   ACE_THROW_SPEC ((
+>     CORBA::SystemException,
+>     TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList,
+>     TAO_IOP::TAO_IOR_Manipulation::Duplicate,
+>     TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR
+>   )) = 0;
+657,668c460,471
+<   virtual CORBA::Object_ptr remove_profiles (
+<       CORBA::Object_ptr ior1,
+<       CORBA::Object_ptr ior2,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::Invalid_IOR,
+<       TAO_IOP::EmptyProfileList,
+<       TAO_IOP::NotFound
+<     )) = 0;
+---
+> virtual CORBA::Object_ptr remove_profiles (
+>     CORBA::Object_ptr ior1,
+>     CORBA::Object_ptr ior2,
+>     CORBA::Environment &ACE_TRY_ENV =
+>       TAO_default_environment ()
+>   )
+>   ACE_THROW_SPEC ((
+>     CORBA::SystemException,
+>     TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR,
+>     TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList,
+>     TAO_IOP::TAO_IOR_Manipulation::NotFound
+>   )) = 0;
+670,680c473,482
+<   virtual CORBA::Boolean set_property (
+<       TAO_IOP::TAO_IOR_Property_ptr prop,
+<       CORBA::Object_ptr ior,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::Invalid_IOR,
+<       TAO_IOP::Duplicate
+<     )) = 0;
+---
+> virtual CORBA::ULong is_in_ior (
+>     CORBA::Object_ptr ior1,
+>     CORBA::Object_ptr ior2,
+>     CORBA::Environment &ACE_TRY_ENV =
+>       TAO_default_environment ()
+>   )
+>   ACE_THROW_SPEC ((
+>     CORBA::SystemException,
+>     TAO_IOP::TAO_IOR_Manipulation::NotFound
+>   )) = 0;
+682,695c484,492
+<   virtual CORBA::Boolean set_primary (
+<       TAO_IOP::TAO_IOR_Property_ptr prop,
+<       CORBA::Object_ptr ior1,
+<       CORBA::Object_ptr ior2,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::Invalid_IOR,
+<       TAO_IOP::Duplicate,
+<       TAO_IOP::MultiProfileList,
+<       TAO_IOP::NotFound
+<     )) = 0;
+---
+> virtual CORBA::ULong get_profile_count (
+>     CORBA::Object_ptr ior,
+>     CORBA::Environment &ACE_TRY_ENV =
+>       TAO_default_environment ()
+>   )
+>   ACE_THROW_SPEC ((
+>     CORBA::SystemException,
+>     TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList
+>   )) = 0;
+697,706c494
+<   virtual CORBA::Object_ptr get_primary (
+<       TAO_IOP::TAO_IOR_Property_ptr prop,
+<       CORBA::Object_ptr ior,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::NotFound
+<     )) = 0;
+---
+> virtual void *_tao_QueryInterface (ptr_arith_t type);
+708,716c496
+<   virtual CORBA::Boolean is_primary_set (
+<       TAO_IOP::TAO_IOR_Property_ptr prop,
+<       CORBA::Object_ptr ior,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException
+<     )) = 0;
+---
+> virtual const char* _interface_repository_id (void) const;
+718,742d497
+<   virtual CORBA::ULong is_in_ior (
+<       CORBA::Object_ptr ior1,
+<       CORBA::Object_ptr ior2,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::NotFound
+<     )) = 0;
+< 
+<   virtual CORBA::ULong get_profile_count (
+<       CORBA::Object_ptr ior,
+<       CORBA::Environment &ACE_TRY_ENV =
+<         TAO_default_environment ()
+<     )
+<     ACE_THROW_SPEC ((
+<       CORBA::SystemException,
+<       TAO_IOP::EmptyProfileList
+<     )) = 0;
+< 
+<   virtual void *_tao_QueryInterface (ptr_arith_t type);
+< 
+<   virtual const char* _interface_repository_id (void) const;
+< 
+758,777d512
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, const TAO_IOP::EmptyProfileList &); // copying version
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, TAO_IOP::EmptyProfileList*); // noncopying version
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::EmptyProfileList *&); // deprecated
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::EmptyProfileList *&);
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, const TAO_IOP::NotFound &); // copying version
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, TAO_IOP::NotFound*); // noncopying version
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::NotFound *&); // deprecated
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::NotFound *&);
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, const TAO_IOP::Duplicate &); // copying version
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, TAO_IOP::Duplicate*); // noncopying version
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::Duplicate *&); // deprecated
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::Duplicate *&);
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, const TAO_IOP::Invalid_IOR &); // copying version
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, TAO_IOP::Invalid_IOR*); // noncopying version
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::Invalid_IOR *&); // deprecated
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::Invalid_IOR *&);
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, const TAO_IOP::MultiProfileList &); // copying version
+< TAO_IORManip_Export void operator<<= (CORBA::Any &, TAO_IOP::MultiProfileList*); // noncopying version
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::MultiProfileList *&); // deprecated
+< TAO_IORManip_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO_IOP::MultiProfileList *&);
+781,782d515
+< TAO_IORManip_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO_IOP::EmptyProfileList &);
+< TAO_IORManip_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::EmptyProfileList &);
+784,796d516
+< TAO_IORManip_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO_IOP::NotFound &);
+< TAO_IORManip_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::NotFound &);
+< 
+< TAO_IORManip_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO_IOP::Duplicate &);
+< TAO_IORManip_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::Duplicate &);
+< 
+< TAO_IORManip_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO_IOP::Invalid_IOR &);
+< TAO_IORManip_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::Invalid_IOR &);
+< 
+< TAO_IORManip_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO_IOP::MultiProfileList &);
+< TAO_IORManip_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO_IOP::MultiProfileList &);
+< 
+< 
+808d527
+< #include "ace/post.h"
diff --git a/TAO/tao/IORManipulation/diffs/IORC.i.diff b/TAO/tao/IORManipulation/diffs/IORC.i.diff
new file mode 100644
index 00000000000..8b1904849dc
--- /dev/null
+++ b/TAO/tao/IORManipulation/diffs/IORC.i.diff
@@ -0,0 +1,271 @@
+1c1
+< /* -*- C++ -*- $Id$ */
+---
+> /* -*- C++ -*- $Id$ */
+11c11
+< // Inline operations for exception TAO_IOP::EmptyProfileList
+---
+> // Inline operations for exception TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList
+15c15
+< // Inline operations for exception TAO_IOP::NotFound
+---
+> // Inline operations for exception TAO_IOP::TAO_IOR_Manipulation::NotFound
+19c19
+< // Inline operations for exception TAO_IOP::Duplicate
+---
+> // Inline operations for exception TAO_IOP::TAO_IOR_Manipulation::Duplicate
+23c23
+< // Inline operations for exception TAO_IOP::Invalid_IOR
+---
+> // Inline operations for exception TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR
+26,28d25
+< // *************************************************************
+< // Inline operations for exception TAO_IOP::MultiProfileList
+< // *************************************************************
+30,200d26
+< 
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY___VAR_CI_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY___VAR_CI_
+< 
+< // *************************************************************
+< // Inline operations for class TAO_IOP::TAO_IOR_Property_var
+< // *************************************************************
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_var::TAO_IOR_Property_var (void) // default constructor
+<   : ptr_ (TAO_IOR_Property::_nil ())
+< {}
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property_var::ptr (void) const
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_var::TAO_IOR_Property_var (const ::TAO_IOP::TAO_IOR_Property_var &p) // copy constructor
+<   : TAO_Base_var (),
+<     ptr_ (TAO_IOR_Property::_duplicate (p.ptr ()))
+< {}
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_var::~TAO_IOR_Property_var (void) // destructor
+< {
+<   CORBA::release (this->ptr_);
+< }
+< 
+< ACE_INLINE TAO_IOP::TAO_IOR_Property_var &
+< TAO_IOP::TAO_IOR_Property_var::operator= (TAO_IOR_Property_ptr p)
+< {
+<   CORBA::release (this->ptr_);
+<   this->ptr_ = p;
+<   return *this;
+< }
+< 
+< ACE_INLINE TAO_IOP::TAO_IOR_Property_var &
+< TAO_IOP::TAO_IOR_Property_var::operator= (const ::TAO_IOP::TAO_IOR_Property_var &p)
+< {
+<   if (this != &p)
+<   {
+<     CORBA::release (this->ptr_);
+<     this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_duplicate (p.ptr ());
+<   }
+<   return *this;
+< }
+< 
+< ACE_INLINE 
+< TAO_IOP::TAO_IOR_Property_var::operator const ::TAO_IOP::TAO_IOR_Property_ptr &() const // cast
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE 
+< TAO_IOP::TAO_IOR_Property_var::operator ::TAO_IOP::TAO_IOR_Property_ptr &() // cast 
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property_var::operator-> (void) const
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property_var::in (void) const
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr &
+< TAO_IOP::TAO_IOR_Property_var::inout (void)
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr &
+< TAO_IOP::TAO_IOR_Property_var::out (void)
+< {
+<   CORBA::release (this->ptr_);
+<   this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_nil ();
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property_var::_retn (void)
+< {
+<   // yield ownership of managed obj reference
+<   ::TAO_IOP::TAO_IOR_Property_ptr val = this->ptr_;
+<   this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_nil ();
+<   return val;
+< }
+< 
+< 
+< #endif /* end #if !defined */
+< 
+< 
+< #if !defined (_TAO_IOP_TAO_IOR_PROPERTY___OUT_CI_)
+< #define _TAO_IOP_TAO_IOR_PROPERTY___OUT_CI_
+< 
+< // *************************************************************
+< // Inline operations for class TAO_IOP::TAO_IOR_Property_out
+< // *************************************************************
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_out::TAO_IOR_Property_out (TAO_IOR_Property_ptr &p)
+<   : ptr_ (p)
+< {
+<   this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_nil ();
+< }
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_out::TAO_IOR_Property_out (TAO_IOR_Property_var &p) // constructor from _var
+<   : ptr_ (p.out ())
+< {
+<   CORBA::release (this->ptr_);
+<   this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_nil ();
+< }
+< 
+< ACE_INLINE
+< TAO_IOP::TAO_IOR_Property_out::TAO_IOR_Property_out (const ::TAO_IOP::TAO_IOR_Property_out &p) // copy constructor
+<   : ptr_ (ACE_const_cast (TAO_IOR_Property_out &, p).ptr_)
+< {}
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_out &
+< TAO_IOP::TAO_IOR_Property_out::operator= (const ::TAO_IOP::TAO_IOR_Property_out &p)
+< {
+<   this->ptr_ = ACE_const_cast (TAO_IOR_Property_out&, p).ptr_;
+<   return *this;
+< }
+< 
+< ACE_INLINE TAO_IOP::TAO_IOR_Property_out &
+< TAO_IOP::TAO_IOR_Property_out::operator= (const ::TAO_IOP::TAO_IOR_Property_var &p)
+< {
+<   this->ptr_ = ::TAO_IOP::TAO_IOR_Property::_duplicate (p.ptr ());
+<   return *this;
+< }
+< 
+< ACE_INLINE TAO_IOP::TAO_IOR_Property_out &
+< TAO_IOP::TAO_IOR_Property_out::operator= (TAO_IOR_Property_ptr p)
+< {
+<   this->ptr_ = p;
+<   return *this;
+< }
+< 
+< ACE_INLINE 
+< TAO_IOP::TAO_IOR_Property_out::operator ::TAO_IOP::TAO_IOR_Property_ptr &() // cast
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr &
+< TAO_IOP::TAO_IOR_Property_out::ptr (void) // ptr
+< {
+<   return this->ptr_;
+< }
+< 
+< ACE_INLINE ::TAO_IOP::TAO_IOR_Property_ptr
+< TAO_IOP::TAO_IOR_Property_out::operator-> (void)
+< {
+<   return this->ptr_;
+< }
+< 
+< 
+< #endif /* end #if !defined */
+< 
+< 
+322c148
+<         this->release_ = 1;
+---
+> 	this->release_ = 1;
+720,789d545
+< 
+< ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::EmptyProfileList &_tao_aggregate)
+< {
+<   // first marshal the repository ID
+<   if (strm << _tao_aggregate._id ())
+<     return 1;
+<   else
+<     return 0;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,TAO_IOP::EmptyProfileList&)
+< {
+<   return 1;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::NotFound &_tao_aggregate)
+< {
+<   // first marshal the repository ID
+<   if (strm << _tao_aggregate._id ())
+<     return 1;
+<   else
+<     return 0;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,TAO_IOP::NotFound&)
+< {
+<   return 1;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::Duplicate &_tao_aggregate)
+< {
+<   // first marshal the repository ID
+<   if (strm << _tao_aggregate._id ())
+<     return 1;
+<   else
+<     return 0;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,TAO_IOP::Duplicate&)
+< {
+<   return 1;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::Invalid_IOR &_tao_aggregate)
+< {
+<   // first marshal the repository ID
+<   if (strm << _tao_aggregate._id ())
+<     return 1;
+<   else
+<     return 0;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,TAO_IOP::Invalid_IOR&)
+< {
+<   return 1;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO_IOP::MultiProfileList &_tao_aggregate)
+< {
+<   // first marshal the repository ID
+<   if (strm << _tao_aggregate._id ())
+<     return 1;
+<   else
+<     return 0;
+< }
+< 
+< ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,TAO_IOP::MultiProfileList&)
+< {
+<   return 1;
+< }