From cee4a1cd0cc13fb4689c7c2bb9f31e2986378350 Mon Sep 17 00:00:00 2001 From: bala Date: Thu, 10 Jan 2002 17:59:01 +0000 Subject: ChangeLogTag: Thu Jan 10 11:53:22 2002 Balachandran Natarajan --- TAO/ChangeLogs/ChangeLog-02a | 18 + TAO/tao/GIOP.pidl | 13 + TAO/tao/GIOPC.cpp | 42 ++ TAO/tao/GIOPC.h | 36 ++ TAO/tao/GIOPC.i | 156 +++++- TAO/tao/diffs/GIOPC.cpp.diff | 1210 ++++++++++++++++++++++++++++++++++++++++ TAO/tao/diffs/GIOPC.h.diff | 611 ++++++++++++++++++++ TAO/tao/diffs/GIOPC.i.diff | 960 +++++++++++++++++++++++++++++++ TAO/tao/diffs/GIOPS.cpp.diff | 69 +++ TAO/tao/diffs/GIOPS.h.diff | 89 +++ TAO/tao/diffs/GIOPS.i.diff | 25 + TAO/tao/diffs/GIOPS_T.cpp.diff | 43 ++ TAO/tao/diffs/GIOPS_T.h.diff | 71 +++ TAO/tao/diffs/GIOPS_T.i.diff | 25 + 14 files changed, 3362 insertions(+), 6 deletions(-) create mode 100644 TAO/tao/diffs/GIOPC.cpp.diff create mode 100644 TAO/tao/diffs/GIOPC.h.diff create mode 100644 TAO/tao/diffs/GIOPC.i.diff create mode 100644 TAO/tao/diffs/GIOPS.cpp.diff create mode 100644 TAO/tao/diffs/GIOPS.h.diff create mode 100644 TAO/tao/diffs/GIOPS.i.diff create mode 100644 TAO/tao/diffs/GIOPS_T.cpp.diff create mode 100644 TAO/tao/diffs/GIOPS_T.h.diff create mode 100644 TAO/tao/diffs/GIOPS_T.i.diff diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a index a4a2f279d1d..24c626639e3 100644 --- a/TAO/ChangeLogs/ChangeLog-02a +++ b/TAO/ChangeLogs/ChangeLog-02a @@ -1,3 +1,21 @@ +Thu Jan 10 11:53:22 2002 Balachandran Natarajan + + * tao/GIOPC.h: + * tao/GIOPC.cpp: + * tao/GIOPC.i (Version_var): Added GIOP::Version_var to the + generated code. + + * tao/diffs/GIOPC.cpp.diff: + * tao/diffs/GIOPC.h.diff: + * tao/diffs/GIOPC.i.diff: + * tao/diffs/GIOPS.cpp.diff: + * tao/diffs/GIOPS.h.diff: + * tao/diffs/GIOPS.i.diff: + * tao/diffs/GIOPS_T.cpp.diff: + * tao/diffs/GIOPS_T.h.diff: + * tao/diffs/GIOPS_T.i.diff: Added diffs to the generated code. + + Wed Jan 9 18:07:55 2002 Jeff Parsons * TO_IDL/fe/fe_init.cpp (populate_global_scope): diff --git a/TAO/tao/GIOP.pidl b/TAO/tao/GIOP.pidl index 46335776941..b10c6cf87d0 100644 --- a/TAO/tao/GIOP.pidl +++ b/TAO/tao/GIOP.pidl @@ -9,8 +9,21 @@ // // = DESCRIPTION // Some new data types included for GIOP 1.2 +// This file was used to generate the code in +// GIOP*.* The command used to generate code +// is: +// +// tao_idl +// -Ge 1 +// -Wb,export_macro=TAO_Export +// -Wb,export_include="tao/TAO_Export.h" +// -Wb,pre_include="ace/pre.h" +// -Wb,post_include="ace/post.h" +// GIOP.pidl +// // ================================================================ #pragma prefix "omg.org" +#include "IOP.pidl" module GIOP { typedef short AddressingDisposition; diff --git a/TAO/tao/GIOPC.cpp b/TAO/tao/GIOPC.cpp index 9e5e1899ac7..99d04588f7c 100644 --- a/TAO/tao/GIOPC.cpp +++ b/TAO/tao/GIOPC.cpp @@ -322,6 +322,48 @@ TAO_NAMESPACE_BEGIN (GIOP) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TargetAddress, &_tc_TAO_tc_GIOP_TargetAddress) TAO_NAMESPACE_END +static const CORBA::Long _oc_GIOP_Version[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 29, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x47494f50), + ACE_NTOHL (0x2f566572), + ACE_NTOHL (0x73696f6e), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/GIOP/Version:1.0 + 8, + ACE_NTOHL (0x56657273), + ACE_NTOHL (0x696f6e00), // name = Version + 2, // member count + 6, + ACE_NTOHL (0x6d616a6f), + ACE_NTOHL (0x72000000), // name = major + CORBA::tk_octet, + + 6, + ACE_NTOHL (0x6d696e6f), + ACE_NTOHL (0x72000000), // name = minor + CORBA::tk_octet, + +}; + +static CORBA::TypeCode _tc_TAO_tc_GIOP_Version ( + CORBA::tk_struct, + sizeof (_oc_GIOP_Version), + (char *) &_oc_GIOP_Version, + 0, + sizeof (GIOP::Version) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (GIOP) +TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Version, &_tc_TAO_tc_GIOP_Version) +TAO_NAMESPACE_END + + void GIOP::IORAddressingInfo::_tao_any_destructor (void *x) { diff --git a/TAO/tao/GIOPC.h b/TAO/tao/GIOPC.h index 1a1ce51244c..b4a34b103fa 100644 --- a/TAO/tao/GIOPC.h +++ b/TAO/tao/GIOPC.h @@ -248,6 +248,42 @@ struct TAO_Export Version CORBA::Octet minor; }; +class TAO_Export Version_var +{ +public: + Version_var (void); + Version_var (Version *); + Version_var (const Version_var &); + // Fixed-size types only. + Version_var (const Version &); + ~Version_var (void); + + Version_var &operator= (Version *); + Version_var &operator= (const Version_var &); + // Fixed-size types only. + Version_var &operator= (const Version &); + Version *operator-> (void); + const Version *operator-> (void) const; + + operator const Version &() const; + operator Version &(); + operator Version &() const; + + // in, inout, out, _retn + const Version &in (void) const; + Version &inout (void); + Version &out (void); + Version _retn (void); + Version *ptr (void) const; + +private: + Version *ptr_; +}; + +typedef Version &Version_out; + +TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Version; + } TAO_NAMESPACE_CLOSE // module GIOP diff --git a/TAO/tao/GIOPC.i b/TAO/tao/GIOPC.i index 6332dcb063c..f61aac328e9 100644 --- a/TAO/tao/GIOPC.i +++ b/TAO/tao/GIOPC.i @@ -56,9 +56,9 @@ GIOP::IORAddressingInfo_var::operator= (const GIOP::IORAddressingInfo_var &p) } else { - GIOP::IORAddressingInfo *deep_copy = + GIOP::IORAddressingInfo *deep_copy = new GIOP::IORAddressingInfo (*p.ptr_); - + if (deep_copy != 0) { GIOP::IORAddressingInfo *tmp = deep_copy; @@ -68,7 +68,7 @@ GIOP::IORAddressingInfo_var::operator= (const GIOP::IORAddressingInfo_var &p) } } } - + return *this; } @@ -368,9 +368,9 @@ GIOP::TargetAddress_var::operator= (const GIOP::TargetAddress_var &p) } else { - GIOP::TargetAddress *deep_copy = + GIOP::TargetAddress *deep_copy = new GIOP::TargetAddress (*p.ptr_); - + if (deep_copy != 0) { GIOP::TargetAddress *tmp = deep_copy; @@ -380,7 +380,7 @@ GIOP::TargetAddress_var::operator= (const GIOP::TargetAddress_var &p) } } } - + return *this; } @@ -515,6 +515,150 @@ GIOP::TargetAddress_out::operator-> (void) #endif /* end #if !defined */ +// ************************************************************* +// Inline operations for class GIOP::Version_var +// ************************************************************* + +ACE_INLINE +GIOP::Version_var::Version_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +GIOP::Version_var::Version_var (Version *p) + : ptr_ (p) +{} + +ACE_INLINE +GIOP::Version_var::Version_var (const ::GIOP::Version_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::GIOP::Version (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +GIOP::Version_var::Version_var (const ::GIOP::Version &p) +{ + ACE_NEW (this->ptr_, ::GIOP::Version (p)); +} + +ACE_INLINE +GIOP::Version_var::~Version_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE GIOP::Version_var & +GIOP::Version_var::operator= (Version *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::GIOP::Version_var & +GIOP::Version_var::operator= (const ::GIOP::Version_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + Version *deep_copy = + new Version (*p.ptr_); + + if (deep_copy != 0) + { + Version *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// fixed-size types only +ACE_INLINE GIOP::Version_var & +GIOP::Version_var::operator= (const ::GIOP::Version &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::GIOP::Version (p), *this); + } + return *this; +} + +ACE_INLINE const ::GIOP::Version * +GIOP::Version_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::GIOP::Version * +GIOP::Version_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +GIOP::Version_var::operator const ::GIOP::Version &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +GIOP::Version_var::operator ::GIOP::Version &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +GIOP::Version_var::operator ::GIOP::Version &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::GIOP::Version & +GIOP::Version_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::GIOP::Version & +GIOP::Version_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::GIOP::Version & +GIOP::Version_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::GIOP::Version +GIOP::Version_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::GIOP::Version * +GIOP::Version_var::ptr (void) const +{ + return this->ptr_; +} ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const GIOP::IORAddressingInfo &_tao_aggregate) { diff --git a/TAO/tao/diffs/GIOPC.cpp.diff b/TAO/tao/diffs/GIOPC.cpp.diff new file mode 100644 index 00000000000..0b961ad8ab0 --- /dev/null +++ b/TAO/tao/diffs/GIOPC.cpp.diff @@ -0,0 +1,1210 @@ +--- orig/GIOPC.cpp Thu Jan 10 11:45:43 2002 ++++ GIOPC.cpp Thu Jan 10 11:37:59 2002 +@@ -1,83 +1,45 @@ +-// -*- C++ -*- +-// +-// $Id$ ++/* -*- C++ -*- $Id$ */ + +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ ++// ================================================================ ++// ++// = LIBRARY ++// TAO + // +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html ++// = FILENAME ++// GIOPC.h ++// ++// = DESCRIPTION ++// Generated from GIOP1_2.pidl, that contains a part of the new data ++// type definitions for GIOP1.2 module. ++// The code was generated by the IDL compiler and then hand-crafted ++// to reduce the includes interdependencies. ++// hand crafted by Balachandran Natarajan ++// ================================================================ + +-#include "GIOPC.h" + +-#include "tao/Stub.h" +-#include "tao/Invocation.h" +-#include "tao/PortableInterceptor.h" +- +-#if TAO_HAS_INTERCEPTORS == 1 +-#include "tao/RequestInfo_Util.h" +-#include "tao/ClientRequestInfo.h" +-#include "tao/ClientInterceptorAdapter.h" +-#endif /* TAO_HAS_INTERCEPTORS == 1 */ +- +-#if defined (__BORLANDC__) +-#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +-#endif /* __BORLANDC__ */ ++#include "tao/GIOPC.h" ++#include "tao/Environment.h" ++#include "tao/Any.h" ++#include "tao/Typecode.h" + + #if !defined (__ACE_INLINE__) + #include "GIOPC.i" + #endif /* !defined INLINE */ + ++ + static const CORBA::Long _oc_GIOP_AddressingDisposition[] = + { + TAO_ENCAP_BYTE_ORDER, // byte order +- 43, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x47494f50), +- ACE_NTOHL (0x2f416464), +- ACE_NTOHL (0x72657373), +- ACE_NTOHL (0x696e6744), +- ACE_NTOHL (0x6973706f), +- ACE_NTOHL (0x73697469), +- ACE_NTOHL (0x6f6e3a31), +- ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/AddressingDisposition:1.0 +- 22, +- ACE_NTOHL (0x41646472), +- ACE_NTOHL (0x65737369), +- ACE_NTOHL (0x6e674469), +- ACE_NTOHL (0x73706f73), +- ACE_NTOHL (0x6974696f), +- ACE_NTOHL (0x6e000000), // name = AddressingDisposition ++ 43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x47494f50), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x696e6744), ACE_NTOHL (0x6973706f), ACE_NTOHL (0x73697469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/AddressingDisposition:1.0 ++ 22, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737369), ACE_NTOHL (0x6e674469), ACE_NTOHL (0x73706f73), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e000000), // name = AddressingDisposition + CORBA::tk_short, + + }; +- +-static CORBA::TypeCode _tc_TAO_tc_GIOP_AddressingDisposition ( +- CORBA::tk_alias, +- sizeof (_oc_GIOP_AddressingDisposition), +- (char *) &_oc_GIOP_AddressingDisposition, +- 0, +- sizeof (GIOP::AddressingDisposition) +- ); +- ++static CORBA::TypeCode _tc_TAO_tc_GIOP_AddressingDisposition (CORBA::tk_alias, sizeof (_oc_GIOP_AddressingDisposition), (char *) &_oc_GIOP_AddressingDisposition, 0, sizeof (GIOP::AddressingDisposition)); + TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) + TAO_NAMESPACE_BEGIN (GIOP) +-TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_AddressingDisposition, &_tc_TAO_tc_GIOP_AddressingDisposition) ++TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AddressingDisposition, &_tc_TAO_tc_GIOP_AddressingDisposition) + TAO_NAMESPACE_END +- + TAO_NAMESPACE_TYPE (const CORBA::Short) + TAO_NAMESPACE_BEGIN (GIOP) + TAO_NAMESPACE_DEFINE (const CORBA::Short, KeyAddr, 0) +@@ -90,155 +52,45 @@ + TAO_NAMESPACE_BEGIN (GIOP) + TAO_NAMESPACE_DEFINE (const CORBA::Short, ReferenceAddr, 2) + TAO_NAMESPACE_END +-static const CORBA::Long _oc_GIOP_Version[] = +-{ +- TAO_ENCAP_BYTE_ORDER, // byte order +- 29, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x47494f50), +- ACE_NTOHL (0x2f566572), +- ACE_NTOHL (0x73696f6e), +- ACE_NTOHL (0x3a312e30), +- ACE_NTOHL (0x0), // repository ID = IDL:omg.org/GIOP/Version:1.0 +- 8, +- ACE_NTOHL (0x56657273), +- ACE_NTOHL (0x696f6e00), // name = Version +- 2, // member count +- 6, +- ACE_NTOHL (0x6d616a6f), +- ACE_NTOHL (0x72000000), // name = major +- CORBA::tk_octet, +- +- 6, +- ACE_NTOHL (0x6d696e6f), +- ACE_NTOHL (0x72000000), // name = minor +- CORBA::tk_octet, +- +-}; +- +-static CORBA::TypeCode _tc_TAO_tc_GIOP_Version ( +- CORBA::tk_struct, +- sizeof (_oc_GIOP_Version), +- (char *) &_oc_GIOP_Version, +- 0, +- sizeof (GIOP::Version) +- ); +- +-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +-TAO_NAMESPACE_BEGIN (GIOP) +-TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Version, &_tc_TAO_tc_GIOP_Version) +-TAO_NAMESPACE_END +- +-void GIOP::Version::_tao_any_destructor (void *_tao_void_pointer) +-{ +- Version *tmp = ACE_static_cast (Version*, _tao_void_pointer); +- delete tmp; +-} +- + static const CORBA::Long _oc_GIOP_IORAddressingInfo[] = + { + TAO_ENCAP_BYTE_ORDER, // byte order +- 39, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x47494f50), +- ACE_NTOHL (0x2f494f52), +- ACE_NTOHL (0x41646472), +- ACE_NTOHL (0x65737369), +- ACE_NTOHL (0x6e67496e), +- ACE_NTOHL (0x666f3a31), +- ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/IORAddressingInfo:1.0 +- 18, +- ACE_NTOHL (0x494f5241), +- ACE_NTOHL (0x64647265), +- ACE_NTOHL (0x7373696e), +- ACE_NTOHL (0x67496e66), +- ACE_NTOHL (0x6f000000), // name = IORAddressingInfo ++ 39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x47494f50), ACE_NTOHL (0x2f494f52), ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737369), ACE_NTOHL (0x6e67496e), ACE_NTOHL (0x666f3a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/IORAddressingInfo:1.0 ++ 18, ACE_NTOHL (0x494f5241), ACE_NTOHL (0x64647265), ACE_NTOHL (0x7373696e), ACE_NTOHL (0x67496e66), ACE_NTOHL (0x6f000000), // name = IORAddressingInfo + 2, // member count +- 23, +- ACE_NTOHL (0x73656c65), +- ACE_NTOHL (0x63746564), +- ACE_NTOHL (0x5f70726f), +- ACE_NTOHL (0x66696c65), +- ACE_NTOHL (0x5f696e64), +- ACE_NTOHL (0x65780000), // name = selected_profile_index ++ 23, ACE_NTOHL (0x73656c65), ACE_NTOHL (0x63746564), ACE_NTOHL (0x5f70726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x5f696e64), ACE_NTOHL (0x65780000), // name = selected_profile_index + CORBA::tk_ulong, + +- 4, +- ACE_NTOHL (0x696f7200), // name = ior ++ 4, ACE_NTOHL (0x696f7200), // name = ior + CORBA::tk_struct, // typecode kind + 288, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 24, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x494f523a), +- ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/IOP/IOR:1.0 +- 4, +- ACE_NTOHL (0x494f5200), // name = IOR ++ 24, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x494f523a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/IOP/IOR:1.0 ++ 4, ACE_NTOHL (0x494f5200), // name = IOR + 2, // member count +- 8, +- ACE_NTOHL (0x74797065), +- ACE_NTOHL (0x5f696400), // name = type_id +- CORBA::tk_string, ++ 8, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f696400), // name = type_id ++ CORBA::tk_string, + 0U, // string length +- 9, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c6573), +- ACE_NTOHL (0x0), // name = profiles ++ 9, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c6573), ACE_NTOHL (0x0), // name = profiles + CORBA::tk_sequence, // typecode kind + 200, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 184, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 34, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x653a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 +- 14, +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x65000000), // name = TaggedProfile ++ 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 ++ 14, ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x65000000), // name = TaggedProfile + 2, // member count +- 4, +- ACE_NTOHL (0x74616700), // name = tag ++ 4, ACE_NTOHL (0x74616700), // name = tag + CORBA::tk_alias, // typecode kind for typedefs + 60, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 30, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x643a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 +- 10, +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x64000000), // name = ProfileId ++ 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 ++ 10, ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x64000000), // name = ProfileId + CORBA::tk_ulong, + + +- 13, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c655f), +- ACE_NTOHL (0x64617461), +- ACE_NTOHL (0x0), // name = profile_data ++ 13, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c655f), ACE_NTOHL (0x64617461), ACE_NTOHL (0x0), // name = profile_data + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +@@ -251,74 +103,12 @@ + + + }; +- +-static CORBA::TypeCode _tc_TAO_tc_GIOP_IORAddressingInfo ( +- CORBA::tk_struct, +- sizeof (_oc_GIOP_IORAddressingInfo), +- (char *) &_oc_GIOP_IORAddressingInfo, +- 0, +- sizeof (GIOP::IORAddressingInfo) +- ); +- ++static CORBA::TypeCode _tc_TAO_tc_GIOP_IORAddressingInfo (CORBA::tk_struct, sizeof (_oc_GIOP_IORAddressingInfo), (char *) &_oc_GIOP_IORAddressingInfo, 0, sizeof (GIOP::IORAddressingInfo)); + TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) + TAO_NAMESPACE_BEGIN (GIOP) +-TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_IORAddressingInfo, &_tc_TAO_tc_GIOP_IORAddressingInfo) ++TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IORAddressingInfo, &_tc_TAO_tc_GIOP_IORAddressingInfo) + TAO_NAMESPACE_END + +-void GIOP::IORAddressingInfo::_tao_any_destructor (void *_tao_void_pointer) +-{ +- IORAddressingInfo *tmp = ACE_static_cast (IORAddressingInfo*, _tao_void_pointer); +- delete tmp; +-} +- +- +-#if !defined (_GIOP_TARGETADDRESS__TAO_SEQ_OCTET_CS_) +-#define _GIOP_TARGETADDRESS__TAO_SEQ_OCTET_CS_ +- +-// ************************************************************* +-// GIOP::TargetAddress::_tao_seq_Octet +-// ************************************************************* +- +-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 +-#else /* TAO_USE_SEQUENCE_TEMPLATES */ +-TAO_Unbounded_Sequence +-#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 +-#else /* TAO_USE_SEQUENCE_TEMPLATES */ +-TAO_Unbounded_Sequence +-#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 +-#else /* TAO_USE_SEQUENCE_TEMPLATES */ +-TAO_Unbounded_Sequence +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +- (seq) +-{} +-GIOP::TargetAddress::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor +-{} +-void GIOP::TargetAddress::_tao_seq_Octet::_tao_any_destructor (void *_tao_void_pointer) +-{ +- _tao_seq_Octet *tmp = ACE_static_cast (_tao_seq_Octet*, _tao_void_pointer); +- delete tmp; +-} +- +- +-#endif /* end #if !defined */ +- + // ************************************************************* + // Operations for union GIOP::TargetAddress + // ************************************************************* +@@ -328,58 +118,36 @@ + { + ACE_OS::memset (&this->disc_, 0, sizeof (this->disc_)); + ACE_OS::memset (&this->u_, 0, sizeof (this->u_)); +- this->disc_ = 0; + } + + // copy constructor +-GIOP::TargetAddress::TargetAddress (const ::GIOP::TargetAddress &u) ++GIOP::TargetAddress::TargetAddress (const GIOP::TargetAddress &u) + { + this->disc_ = u.disc_; + switch (this->disc_) + { + case 0: + { +- if (u.u_.object_key_ == 0) +- { +- this->u_.object_key_ = 0; +- } +- else +- { +- ACE_NEW ( +- this->u_.object_key_, +- GIOP::TargetAddress::_tao_seq_Octet (*u.u_.object_key_) +- ); +- } ++ ACE_NEW ( ++ this->u_.object_key_, ++ TAO_ObjectKey (*u.u_.object_key_) ++ ); + } + break; + case 1: + { +- if (u.u_.profile_ == 0) +- { +- this->u_.profile_ = 0; +- } +- else +- { +- ACE_NEW ( +- this->u_.profile_, +- IOP::TaggedProfile (*u.u_.profile_) +- ); +- } ++ ACE_NEW ( ++ this->u_.profile_, ++ IOP::TaggedProfile (*u.u_.profile_) ++ ); + } + break; + case 2: + { +- if (u.u_.ior_ == 0) +- { +- this->u_.ior_ = 0; +- } +- else +- { +- ACE_NEW ( +- this->u_.ior_, +- GIOP::IORAddressingInfo (*u.u_.ior_) +- ); +- } ++ ACE_NEW ( ++ this->u_.ior_, ++ GIOP::IORAddressingInfo (*u.u_.ior_) ++ ); + } + break; + default: +@@ -387,86 +155,45 @@ + } + } + +-// destructor +-GIOP::TargetAddress::~TargetAddress (void) +-{ +- // finalize +- this->_reset (this->disc_, 1); +-} +- +-void GIOP::TargetAddress::_tao_any_destructor (void *_tao_void_pointer) +-{ +- TargetAddress *tmp = ACE_static_cast (TargetAddress*, _tao_void_pointer); +- delete tmp; +-} +- + // assignment operator + GIOP::TargetAddress & +-GIOP::TargetAddress::operator= (const ::GIOP::TargetAddress &u) ++GIOP::TargetAddress::operator= (const GIOP::TargetAddress &u) + { +- if (&u == this) +- { +- return *this; +- } +- + this->_reset (u.disc_, 0); + this->disc_ = u.disc_; +- + switch (this->disc_) + { + case 0: + { +- if (u.u_.object_key_ == 0) +- { +- this->u_.object_key_ = 0; +- } +- else +- { +- ACE_NEW_RETURN ( +- this->u_.object_key_, +- GIOP::TargetAddress::_tao_seq_Octet (*u.u_.object_key_), +- *this +- ); +- } ++ ACE_NEW_RETURN ( ++ this->u_.object_key_, ++ TAO_ObjectKey (*u.u_.object_key_), ++ *this ++ ); + } + break; + case 1: + { +- if (u.u_.profile_ == 0) +- { +- this->u_.profile_ = 0; +- } +- else +- { +- ACE_NEW_RETURN ( +- this->u_.profile_, +- IOP::TaggedProfile (*u.u_.profile_), +- *this +- ); +- } ++ ACE_NEW_RETURN ( ++ this->u_.profile_, ++ IOP::TaggedProfile (*u.u_.profile_), ++ *this ++ ); + } + break; + case 2: + { +- if (u.u_.ior_ == 0) +- { +- this->u_.ior_ = 0; +- } +- else +- { +- ACE_NEW_RETURN ( +- this->u_.ior_, +- GIOP::IORAddressingInfo (*u.u_.ior_), +- *this +- ); +- } ++ ACE_NEW_RETURN ( ++ this->u_.ior_, ++ GIOP::IORAddressingInfo (*u.u_.ior_), ++ *this ++ ); + } + break; + default: + break; + } +- +- return *this; ++return *this; + } + + // reset method to reset old values of a union +@@ -494,30 +221,14 @@ + static const CORBA::Long _oc_GIOP_TargetAddress[] = + { + TAO_ENCAP_BYTE_ORDER, // byte order +- 35, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x47494f50), +- ACE_NTOHL (0x2f546172), +- ACE_NTOHL (0x67657441), +- ACE_NTOHL (0x64647265), +- ACE_NTOHL (0x73733a31), +- ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/TargetAddress:1.0 +- 14, +- ACE_NTOHL (0x54617267), +- ACE_NTOHL (0x65744164), +- ACE_NTOHL (0x64726573), +- ACE_NTOHL (0x73000000), // name = TargetAddress ++ 35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x47494f50), ACE_NTOHL (0x2f546172), ACE_NTOHL (0x67657441), ACE_NTOHL (0x64647265), ACE_NTOHL (0x73733a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/TargetAddress:1.0 ++ 14, ACE_NTOHL (0x54617267), ACE_NTOHL (0x65744164), ACE_NTOHL (0x64726573), ACE_NTOHL (0x73000000), // name = TargetAddress + CORBA::tk_short, + + -1, // default used index + 3, // member count + ACE_IDL_NSTOHL (0x0000), // union case label (evaluated value) +- 11, +- ACE_NTOHL (0x6f626a65), +- ACE_NTOHL (0x63745f6b), +- ACE_NTOHL (0x65790000), // name = object_key ++ 11, ACE_NTOHL (0x6f626a65), ACE_NTOHL (0x63745f6b), ACE_NTOHL (0x65790000), // name = object_key + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +@@ -526,54 +237,23 @@ + 0U, + + ACE_IDL_NSTOHL (0x0001), // union case label (evaluated value) +- 8, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c6500), // name = profile ++ 8, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c6500), // name = profile + CORBA::tk_struct, // typecode kind + 184, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 34, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x653a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 +- 14, +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x65000000), // name = TaggedProfile ++ 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 ++ 14, ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x65000000), // name = TaggedProfile + 2, // member count +- 4, +- ACE_NTOHL (0x74616700), // name = tag ++ 4, ACE_NTOHL (0x74616700), // name = tag + CORBA::tk_alias, // typecode kind for typedefs + 60, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 30, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x643a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 +- 10, +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x64000000), // name = ProfileId ++ 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 ++ 10, ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x64000000), // name = ProfileId + CORBA::tk_ulong, + + +- 13, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c655f), +- ACE_NTOHL (0x64617461), +- ACE_NTOHL (0x0), // name = profile_data ++ 13, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c655f), ACE_NTOHL (0x64617461), ACE_NTOHL (0x0), // name = profile_data + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +@@ -583,110 +263,46 @@ + + + ACE_IDL_NSTOHL (0x0002), // union case label (evaluated value) +- 4, +- ACE_NTOHL (0x696f7200), // name = ior ++ 4, ACE_NTOHL (0x696f7200), // name = ior + CORBA::tk_struct, // typecode kind + 412, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 39, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x47494f50), +- ACE_NTOHL (0x2f494f52), +- ACE_NTOHL (0x41646472), +- ACE_NTOHL (0x65737369), +- ACE_NTOHL (0x6e67496e), +- ACE_NTOHL (0x666f3a31), +- ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/IORAddressingInfo:1.0 +- 18, +- ACE_NTOHL (0x494f5241), +- ACE_NTOHL (0x64647265), +- ACE_NTOHL (0x7373696e), +- ACE_NTOHL (0x67496e66), +- ACE_NTOHL (0x6f000000), // name = IORAddressingInfo ++ 39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x47494f50), ACE_NTOHL (0x2f494f52), ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737369), ACE_NTOHL (0x6e67496e), ACE_NTOHL (0x666f3a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/GIOP/IORAddressingInfo:1.0 ++ 18, ACE_NTOHL (0x494f5241), ACE_NTOHL (0x64647265), ACE_NTOHL (0x7373696e), ACE_NTOHL (0x67496e66), ACE_NTOHL (0x6f000000), // name = IORAddressingInfo + 2, // member count +- 23, +- ACE_NTOHL (0x73656c65), +- ACE_NTOHL (0x63746564), +- ACE_NTOHL (0x5f70726f), +- ACE_NTOHL (0x66696c65), +- ACE_NTOHL (0x5f696e64), +- ACE_NTOHL (0x65780000), // name = selected_profile_index ++ 23, ACE_NTOHL (0x73656c65), ACE_NTOHL (0x63746564), ACE_NTOHL (0x5f70726f), ACE_NTOHL (0x66696c65), ACE_NTOHL (0x5f696e64), ACE_NTOHL (0x65780000), // name = selected_profile_index + CORBA::tk_ulong, + +- 4, +- ACE_NTOHL (0x696f7200), // name = ior ++ 4, ACE_NTOHL (0x696f7200), // name = ior + CORBA::tk_struct, // typecode kind + 288, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 24, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x494f523a), +- ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/IOP/IOR:1.0 +- 4, +- ACE_NTOHL (0x494f5200), // name = IOR ++ 24, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x494f523a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/IOP/IOR:1.0 ++ 4, ACE_NTOHL (0x494f5200), // name = IOR + 2, // member count +- 8, +- ACE_NTOHL (0x74797065), +- ACE_NTOHL (0x5f696400), // name = type_id +- CORBA::tk_string, ++ 8, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f696400), // name = type_id ++ CORBA::tk_string, + 0U, // string length +- 9, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c6573), +- ACE_NTOHL (0x0), // name = profiles ++ 9, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c6573), ACE_NTOHL (0x0), // name = profiles + CORBA::tk_sequence, // typecode kind + 200, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 184, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 34, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x653a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 +- 14, +- ACE_NTOHL (0x54616767), +- ACE_NTOHL (0x65645072), +- ACE_NTOHL (0x6f66696c), +- ACE_NTOHL (0x65000000), // name = TaggedProfile ++ 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/TaggedProfile:1.0 ++ 14, ACE_NTOHL (0x54616767), ACE_NTOHL (0x65645072), ACE_NTOHL (0x6f66696c), ACE_NTOHL (0x65000000), // name = TaggedProfile + 2, // member count +- 4, +- ACE_NTOHL (0x74616700), // name = tag ++ 4, ACE_NTOHL (0x74616700), // name = tag + CORBA::tk_alias, // typecode kind for typedefs + 60, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +- 30, +- ACE_NTOHL (0x49444c3a), +- ACE_NTOHL (0x6f6d672e), +- ACE_NTOHL (0x6f72672f), +- ACE_NTOHL (0x494f502f), +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x643a312e), +- ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 +- 10, +- ACE_NTOHL (0x50726f66), +- ACE_NTOHL (0x696c6549), +- ACE_NTOHL (0x64000000), // name = ProfileId ++ 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/IOP/ProfileId:1.0 ++ 10, ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x64000000), // name = ProfileId + CORBA::tk_ulong, + + +- 13, +- ACE_NTOHL (0x70726f66), +- ACE_NTOHL (0x696c655f), +- ACE_NTOHL (0x64617461), +- ACE_NTOHL (0x0), // name = profile_data ++ 13, ACE_NTOHL (0x70726f66), ACE_NTOHL (0x696c655f), ACE_NTOHL (0x64617461), ACE_NTOHL (0x0), // name = profile_data + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order +@@ -700,101 +316,59 @@ + + + }; ++static CORBA::TypeCode _tc_TAO_tc_GIOP_TargetAddress (CORBA::tk_union, sizeof (_oc_GIOP_TargetAddress), (char *) &_oc_GIOP_TargetAddress, 0, sizeof (GIOP::TargetAddress)); ++TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) ++TAO_NAMESPACE_BEGIN (GIOP) ++TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TargetAddress, &_tc_TAO_tc_GIOP_TargetAddress) ++TAO_NAMESPACE_END ++ ++static const CORBA::Long _oc_GIOP_Version[] = ++{ ++ TAO_ENCAP_BYTE_ORDER, // byte order ++ 29, ++ ACE_NTOHL (0x49444c3a), ++ ACE_NTOHL (0x6f6d672e), ++ ACE_NTOHL (0x6f72672f), ++ ACE_NTOHL (0x47494f50), ++ ACE_NTOHL (0x2f566572), ++ ACE_NTOHL (0x73696f6e), ++ ACE_NTOHL (0x3a312e30), ++ ACE_NTOHL (0x0), // repository ID = IDL:omg.org/GIOP/Version:1.0 ++ 8, ++ ACE_NTOHL (0x56657273), ++ ACE_NTOHL (0x696f6e00), // name = Version ++ 2, // member count ++ 6, ++ ACE_NTOHL (0x6d616a6f), ++ ACE_NTOHL (0x72000000), // name = major ++ CORBA::tk_octet, ++ ++ 6, ++ ACE_NTOHL (0x6d696e6f), ++ ACE_NTOHL (0x72000000), // name = minor ++ CORBA::tk_octet, ++ ++}; + +-static CORBA::TypeCode _tc_TAO_tc_GIOP_TargetAddress ( +- CORBA::tk_union, +- sizeof (_oc_GIOP_TargetAddress), +- (char *) &_oc_GIOP_TargetAddress, ++static CORBA::TypeCode _tc_TAO_tc_GIOP_Version ( ++ CORBA::tk_struct, ++ sizeof (_oc_GIOP_Version), ++ (char *) &_oc_GIOP_Version, + 0, +- sizeof (GIOP::TargetAddress) ++ sizeof (GIOP::Version) + ); + + TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) + TAO_NAMESPACE_BEGIN (GIOP) +-TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_TargetAddress, &_tc_TAO_tc_GIOP_TargetAddress) ++TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Version, &_tc_TAO_tc_GIOP_Version) + TAO_NAMESPACE_END + +-void operator<<= (CORBA::Any &_tao_any, const GIOP::Version &_tao_elem) // copying +-{ +- TAO_OutputCDR stream; +- stream << _tao_elem; +- _tao_any._tao_replace ( +- GIOP::_tc_Version, +- TAO_ENCAP_BYTE_ORDER, +- stream.begin () +- ); +-} +- +-void operator<<= (CORBA::Any &_tao_any, GIOP::Version *_tao_elem) // non copying +-{ +- TAO_OutputCDR stream; +- stream << *_tao_elem; +- _tao_any._tao_replace ( +- GIOP::_tc_Version, +- TAO_ENCAP_BYTE_ORDER, +- stream.begin (), +- 1, +- _tao_elem, +- GIOP::Version::_tao_any_destructor +- ); +-} +- +-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::Version *&_tao_elem) +-{ +- return _tao_any >>= ACE_const_cast(const GIOP::Version*&,_tao_elem); +-} + +-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const GIOP::Version *&_tao_elem) ++void ++GIOP::IORAddressingInfo::_tao_any_destructor (void *x) + { +- _tao_elem = 0; +- ACE_TRY_NEW_ENV +- { +- CORBA::TypeCode_var type = _tao_any.type (); +- +- CORBA::Boolean result = type->equivalent (GIOP::_tc_Version TAO_ENV_ARG_PARAMETER); +- ACE_TRY_CHECK; +- +- if (!result) +- return 0; // not equivalent +- +- if (_tao_any.any_owns_data ()) +- { +- _tao_elem = ACE_static_cast( +- const GIOP::Version*, +- _tao_any.value () +- ); +- return 1; +- } +- else +- { +- GIOP::Version *tmp; +- ACE_NEW_RETURN (tmp, GIOP::Version, 0); +- TAO_InputCDR stream ( +- _tao_any._tao_get_cdr (), +- _tao_any._tao_byte_order () +- ); +- if (stream >> *tmp) +- { +- ((CORBA::Any *)&_tao_any)->_tao_replace ( +- GIOP::_tc_Version, +- 1, +- ACE_static_cast (void *, tmp), +- GIOP::Version::_tao_any_destructor +- ); +- _tao_elem = tmp; +- return 1; +- } +- else +- { +- delete tmp; +- } +- } +- } +- ACE_CATCHANY +- { +- } +- ACE_ENDTRY; +- return 0; ++ GIOP::IORAddressingInfo *tmp = ACE_static_cast (GIOP::IORAddressingInfo*,x); ++ delete tmp; + } + + void operator<<= (CORBA::Any &_tao_any, const GIOP::IORAddressingInfo &_tao_elem) // copying +@@ -824,62 +398,70 @@ + + CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, GIOP::IORAddressingInfo *&_tao_elem) + { +- return _tao_any >>= ACE_const_cast(const GIOP::IORAddressingInfo*&,_tao_elem); +-} +- +-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const GIOP::IORAddressingInfo *&_tao_elem) +-{ +- _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); +- +- CORBA::Boolean result = type->equivalent (GIOP::_tc_IORAddressingInfo TAO_ENV_ARG_PARAMETER); ++ CORBA::Boolean result = ++ type->equivalent (GIOP::_tc_IORAddressingInfo TAO_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; +- ++ + if (!result) +- return 0; // not equivalent +- ++ { ++ _tao_elem = 0; ++ return 0; ++ } ++ + if (_tao_any.any_owns_data ()) + { +- _tao_elem = ACE_static_cast( +- const GIOP::IORAddressingInfo*, +- _tao_any.value () +- ); ++ _tao_elem = (GIOP::IORAddressingInfo *)_tao_any.value (); + return 1; + } + else + { +- GIOP::IORAddressingInfo *tmp; +- ACE_NEW_RETURN (tmp, GIOP::IORAddressingInfo, 0); ++ ACE_NEW_RETURN (_tao_elem, GIOP::IORAddressingInfo, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); +- if (stream >> *tmp) ++ if (stream >> *_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_IORAddressingInfo, + 1, +- ACE_static_cast (void *, tmp), ++ ACE_reinterpret_cast (void *, _tao_elem), + GIOP::IORAddressingInfo::_tao_any_destructor + ); +- _tao_elem = tmp; + return 1; + } + else + { +- delete tmp; ++ delete _tao_elem; ++ _tao_elem = 0; + } + } + } + ACE_CATCHANY + { ++ delete _tao_elem; ++ _tao_elem = 0; ++ return 0; + } + ACE_ENDTRY; + return 0; + } + ++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const GIOP::IORAddressingInfo *&_tao_elem) ++{ ++ return _tao_any >>= ACE_const_cast(GIOP::IORAddressingInfo*&,_tao_elem); ++} ++ ++void ++GIOP::TargetAddress::_tao_any_destructor (void *x) ++{ ++ GIOP::TargetAddress *tmp = ACE_static_cast (GIOP::TargetAddress*,x); ++ delete tmp; ++} ++ + void operator<<= ( + CORBA::Any &_tao_any, + const GIOP::TargetAddress &_tao_elem +@@ -887,13 +469,13 @@ + { + TAO_OutputCDR stream; + if (stream << _tao_elem) +- { +- _tao_any._tao_replace ( +- GIOP::_tc_TargetAddress, +- TAO_ENCAP_BYTE_ORDER, +- stream.begin () +- ); +- } ++ { ++ _tao_any._tao_replace ( ++ GIOP::_tc_TargetAddress, ++ TAO_ENCAP_BYTE_ORDER, ++ stream.begin () ++ ); ++ } + } + + void operator<<= ( +@@ -903,16 +485,16 @@ + { + TAO_OutputCDR stream; + if (stream << *_tao_elem) +- { +- _tao_any._tao_replace ( +- GIOP::_tc_TargetAddress, +- TAO_ENCAP_BYTE_ORDER, +- stream.begin (), +- 1, +- _tao_elem, +- GIOP::TargetAddress::_tao_any_destructor +- ); +- } ++ { ++ _tao_any._tao_replace ( ++ GIOP::_tc_TargetAddress, ++ TAO_ENCAP_BYTE_ORDER, ++ stream.begin (), ++ 1, ++ _tao_elem, ++ GIOP::IORAddressingInfo::_tao_any_destructor ++ ); ++ } + } + + CORBA::Boolean operator>>= ( +@@ -920,145 +502,62 @@ + GIOP::TargetAddress *&_tao_elem + ) + { +- return _tao_any >>= ACE_const_cast( +- const GIOP::TargetAddress*&, +- _tao_elem +- ); +-} +- +-CORBA::Boolean operator>>= ( +- const CORBA::Any &_tao_any, +- const GIOP::TargetAddress *&_tao_elem +- ) +-{ +- _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); +- +- CORBA::Boolean result = type->equivalent (GIOP::_tc_TargetAddress TAO_ENV_ARG_PARAMETER); ++ CORBA::Boolean result = ++ type->equivalent (GIOP::_tc_TargetAddress TAO_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; +- ++ + if (!result) +- return 0; // not equivalent +- ++ { ++ _tao_elem = 0; ++ return 0; ++ } ++ + if (_tao_any.any_owns_data ()) + { +- _tao_elem = ACE_static_cast( +- const GIOP::TargetAddress*, +- _tao_any.value () +- ); ++ _tao_elem = (GIOP::TargetAddress *)_tao_any.value (); + return 1; + } + else + { +- GIOP::TargetAddress *tmp; +- ACE_NEW_RETURN (tmp, GIOP::TargetAddress, 0); ++ ACE_NEW_RETURN (_tao_elem, GIOP::TargetAddress, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); +- +- if (stream >> *tmp) ++ ++ if (stream >> *_tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + GIOP::_tc_TargetAddress, + 1, +- ACE_static_cast (void *, tmp), +- GIOP::TargetAddress::_tao_any_destructor ++ ACE_reinterpret_cast (void *, _tao_elem), ++ GIOP::IORAddressingInfo::_tao_any_destructor + ); +- _tao_elem = tmp; + return 1; + } + else + { +- delete tmp; ++ delete _tao_elem; ++ _tao_elem = 0; + } + } + } + ACE_CATCHANY + { ++ delete _tao_elem; ++ _tao_elem = 0; + } + ACE_ENDTRY; + return 0; + } + +- +-#if !defined _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_CPP_ +-#define _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_CPP_ +- +-CORBA::Boolean operator<< ( +- TAO_OutputCDR &strm, +- const GIOP::TargetAddress::_tao_seq_Octet &_tao_sequence +- ) +-{ +- if (strm << _tao_sequence.length ()) +- { +- // encode all elements +- +-#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) +- { +- TAO_Unbounded_Sequence *oseq = +- ACE_static_cast (TAO_Unbounded_Sequence*, (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 == 0 */ +- return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); +- +-#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ +- } +- return 0; // error +-} +- +-CORBA::Boolean operator>> ( +- TAO_InputCDR &strm, +- GIOP::TargetAddress::_tao_seq_Octet &_tao_sequence ++CORBA::Boolean operator>>= ( ++ const CORBA::Any &_tao_any, ++ const GIOP::TargetAddress *&_tao_elem + ) + { +- CORBA::ULong _tao_seq_len; +- if (strm >> _tao_seq_len) +- { +- // set the length of the sequence +- _tao_sequence.length (_tao_seq_len); +- // If length is 0 we return true. +- if (0 >= _tao_seq_len) +- return 1; +- // Add a check to the length of the sequence +- // to make sure it does not exceed the length +- // of the stream. (See bug 58.) +- if (_tao_seq_len > strm.length()) +- return 0; +- // retrieve all the elements +- +-#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) +- if (ACE_BIT_DISABLED (strm.start ()->flags (), +- ACE_Message_Block::DONT_DELETE)) +- { +- TAO_ORB_Core* orb_core = strm.orb_core (); +- if (orb_core != 0 && +- strm.orb_core ()->resource_factory ()-> +- input_cdr_allocator_type_locked () == 1) +- { +- TAO_Unbounded_Sequence *oseq = +- ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); +- oseq->replace (_tao_seq_len, strm.start ()); +- oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); +- strm.skip_bytes (_tao_seq_len); +- return 1; +- } +- } +- return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); +-#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ +- return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); +- +-#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ +- } +- return 0; // error ++ return _tao_any >>= ACE_const_cast (GIOP::TargetAddress*&,_tao_elem); + } +- +-#endif /* _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_CPP_ */ +- diff --git a/TAO/tao/diffs/GIOPC.h.diff b/TAO/tao/diffs/GIOPC.h.diff new file mode 100644 index 00000000000..d75eb80a4f9 --- /dev/null +++ b/TAO/tao/diffs/GIOPC.h.diff @@ -0,0 +1,611 @@ +--- orig/GIOPC.h Thu Jan 10 11:45:43 2002 ++++ GIOPC.h Thu Jan 10 11:36:27 2002 +@@ -1,36 +1,51 @@ +-// -*- C++ -*- +-// +-// $Id$ ++/* -*- C++ -*- $Id$ */ ++ + +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ ++//============================================================================= ++/** ++ * @file GIOPC.h ++ * ++ * $Id$ ++ ++ * ++ * Generated from GIOP1_2.pidl, that contains a part of the new data ++ * type definitions for GIOP1.2 module. ++ * The code was generated by the IDL compiler and then hand-crafted ++ * to reduce the includes interdependencies. ++ * hand crafted by Balachandran Natarajan ++ * ++ */ ++//============================================================================= ++ ++// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* ++// TAO and the TAO IDL Compiler have been developed by the Center for ++// Distributed Object Computing at Washington University, St. Louis. + // + // Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html ++// http://www.cs.wustl.edu/~schmidt/TAO.html ++ ++// Readers Note: ++// This file is named GIOPC.h intentionally. Shortly the file GIOP.h ++// in $TAO_ROOT/ta would dissappear giving way to new files once the ++// pluggable messaging stuff is done. So I would assume that there ++// should be no such name clashes. + + #ifndef _TAO_IDL_GIOPC_H_ + #define _TAO_IDL_GIOPC_H_ +- + #include "ace/pre.h" +-#include "tao/corba.h" ++ ++#include "tao/corbafwd.h" ++#include "tao/IOPC.h" ++#include "tao/Object_KeyC.h" ++ ++#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) ++#include "ace/streams.h" ++#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ + + #if !defined (ACE_LACKS_PRAGMA_ONCE) + # pragma once + #endif /* ACE_LACKS_PRAGMA_ONCE */ + +-#include "tao/TAO_Export.h" +-#include "IOPC.h" + + #if defined (TAO_EXPORT_MACRO) + #undef TAO_EXPORT_MACRO +@@ -51,122 +66,61 @@ + #pragma warning(disable:4250) + #endif /* _MSC_VER */ + +-#if defined (__BORLANDC__) +-#pragma option push -w-rvl -w-rch -w-ccc -w-inl +-#endif /* __BORLANDC__ */ +- + TAO_NAMESPACE GIOP + { + typedef CORBA::Short AddressingDisposition; + typedef CORBA::Short_out AddressingDisposition_out; +- TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_AddressingDisposition; +- ++ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AddressingDisposition; ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short KeyAddr; +- ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short ProfileAddr; +- ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short ReferenceAddr; +- +- struct Version; +- class Version_var; +- +- struct TAO_Export Version +- { +- +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Version_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ + +- static void _tao_any_destructor (void*); +- +- CORBA::Octet major; +- CORBA::Octet minor; +- +- }; +- +- class TAO_Export Version_var +- { +- public: +- Version_var (void); +- Version_var (Version *); +- Version_var (const Version_var &); +- // Fixed-size types only. +- Version_var (const Version &); +- ~Version_var (void); +- +- Version_var &operator= (Version *); +- Version_var &operator= (const Version_var &); +- // Fixed-size types only. +- Version_var &operator= (const Version &); +- Version *operator-> (void); +- const Version *operator-> (void) const; +- +- operator const Version &() const; +- operator Version &(); +- operator Version &() const; +- +- // in, inout, out, _retn +- const Version &in (void) const; +- Version &inout (void); +- Version &out (void); +- Version _retn (void); +- Version *ptr (void) const; +- +- private: +- Version *ptr_; +- }; +- +- typedef Version &Version_out; +- +- TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Version; +- ++ + struct IORAddressingInfo; + class IORAddressingInfo_var; +- ++ + struct TAO_Export IORAddressingInfo + { +- ++ + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef IORAddressingInfo_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ +- + static void _tao_any_destructor (void*); +- ++ + CORBA::ULong selected_profile_index; + IOP::IOR ior; +- + }; +- ++ + class TAO_Export IORAddressingInfo_var + { + public: +- IORAddressingInfo_var (void); ++ IORAddressingInfo_var (void); // default constructor + IORAddressingInfo_var (IORAddressingInfo *); +- IORAddressingInfo_var (const IORAddressingInfo_var &); +- ~IORAddressingInfo_var (void); +- ++ IORAddressingInfo_var (const IORAddressingInfo_var &); // copy constructor ++ ~IORAddressingInfo_var (void); // destructor ++ + IORAddressingInfo_var &operator= (IORAddressingInfo *); + IORAddressingInfo_var &operator= (const IORAddressingInfo_var &); + IORAddressingInfo *operator-> (void); + const IORAddressingInfo *operator-> (void) const; +- ++ + operator const IORAddressingInfo &() const; + operator IORAddressingInfo &(); + operator IORAddressingInfo &() const; +- // Variable-size types only. +- operator IORAddressingInfo *&(); +- +- // in, inout, out, _retn ++ // in, inout, out, _retn + const IORAddressingInfo &in (void) const; + IORAddressingInfo &inout (void); + IORAddressingInfo *&out (void); + IORAddressingInfo *_retn (void); + IORAddressingInfo *ptr (void) const; +- ++ + private: + IORAddressingInfo *ptr_; + }; +- ++ + class TAO_Export IORAddressingInfo_out + { + public: +@@ -178,226 +132,188 @@ + operator IORAddressingInfo *&(); + IORAddressingInfo *&ptr (void); + IORAddressingInfo *operator-> (void); +- ++ + private: + IORAddressingInfo *&ptr_; +- // Assignment from T_var not allowed. ++ // assignment from T_var not allowed + void operator= (const IORAddressingInfo_var &); + }; +- +- TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_IORAddressingInfo; +- +- +-#if !defined (_GIOP_TARGETADDRESS_CH_) +-#define _GIOP_TARGETADDRESS_CH_ +- ++ ++ TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IORAddressingInfo; ++ ++ + class TargetAddress; + class TargetAddress_var; +- ++ + class TAO_Export TargetAddress + { + public: +- TargetAddress (void); +- TargetAddress (const TargetAddress &); +- ~TargetAddress (void); +- static void _tao_any_destructor (void*); +- +- TargetAddress &operator= (const TargetAddress &); +- ++ TargetAddress (void); // default constructor ++ TargetAddress (const TargetAddress &); // copy constructor ++ ~TargetAddress (void); // destructor ++ TargetAddress &operator= (const TargetAddress &); // copy constructor ++ + void _d (CORBA::Short); + CORBA::Short _d (void) const; +- ++ + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef TargetAddress_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ +- +- +-#if !defined (_GIOP_TARGETADDRESS__TAO_SEQ_OCTET_CH_) +-#define _GIOP_TARGETADDRESS__TAO_SEQ_OCTET_CH_ +- +- class _tao_seq_Octet; +- +- // ************************************************************* +- // _tao_seq_Octet +- // ************************************************************* +- +- class TAO_Export _tao_seq_Octet : public +-#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- TAO_Unbounded_Sequence +-#else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +- { +- public: +- _tao_seq_Octet (void); // default ctor +- _tao_seq_Octet (CORBA::ULong max); // uses max size +- _tao_seq_Octet ( +- CORBA::ULong max, +- CORBA::ULong length, +- CORBA::Octet *buffer, +- CORBA::Boolean release = 0 +- ); +- _tao_seq_Octet (const _tao_seq_Octet &); // copy ctor +- ~_tao_seq_Octet (void); +- static void _tao_any_destructor (void*); +- +-#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) +- _tao_seq_Octet ( +- CORBA::ULong length, +- const ACE_Message_Block* mb +- ) +- : TAO_Unbounded_Sequence (length, mb) {} +-#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ +- +- }; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef _tao_seq_Octet _object_key_seq; +-#endif /* ! __GNUC__ || ACE_HAS_GNUG_PRE_2_8 */ +- +- void object_key (const _tao_seq_Octet &); +- const _tao_seq_Octet &object_key (void) const; +- _tao_seq_Octet &object_key (void); +- +- void profile (const IOP::TaggedProfile &); +- const IOP::TaggedProfile &profile (void) const; +- IOP::TaggedProfile &profile (void); +- +- void ior (const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &); +- const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void) const; +- ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void); +- +- void _default (void); ++ static void _tao_any_destructor (void*); ++ ++ ++ void object_key (const TAO_ObjectKey &);// set ++ const TAO_ObjectKey &object_key (void) const; // get method (read only) ++ TAO_ObjectKey &object_key (void); // get method (read/write only) ++ ++ void profile (const IOP::TaggedProfile &);// set ++ const IOP::TaggedProfile &profile (void) const; // get method (read only) ++ IOP::TaggedProfile &profile (void); // get method (read/write only) ++ ++ void ior (const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &);// set ++ const ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void) const; // get method (read only) ++ ACE_NESTED_CLASS (GIOP, IORAddressingInfo) &ior (void); // get method (read/write only) ++ ++ void _default (); + private: + CORBA::Short disc_; +- CORBA::Short holder_; +- + union + { +- _tao_seq_Octet *object_key_; ++ TAO_ObjectKey *object_key_; + IOP::TaggedProfile *profile_; + ACE_NESTED_CLASS (GIOP, IORAddressingInfo) *ior_; +- +- } u_; +- +- // TAO extension. +- void _reset (CORBA::Short, CORBA::Boolean /* finalize */); +- // Frees any allocated storage. +- +- }; //GIOP::TargetAddress +- +- TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_TargetAddress; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_GIOP_TARGETADDRESS___VAR_CH_) +-#define _GIOP_TARGETADDRESS___VAR_CH_ +- +- class TAO_Export TargetAddress_var +- { +- public: +- TargetAddress_var (void); +- TargetAddress_var (TargetAddress *); +- TargetAddress_var (const TargetAddress_var &); +- ~TargetAddress_var (void); +- +- TargetAddress_var &operator= (TargetAddress *); +- TargetAddress_var &operator= (const TargetAddress_var &); +- TargetAddress *operator-> (void); +- const TargetAddress *operator-> (void) const; +- +- operator const TargetAddress &() const; +- operator TargetAddress &(); +- operator TargetAddress &() const; +- // Variable size types only. +- operator TargetAddress *&(); +- +- // in, inout, out, _retn +- const TargetAddress &in (void) const; +- TargetAddress &inout (void); +- TargetAddress *&out (void); +- TargetAddress *_retn (void); +- TargetAddress *ptr (void) const; +- +- private: +- TargetAddress *ptr_; +- }; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_GIOP_TARGETADDRESS___OUT_CH_) +-#define _GIOP_TARGETADDRESS___OUT_CH_ +- +- class TAO_Export TargetAddress_out +- { +- public: +- TargetAddress_out (TargetAddress *&); +- TargetAddress_out (TargetAddress_var &); +- TargetAddress_out (const TargetAddress_out &); +- TargetAddress_out &operator= (const TargetAddress_out &); +- TargetAddress_out &operator= (TargetAddress *); +- operator TargetAddress *&(); +- TargetAddress *&ptr (void); +- TargetAddress *operator-> (void); +- +- private: +- TargetAddress *&ptr_; +- // assignment from T_var not allowed. +- void operator= (const TargetAddress_var &); +- }; +- +- +-#endif /* end #if !defined */ +- +- +- } +-TAO_NAMESPACE_CLOSE // module GIOP ++ } u_; // end of union ++ // TAO extensions ++ void _reset (CORBA::Short, CORBA::Boolean); ++ // Frees any allocated storage ++ ++ void _reset (void); ++ // calls the above reset with finalize=1 ++ ++}; // GIOP::TargetAddress ++ ++TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TargetAddress; ++ ++class TAO_Export TargetAddress_var ++{ ++public: ++ TargetAddress_var (void); // default constructor ++ TargetAddress_var (TargetAddress *); ++ TargetAddress_var (const TargetAddress_var &); // copy constructor ++ ~TargetAddress_var (void); // destructor ++ ++ TargetAddress_var &operator= (TargetAddress *); ++ TargetAddress_var &operator= (const TargetAddress_var &); ++ TargetAddress *operator-> (void); ++ const TargetAddress *operator-> (void) const; ++ ++ operator const TargetAddress &() const; ++ operator TargetAddress &(); ++ operator TargetAddress &() const; ++ // in, inout, out, _retn ++ const TargetAddress &in (void) const; ++ TargetAddress &inout (void); ++ TargetAddress *&out (void); ++ TargetAddress *_retn (void); ++ TargetAddress *ptr(void) const; ++ ++private: ++ TargetAddress *ptr_; ++}; ++ ++class TAO_Export TargetAddress_out ++{ ++public: ++ TargetAddress_out (TargetAddress *&); ++ TargetAddress_out (TargetAddress_var &); ++ TargetAddress_out (const TargetAddress_out &); ++ TargetAddress_out &operator= (const TargetAddress_out &); ++ TargetAddress_out &operator= (TargetAddress *); ++ operator TargetAddress *&(); ++ TargetAddress *&ptr (void); ++ TargetAddress *operator-> (void); ++ ++private: ++ TargetAddress *&ptr_; ++ // assignment from T_var not allowed ++ void operator= (const TargetAddress_var &); ++}; ++ ++// We dont have the _var _out for this struct. If need arises we can ++// add them later. For the present the Version struct alone should be ++// sufficient ++struct TAO_Export Version ++{ ++ CORBA::Octet major; ++ CORBA::Octet minor; ++}; + +- TAO_Export void operator<<= (CORBA::Any &, const GIOP::Version &); // copying version +- TAO_Export void operator<<= (CORBA::Any &, GIOP::Version*); // noncopying version +- TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::Version *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const GIOP::Version *&); +- TAO_Export void operator<<= (CORBA::Any &, const GIOP::IORAddressingInfo &); // copying version +- TAO_Export void operator<<= (CORBA::Any &, GIOP::IORAddressingInfo*); // noncopying version +- TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::IORAddressingInfo *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const GIOP::IORAddressingInfo *&); +- TAO_Export void operator<<= (CORBA::Any &, const GIOP::TargetAddress &); // copying version +- TAO_Export void operator<<= (CORBA::Any &, GIOP::TargetAddress*); // noncopying version +- TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, GIOP::TargetAddress *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const GIOP::TargetAddress *&); +- +- #ifndef __ACE_INLINE__ +- +- TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::Version &); +- TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::Version &); +- TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::IORAddressingInfo &); +- TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::IORAddressingInfo &); +- TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::TargetAddress &); +- TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::TargetAddress &); +- +-#if !defined _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_H_ +- #define _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_H_ +- +-TAO_Export CORBA::Boolean operator<< ( +- TAO_OutputCDR &, +- const GIOP::TargetAddress::_tao_seq_Octet & +- ); +- TAO_Export CORBA::Boolean operator>> ( +- TAO_InputCDR &, +- GIOP::TargetAddress::_tao_seq_Octet & +- ); ++class TAO_Export Version_var ++{ ++public: ++ Version_var (void); ++ Version_var (Version *); ++ Version_var (const Version_var &); ++ // Fixed-size types only. ++ Version_var (const Version &); ++ ~Version_var (void); ++ ++ Version_var &operator= (Version *); ++ Version_var &operator= (const Version_var &); ++ // Fixed-size types only. ++ Version_var &operator= (const Version &); ++ Version *operator-> (void); ++ const Version *operator-> (void) const; ++ ++ operator const Version &() const; ++ operator Version &(); ++ operator Version &() const; ++ ++ // in, inout, out, _retn ++ const Version &in (void) const; ++ Version &inout (void); ++ Version &out (void); ++ Version _retn (void); ++ Version *ptr (void) const; ++ ++private: ++ Version *ptr_; ++}; + +-#endif /* _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_H_ */ ++typedef Version &Version_out; + ++TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Version; + +- #endif /* __ACE_INLINE__ */ ++} ++TAO_NAMESPACE_CLOSE // module GIOP ++ ++TAO_Export void operator<<= (CORBA::Any &, ++ const GIOP::IORAddressingInfo &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, ++ GIOP::IORAddressingInfo*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ GIOP::IORAddressingInfo *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ const GIOP::IORAddressingInfo *&); ++TAO_Export void operator<<= (CORBA::Any &, ++ const GIOP::TargetAddress &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, ++ GIOP::TargetAddress*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ GIOP::TargetAddress *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ const GIOP::TargetAddress *&); ++ ++#ifndef __ACE_INLINE__ ++ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::IORAddressingInfo &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::IORAddressingInfo &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::TargetAddress &); // ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::TargetAddress &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const GIOP::Version &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, GIOP::Version &); ++ ++#endif /* __ACE_INLINE__ */ + + + #if defined (__ACE_INLINE__) +@@ -407,10 +323,6 @@ + #if defined(_MSC_VER) && (_MSC_VER >= 1200) + #pragma warning(pop) + #endif /* _MSC_VER */ +- +-#if defined (__BORLANDC__) +-#pragma option pop +-#endif /* __BORLANDC__ */ + + #include "ace/post.h" + #endif /* ifndef */ diff --git a/TAO/tao/diffs/GIOPC.i.diff b/TAO/tao/diffs/GIOPC.i.diff new file mode 100644 index 00000000000..85d054e5341 --- /dev/null +++ b/TAO/tao/diffs/GIOPC.i.diff @@ -0,0 +1,960 @@ +--- orig/GIOPC.i Thu Jan 10 11:45:43 2002 ++++ GIOPC.i Thu Jan 10 11:39:27 2002 +@@ -1,168 +1,11 @@ +-// -*- C++ -*- +-// +-// $Id$ ++/* -*- C++ -*- $Id$ */ + +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ ++// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* ++// TAO and the TAO IDL Compiler have been developed by the Center for ++// Distributed Object Computing at Washington University, St. Louis. + // + // Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- +-// ************************************************************* +-// Inline operations for class GIOP::Version_var +-// ************************************************************* +- +-ACE_INLINE +-GIOP::Version_var::Version_var (void) // default constructor +- : ptr_ (0) +-{} +- +-ACE_INLINE +-GIOP::Version_var::Version_var (Version *p) +- : ptr_ (p) +-{} +- +-ACE_INLINE +-GIOP::Version_var::Version_var (const ::GIOP::Version_var &p) // copy constructor +-{ +- if (p.ptr_) +- ACE_NEW (this->ptr_, ::GIOP::Version (*p.ptr_)); +- else +- this->ptr_ = 0; +-} +- +-// fixed-size types only +-ACE_INLINE +-GIOP::Version_var::Version_var (const ::GIOP::Version &p) +-{ +- ACE_NEW (this->ptr_, ::GIOP::Version (p)); +-} +- +-ACE_INLINE +-GIOP::Version_var::~Version_var (void) // destructor +-{ +- delete this->ptr_; +-} +- +-ACE_INLINE GIOP::Version_var & +-GIOP::Version_var::operator= (Version *p) +-{ +- delete this->ptr_; +- this->ptr_ = p; +- return *this; +-} +- +-ACE_INLINE ::GIOP::Version_var & +-GIOP::Version_var::operator= (const ::GIOP::Version_var &p) +-{ +- if (this != &p) +- { +- if (p.ptr_ == 0) +- { +- delete this->ptr_; +- this->ptr_ = 0; +- } +- else +- { +- Version *deep_copy = +- new Version (*p.ptr_); +- +- if (deep_copy != 0) +- { +- Version *tmp = deep_copy; +- deep_copy = this->ptr_; +- this->ptr_ = tmp; +- delete deep_copy; +- } +- } +- } +- +- return *this; +-} +- +-// fixed-size types only +-ACE_INLINE GIOP::Version_var & +-GIOP::Version_var::operator= (const ::GIOP::Version &p) +-{ +- if (this->ptr_ != &p) +- { +- delete this->ptr_; +- ACE_NEW_RETURN (this->ptr_, ::GIOP::Version (p), *this); +- } +- return *this; +-} +- +-ACE_INLINE const ::GIOP::Version * +-GIOP::Version_var::operator-> (void) const +-{ +- return this->ptr_; +-} +- +-ACE_INLINE ::GIOP::Version * +-GIOP::Version_var::operator-> (void) +-{ +- return this->ptr_; +-} +- +-ACE_INLINE +-GIOP::Version_var::operator const ::GIOP::Version &() const // cast +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE +-GIOP::Version_var::operator ::GIOP::Version &() // cast +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE +-GIOP::Version_var::operator ::GIOP::Version &() const // cast +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE const ::GIOP::Version & +-GIOP::Version_var::in (void) const +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE ::GIOP::Version & +-GIOP::Version_var::inout (void) +-{ +- return *this->ptr_; +-} +- +-// mapping for fixed size +-ACE_INLINE ::GIOP::Version & +-GIOP::Version_var::out (void) +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE ::GIOP::Version +-GIOP::Version_var::_retn (void) +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE ::GIOP::Version * +-GIOP::Version_var::ptr (void) const +-{ +- return this->ptr_; +-} ++// http://www.cs.wustl.edu/~schmidt/TAO.html + + // ************************************************************* + // Inline operations for class GIOP::IORAddressingInfo_var +@@ -174,15 +17,15 @@ + {} + + ACE_INLINE +-GIOP::IORAddressingInfo_var::IORAddressingInfo_var (IORAddressingInfo *p) ++GIOP::IORAddressingInfo_var::IORAddressingInfo_var (GIOP::IORAddressingInfo *p) + : ptr_ (p) + {} + + ACE_INLINE +-GIOP::IORAddressingInfo_var::IORAddressingInfo_var (const ::GIOP::IORAddressingInfo_var &p) // copy constructor ++GIOP::IORAddressingInfo_var::IORAddressingInfo_var (const GIOP::IORAddressingInfo_var &p) // copy constructor + { + if (p.ptr_) +- ACE_NEW (this->ptr_, ::GIOP::IORAddressingInfo (*p.ptr_)); ++ ACE_NEW (this->ptr_, GIOP::IORAddressingInfo (*p.ptr_)); + else + this->ptr_ = 0; + } +@@ -194,15 +37,15 @@ + } + + ACE_INLINE GIOP::IORAddressingInfo_var & +-GIOP::IORAddressingInfo_var::operator= (IORAddressingInfo *p) ++GIOP::IORAddressingInfo_var::operator= (GIOP::IORAddressingInfo *p) + { + delete this->ptr_; + this->ptr_ = p; + return *this; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo_var & +-GIOP::IORAddressingInfo_var::operator= (const ::GIOP::IORAddressingInfo_var &p) ++ACE_INLINE GIOP::IORAddressingInfo_var & ++GIOP::IORAddressingInfo_var::operator= (const GIOP::IORAddressingInfo_var &p) + { + if (this != &p) + { +@@ -213,73 +56,66 @@ + } + else + { +- IORAddressingInfo *deep_copy = +- new IORAddressingInfo (*p.ptr_); +- ++ GIOP::IORAddressingInfo *deep_copy = ++ new GIOP::IORAddressingInfo (*p.ptr_); ++ + if (deep_copy != 0) + { +- IORAddressingInfo *tmp = deep_copy; ++ GIOP::IORAddressingInfo *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } +- ++ + return *this; + } + +-ACE_INLINE const ::GIOP::IORAddressingInfo * ++ACE_INLINE const GIOP::IORAddressingInfo * + GIOP::IORAddressingInfo_var::operator-> (void) const + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo * ++ACE_INLINE GIOP::IORAddressingInfo * + GIOP::IORAddressingInfo_var::operator-> (void) + { + return this->ptr_; + } + + ACE_INLINE +-GIOP::IORAddressingInfo_var::operator const ::GIOP::IORAddressingInfo &() const // cast ++GIOP::IORAddressingInfo_var::operator const GIOP::IORAddressingInfo &() const // cast + { + return *this->ptr_; + } + + ACE_INLINE +-GIOP::IORAddressingInfo_var::operator ::GIOP::IORAddressingInfo &() // cast ++GIOP::IORAddressingInfo_var::operator GIOP::IORAddressingInfo &() // cast + { + return *this->ptr_; + } + + ACE_INLINE +-GIOP::IORAddressingInfo_var::operator ::GIOP::IORAddressingInfo &() const // cast ++GIOP::IORAddressingInfo_var::operator GIOP::IORAddressingInfo &() const// cast + { + return *this->ptr_; + } + +-// variable-size types only +-ACE_INLINE +-GIOP::IORAddressingInfo_var::operator ::GIOP::IORAddressingInfo *&() // cast +-{ +- return this->ptr_; +-} +- +-ACE_INLINE const ::GIOP::IORAddressingInfo & ++ACE_INLINE const GIOP::IORAddressingInfo & + GIOP::IORAddressingInfo_var::in (void) const + { + return *this->ptr_; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo & ++ACE_INLINE GIOP::IORAddressingInfo & + GIOP::IORAddressingInfo_var::inout (void) + { + return *this->ptr_; + } + +-// mapping for variable size +-ACE_INLINE ::GIOP::IORAddressingInfo *& ++// mapping for variable size ++ACE_INLINE GIOP::IORAddressingInfo *& + GIOP::IORAddressingInfo_var::out (void) + { + delete this->ptr_; +@@ -287,15 +123,15 @@ + return this->ptr_; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo * ++ACE_INLINE GIOP::IORAddressingInfo * + GIOP::IORAddressingInfo_var::_retn (void) + { +- ::GIOP::IORAddressingInfo *tmp = this->ptr_; ++ GIOP::IORAddressingInfo *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo * ++ACE_INLINE GIOP::IORAddressingInfo * + GIOP::IORAddressingInfo_var::ptr (void) const + { + return this->ptr_; +@@ -306,14 +142,14 @@ + // ************************************************************* + + ACE_INLINE +-GIOP::IORAddressingInfo_out::IORAddressingInfo_out (::GIOP::IORAddressingInfo *&p) ++GIOP::IORAddressingInfo_out::IORAddressingInfo_out (GIOP::IORAddressingInfo *&p) + : ptr_ (p) + { + this->ptr_ = 0; + } + + ACE_INLINE +-GIOP::IORAddressingInfo_out::IORAddressingInfo_out (IORAddressingInfo_var &p) // constructor from _var ++GIOP::IORAddressingInfo_out::IORAddressingInfo_out (GIOP::IORAddressingInfo_var &p) // constructor from _var + : ptr_ (p.out ()) + { + delete this->ptr_; +@@ -321,37 +157,37 @@ + } + + ACE_INLINE +-GIOP::IORAddressingInfo_out::IORAddressingInfo_out (const ::GIOP::IORAddressingInfo_out &p) // copy constructor +- : ptr_ (ACE_const_cast (IORAddressingInfo_out&, p).ptr_) ++GIOP::IORAddressingInfo_out::IORAddressingInfo_out (const GIOP::IORAddressingInfo_out &p) // copy constructor ++ : ptr_ (ACE_const_cast (GIOP::IORAddressingInfo_out&,p).ptr_) + {} + + ACE_INLINE GIOP::IORAddressingInfo_out & +-GIOP::IORAddressingInfo_out::operator= (const ::GIOP::IORAddressingInfo_out &p) ++GIOP::IORAddressingInfo_out::operator= (const GIOP::IORAddressingInfo_out &p) + { +- this->ptr_ = ACE_const_cast (IORAddressingInfo_out&, p).ptr_; ++ this->ptr_ = ACE_const_cast (GIOP::IORAddressingInfo_out&,p).ptr_; + return *this; + } + + ACE_INLINE GIOP::IORAddressingInfo_out & +-GIOP::IORAddressingInfo_out::operator= (IORAddressingInfo *p) ++GIOP::IORAddressingInfo_out::operator= (GIOP::IORAddressingInfo *p) + { + this->ptr_ = p; + return *this; + } + +-ACE_INLINE +-GIOP::IORAddressingInfo_out::operator ::GIOP::IORAddressingInfo *&() // cast ++ACE_INLINE ++GIOP::IORAddressingInfo_out::operator GIOP::IORAddressingInfo *&() // cast + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo *& ++ACE_INLINE GIOP::IORAddressingInfo *& + GIOP::IORAddressingInfo_out::ptr (void) // ptr + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::IORAddressingInfo * ++ACE_INLINE GIOP::IORAddressingInfo * + GIOP::IORAddressingInfo_out::operator-> (void) + { + return this->ptr_; +@@ -361,8 +197,24 @@ + // Inline operations for union GIOP::TargetAddress + // ************************************************************* + ++// destructor ++ACE_INLINE ++GIOP::TargetAddress::~TargetAddress (void) ++{ ++ // finalize ++ this->_reset (this->disc_, 1); ++} ++ ++// this reset method is used by the decoding engine ++ACE_INLINE void ++GIOP::TargetAddress::_reset (void) ++{ ++ this->_reset (this->disc_, 1); ++ ACE_OS::memcpy (&this->u_, 0, sizeof (this->u_)); ++} ++ + // the implicit _default () method +-ACE_INLINE void ++ACE_INLINE void + GIOP::TargetAddress::_default () + { + this->disc_ = -32768; +@@ -381,28 +233,29 @@ + return this->disc_; + } + ++ + // accessor to set the member + ACE_INLINE void +-GIOP::TargetAddress::object_key (const GIOP::TargetAddress::_tao_seq_Octet &val) ++GIOP::TargetAddress::object_key (const TAO_ObjectKey &val) + { + // set the discriminant val + this->_reset (0, 0); + this->disc_ = 0; + ACE_NEW ( + this->u_.object_key_, +- GIOP::TargetAddress::_tao_seq_Octet (val) ++ TAO_ObjectKey (val) + ); + } + +-// readonly get method +-ACE_INLINE const GIOP::TargetAddress::_tao_seq_Octet & ++// readonly get method ++ACE_INLINE const TAO_ObjectKey & + GIOP::TargetAddress::object_key (void) const + { + return *this->u_.object_key_; + } + +-// read/write get method +-ACE_INLINE GIOP::TargetAddress::_tao_seq_Octet & ++// read/write get method ++ACE_INLINE TAO_ObjectKey & + GIOP::TargetAddress::object_key (void) + { + return *this->u_.object_key_; +@@ -421,14 +274,14 @@ + ); + } + +-// readonly get method ++// readonly get method + ACE_INLINE const IOP::TaggedProfile & + GIOP::TargetAddress::profile (void) const + { + return *this->u_.profile_; + } + +-// read/write get method ++// read/write get method + ACE_INLINE IOP::TaggedProfile & + GIOP::TargetAddress::profile (void) + { +@@ -448,14 +301,14 @@ + ); + } + +-// readonly get method ++// readonly get method + ACE_INLINE const GIOP::IORAddressingInfo & + GIOP::TargetAddress::ior (void) const + { + return *this->u_.ior_; + } + +-// read/write get method ++// read/write get method + ACE_INLINE GIOP::IORAddressingInfo & + GIOP::TargetAddress::ior (void) + { +@@ -476,15 +329,15 @@ + {} + + ACE_INLINE +-GIOP::TargetAddress_var::TargetAddress_var (TargetAddress *p) ++GIOP::TargetAddress_var::TargetAddress_var (GIOP::TargetAddress *p) + : ptr_ (p) + {} + + ACE_INLINE +-GIOP::TargetAddress_var::TargetAddress_var (const ::GIOP::TargetAddress_var &p) // copy constructor ++GIOP::TargetAddress_var::TargetAddress_var (const GIOP::TargetAddress_var &p) // copy constructor + { + if (p.ptr_) +- ACE_NEW (this->ptr_, ::GIOP::TargetAddress (*p.ptr_)); ++ ACE_NEW (this->ptr_, GIOP::TargetAddress (*p.ptr_)); + else + this->ptr_ = 0; + } +@@ -495,16 +348,16 @@ + delete this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress_var & +-GIOP::TargetAddress_var::operator= (TargetAddress *p) ++ACE_INLINE GIOP::TargetAddress_var & ++GIOP::TargetAddress_var::operator= (GIOP::TargetAddress *p) + { + delete this->ptr_; + this->ptr_ = p; + return *this; + } + +-ACE_INLINE ::GIOP::TargetAddress_var & +-GIOP::TargetAddress_var::operator= (const ::GIOP::TargetAddress_var &p) ++ACE_INLINE GIOP::TargetAddress_var & ++GIOP::TargetAddress_var::operator= (const GIOP::TargetAddress_var &p) + { + if (this != &p) + { +@@ -515,73 +368,66 @@ + } + else + { +- TargetAddress *deep_copy = +- new TargetAddress (*p.ptr_); +- ++ GIOP::TargetAddress *deep_copy = ++ new GIOP::TargetAddress (*p.ptr_); ++ + if (deep_copy != 0) + { +- TargetAddress *tmp = deep_copy; ++ GIOP::TargetAddress *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } +- ++ + return *this; + } + +-ACE_INLINE const ::GIOP::TargetAddress * ++ACE_INLINE const GIOP::TargetAddress * + GIOP::TargetAddress_var::operator-> (void) const + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress * ++ACE_INLINE GIOP::TargetAddress * + GIOP::TargetAddress_var::operator-> (void) + { + return this->ptr_; + } + +-ACE_INLINE +-GIOP::TargetAddress_var::operator const ::GIOP::TargetAddress &() const // cast +-{ +- return *this->ptr_; +-} +- +-ACE_INLINE +-GIOP::TargetAddress_var::operator ::GIOP::TargetAddress &() // cast ++ACE_INLINE ++GIOP::TargetAddress_var::operator const GIOP::TargetAddress &() const // cast + { + return *this->ptr_; + } + +-ACE_INLINE +-GIOP::TargetAddress_var::operator ::GIOP::TargetAddress &() const// cast ++ACE_INLINE ++GIOP::TargetAddress_var::operator GIOP::TargetAddress &() // cast + { + return *this->ptr_; + } + +-// variable-size types only + ACE_INLINE +-GIOP::TargetAddress_var::operator ::GIOP::TargetAddress *&() // cast ++GIOP::TargetAddress_var::operator GIOP::TargetAddress &() const// cast + { +- return this->ptr_; ++ return *this->ptr_; + } + +-ACE_INLINE const ::GIOP::TargetAddress & ++ACE_INLINE const GIOP::TargetAddress & + GIOP::TargetAddress_var::in (void) const + { + return *this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress & ++ACE_INLINE GIOP::TargetAddress & + GIOP::TargetAddress_var::inout (void) + { + return *this->ptr_; + } + +-// mapping for variable size +-ACE_INLINE ::GIOP::TargetAddress *& ++// mapping for variable size ++ACE_INLINE GIOP::TargetAddress *& + GIOP::TargetAddress_var::out (void) + { + delete this->ptr_; +@@ -589,15 +435,15 @@ + return this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress * ++ACE_INLINE GIOP::TargetAddress * + GIOP::TargetAddress_var::_retn (void) + { +- ::GIOP::TargetAddress *tmp = this->ptr_; ++ GIOP::TargetAddress *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; + } + +-ACE_INLINE ::GIOP::TargetAddress * ++ACE_INLINE GIOP::TargetAddress * + GIOP::TargetAddress_var::ptr (void) const + { + return this->ptr_; +@@ -615,14 +461,14 @@ + // ************************************************************* + + ACE_INLINE +-GIOP::TargetAddress_out::TargetAddress_out (TargetAddress *&p) ++GIOP::TargetAddress_out::TargetAddress_out (GIOP::TargetAddress *&p) + : ptr_ (p) + { + this->ptr_ = 0; + } + + ACE_INLINE +-GIOP::TargetAddress_out::TargetAddress_out (TargetAddress_var &p) // constructor from _var ++GIOP::TargetAddress_out::TargetAddress_out (GIOP::TargetAddress_var &p) // constructor from _var + : ptr_ (p.out ()) + { + delete this->ptr_; +@@ -630,37 +476,37 @@ + } + + ACE_INLINE +-GIOP::TargetAddress_out::TargetAddress_out (const ::GIOP::TargetAddress_out &p) // copy constructor +- : ptr_ (ACE_const_cast (TargetAddress_out&, p).ptr_) ++GIOP::TargetAddress_out::TargetAddress_out (const GIOP::TargetAddress_out &p) // copy constructor ++ : ptr_ (ACE_const_cast (GIOP::TargetAddress_out&,p).ptr_) + {} + +-ACE_INLINE ::GIOP::TargetAddress_out & +-GIOP::TargetAddress_out::operator= (const ::GIOP::TargetAddress_out &p) ++ACE_INLINE GIOP::TargetAddress_out & ++GIOP::TargetAddress_out::operator= (const GIOP::TargetAddress_out &p) + { +- this->ptr_ = ACE_const_cast (TargetAddress_out&, p).ptr_; ++ this->ptr_ = ACE_const_cast (GIOP::TargetAddress_out&,p).ptr_; + return *this; + } + +-ACE_INLINE ::GIOP::TargetAddress_out & +-GIOP::TargetAddress_out::operator= (TargetAddress *p) ++ACE_INLINE GIOP::TargetAddress_out & ++GIOP::TargetAddress_out::operator= (GIOP::TargetAddress *p) + { + this->ptr_ = p; + return *this; + } + +-ACE_INLINE +-GIOP::TargetAddress_out::operator ::GIOP::TargetAddress *&() // cast ++ACE_INLINE ++GIOP::TargetAddress_out::operator GIOP::TargetAddress *&() // cast + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress *& ++ACE_INLINE GIOP::TargetAddress *& + GIOP::TargetAddress_out::ptr (void) // ptr + { + return this->ptr_; + } + +-ACE_INLINE ::GIOP::TargetAddress * ++ACE_INLINE GIOP::TargetAddress * + GIOP::TargetAddress_out::operator-> (void) + { + return this->ptr_; +@@ -669,28 +515,149 @@ + + #endif /* end #if !defined */ + +-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const GIOP::Version &_tao_aggregate) ++// ************************************************************* ++// Inline operations for class GIOP::Version_var ++// ************************************************************* ++ ++ACE_INLINE ++GIOP::Version_var::Version_var (void) // default constructor ++ : ptr_ (0) ++{} ++ ++ACE_INLINE ++GIOP::Version_var::Version_var (Version *p) ++ : ptr_ (p) ++{} ++ ++ACE_INLINE ++GIOP::Version_var::Version_var (const ::GIOP::Version_var &p) // copy constructor + { +- if ( +- (strm << CORBA::Any::from_octet (_tao_aggregate.major)) && +- (strm << CORBA::Any::from_octet (_tao_aggregate.minor)) +- ) +- return 1; ++ if (p.ptr_) ++ ACE_NEW (this->ptr_, ::GIOP::Version (*p.ptr_)); + else +- return 0; +- ++ this->ptr_ = 0; + } + +-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, GIOP::Version &_tao_aggregate) ++// fixed-size types only ++ACE_INLINE ++GIOP::Version_var::Version_var (const ::GIOP::Version &p) + { +- if ( +- (strm >> CORBA::Any::to_octet (_tao_aggregate.major)) && +- (strm >> CORBA::Any::to_octet (_tao_aggregate.minor)) +- ) +- return 1; +- else +- return 0; +- ++ ACE_NEW (this->ptr_, ::GIOP::Version (p)); ++} ++ ++ACE_INLINE ++GIOP::Version_var::~Version_var (void) // destructor ++{ ++ delete this->ptr_; ++} ++ ++ACE_INLINE GIOP::Version_var & ++GIOP::Version_var::operator= (Version *p) ++{ ++ delete this->ptr_; ++ this->ptr_ = p; ++ return *this; ++} ++ ++ACE_INLINE ::GIOP::Version_var & ++GIOP::Version_var::operator= (const ::GIOP::Version_var &p) ++{ ++ if (this != &p) ++ { ++ if (p.ptr_ == 0) ++ { ++ delete this->ptr_; ++ this->ptr_ = 0; ++ } ++ else ++ { ++ Version *deep_copy = ++ new Version (*p.ptr_); ++ ++ if (deep_copy != 0) ++ { ++ Version *tmp = deep_copy; ++ deep_copy = this->ptr_; ++ this->ptr_ = tmp; ++ delete deep_copy; ++ } ++ } ++ } ++ ++ return *this; ++} ++ ++// fixed-size types only ++ACE_INLINE GIOP::Version_var & ++GIOP::Version_var::operator= (const ::GIOP::Version &p) ++{ ++ if (this->ptr_ != &p) ++ { ++ delete this->ptr_; ++ ACE_NEW_RETURN (this->ptr_, ::GIOP::Version (p), *this); ++ } ++ return *this; ++} ++ ++ACE_INLINE const ::GIOP::Version * ++GIOP::Version_var::operator-> (void) const ++{ ++ return this->ptr_; ++} ++ ++ACE_INLINE ::GIOP::Version * ++GIOP::Version_var::operator-> (void) ++{ ++ return this->ptr_; ++} ++ ++ACE_INLINE ++GIOP::Version_var::operator const ::GIOP::Version &() const // cast ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE ++GIOP::Version_var::operator ::GIOP::Version &() // cast ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE ++GIOP::Version_var::operator ::GIOP::Version &() const // cast ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE const ::GIOP::Version & ++GIOP::Version_var::in (void) const ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE ::GIOP::Version & ++GIOP::Version_var::inout (void) ++{ ++ return *this->ptr_; ++} ++ ++// mapping for fixed size ++ACE_INLINE ::GIOP::Version & ++GIOP::Version_var::out (void) ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE ::GIOP::Version ++GIOP::Version_var::_retn (void) ++{ ++ return *this->ptr_; ++} ++ ++ACE_INLINE ::GIOP::Version * ++GIOP::Version_var::ptr (void) const ++{ ++ return this->ptr_; + } + + ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const GIOP::IORAddressingInfo &_tao_aggregate) +@@ -702,7 +669,7 @@ + return 1; + else + return 0; +- ++ + } + + ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, GIOP::IORAddressingInfo &_tao_aggregate) +@@ -714,23 +681,29 @@ + return 1; + else + return 0; +- ++ + } + ++ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const GIOP::Version &ver) ++{ ++ if ((strm.write_octet (ver.major)) && ++ (strm.write_octet (ver.minor))) ++ return 1; ++ else ++ return 0; ++ ++} + +-#if !defined _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_I_ +-#define _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_I_ ++ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, GIOP::Version &ver) ++{ ++ if ((strm.read_octet (ver.major)) && ++ (strm.read_octet (ver.minor))) ++ return 1; ++ else ++ return 0; ++} + +-CORBA::Boolean TAO_Export operator<< ( +- TAO_OutputCDR &, +- const GIOP::TargetAddress::_tao_seq_Octet & +- ); +-CORBA::Boolean TAO_Export operator>> ( +- TAO_InputCDR &, +- GIOP::TargetAddress::_tao_seq_Octet & +- ); + +-#endif /* _TAO_CDR_OP_GIOP_TargetAddress__tao_seq_Octet_I_ */ + + ACE_INLINE CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, +@@ -780,13 +753,10 @@ + { + case 0: + { +- GIOP::TargetAddress::_tao_seq_Octet _tao_union_tmp; ++ TAO_ObjectKey _tao_union_tmp; + result = strm >> _tao_union_tmp; + if (result) +- { +- _tao_union.object_key (_tao_union_tmp); +- _tao_union._d (_tao_discriminant); +- } ++ _tao_union.object_key (_tao_union_tmp); + } + break; + case 1: +@@ -794,10 +764,7 @@ + IOP::TaggedProfile _tao_union_tmp; + result = strm >> _tao_union_tmp; + if (result) +- { +- _tao_union.profile (_tao_union_tmp); +- _tao_union._d (_tao_discriminant); +- } ++ _tao_union.profile (_tao_union_tmp); + } + break; + case 2: +@@ -805,10 +772,7 @@ + GIOP::IORAddressingInfo _tao_union_tmp; + result = strm >> _tao_union_tmp; + if (result) +- { +- _tao_union.ior (_tao_union_tmp); +- _tao_union._d (_tao_discriminant); +- } ++ _tao_union.ior (_tao_union_tmp); + } + break; + default: +@@ -817,4 +781,3 @@ + } + return result; + } +- diff --git a/TAO/tao/diffs/GIOPS.cpp.diff b/TAO/tao/diffs/GIOPS.cpp.diff new file mode 100644 index 00000000000..b70e55ba4f2 --- /dev/null +++ b/TAO/tao/diffs/GIOPS.cpp.diff @@ -0,0 +1,69 @@ +--- orig/GIOPS.cpp Thu Jan 10 11:45:43 2002 ++++ GIOPS.cpp Tue Sep 12 18:04:48 2000 +@@ -1,52 +1,22 @@ +-// -*- C++ -*- ++/* -*- C++ -*- $Id$ */ + // +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ ++// $Id$ + // +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- +-#ifndef _TAO_IDL_GIOPS_CPP_ +-#define _TAO_IDL_GIOPS_CPP_ ++// ================================================================ ++// ++// = LIBRARY ++// TAO ++// ++// = FILENAME ++// GIOPS.cpp ++// ++// = DESCRIPTION ++// Generated from GIOP.pidl ++// ++// ================================================================ + + #include "GIOPS.h" + +-#include "tao/PortableServer/Object_Adapter.h" +-#include "tao/PortableServer/Operation_Table.h" +-#include "tao/TAO_Server_Request.h" +-#include "tao/ORB_Core.h" +-#include "tao/Stub.h" +-#include "tao/IFR_Client_Adapter.h" +-#include "tao/PortableInterceptor.h" +- +-#if TAO_HAS_INTERCEPTORS == 1 +-#include "tao/RequestInfo_Util.h" +-#include "tao/PICurrent.h" +-#include "tao/PortableServer/ServerRequestInfo.h" +-#include "tao/PortableServer/ServerInterceptorAdapter.h" +-#endif /* TAO_HAS_INTERCEPTORS == 1 */ +- +-#include "ace/Dynamic_Service.h" +-#if defined (__BORLANDC__) +-#pragma option -w-rvl -w-rch -w-ccc -w-aus +-#endif /* __BORLANDC__ */ +- + #if !defined (__ACE_INLINE__) + #include "GIOPS.i" + #endif /* !defined INLINE */ +- +- +-#endif /* ifndef */ diff --git a/TAO/tao/diffs/GIOPS.h.diff b/TAO/tao/diffs/GIOPS.h.diff new file mode 100644 index 00000000000..4dac3131285 --- /dev/null +++ b/TAO/tao/diffs/GIOPS.h.diff @@ -0,0 +1,89 @@ +--- orig/GIOPS.h Thu Jan 10 11:45:43 2002 ++++ GIOPS.h Fri Dec 15 14:06:47 2000 +@@ -1,29 +1,20 @@ +-// -*- C++ -*- +-// +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ +-// +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html ++/* -*- C++ -*- $Id$ */ ++//============================================================================= ++/** ++ * @file GIOPS.h ++ * ++ * $Id$ ++ * ++ * Generated from GIOP.pidl ++ * The file is almost empty and only present to keep other IDL files ++ * that include GIOP.pidl happy. ++ * ++ */ ++//============================================================================= + +-#ifndef _TAO_IDL_GIOPS_H_ +-#define _TAO_IDL_GIOPS_H_ ++#ifndef TAO_IDL_GIOP1_2S_H ++#define TAO_IDL_GIOP1_2S_H + +-#include "ace/pre.h" +-#include "IOPS.h" + #include "GIOPC.h" + + +@@ -31,40 +22,10 @@ + # pragma once + #endif /* ACE_LACKS_PRAGMA_ONCE */ + +-#include "tao/PortableServer/PortableServer.h" +-#include "tao/PortableServer/Servant_Base.h" +-#include "tao/PortableServer/Collocated_Object.h" +-#include "tao/PortableServer/ThruPOA_Object_Proxy_Impl.h" +-#include "tao/PortableServer/Direct_Object_Proxy_Impl.h" +-#if defined(_MSC_VER) +-#if (_MSC_VER >= 1200) +-#pragma warning(push) +-#endif /* _MSC_VER >= 1200 */ +-#pragma warning(disable:4250) +-#endif /* _MSC_VER */ +- +-#if defined (__BORLANDC__) +-#pragma option push -w-rvl -w-rch -w-ccc -w-inl +-#endif /* __BORLANDC__ */ +- +-TAO_NAMESPACE POA_GIOP +-{ +-} +-TAO_NAMESPACE_CLOSE // module GIOP +- +-#include "GIOPS_T.h" ++#include "tao/GIOPS_T.h" + + #if defined (__ACE_INLINE__) + #include "GIOPS.i" + #endif /* defined INLINE */ + +-#if defined(_MSC_VER) && (_MSC_VER >= 1200) +-#pragma warning(pop) +-#endif /* _MSC_VER */ +- +-#if defined (__BORLANDC__) +-#pragma option pop +-#endif /* __BORLANDC__ */ +- +-#include "ace/post.h" + #endif /* ifndef */ diff --git a/TAO/tao/diffs/GIOPS.i.diff b/TAO/tao/diffs/GIOPS.i.diff new file mode 100644 index 00000000000..b97701de0ac --- /dev/null +++ b/TAO/tao/diffs/GIOPS.i.diff @@ -0,0 +1,25 @@ +--- orig/GIOPS.i Thu Jan 10 11:45:43 2002 ++++ GIOPS.i Tue Sep 12 18:04:48 2000 +@@ -1,21 +1 @@ +-// -*- C++ -*- +-// +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ +-// +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- ++/* -*- C++ -*- $Id$ */ diff --git a/TAO/tao/diffs/GIOPS_T.cpp.diff b/TAO/tao/diffs/GIOPS_T.cpp.diff new file mode 100644 index 00000000000..5eadc43f56a --- /dev/null +++ b/TAO/tao/diffs/GIOPS_T.cpp.diff @@ -0,0 +1,43 @@ +--- orig/GIOPS_T.cpp Thu Jan 10 11:45:43 2002 ++++ GIOPS_T.cpp Tue Sep 12 18:04:48 2000 +@@ -1,26 +1,19 @@ +-// -*- C++ -*- ++/* -*- C++ -*- $Id$ */ ++// ================================================================ + // +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ ++// = LIBRARY ++// TAO + // +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- +-#ifndef _TAO_IDL_GIOPS_T_CPP_ +-#define _TAO_IDL_GIOPS_T_CPP_ ++// = FILENAME ++// GIOPS_T.h ++// ++// = DESCRIPTION ++// Generated from GIOP.pidl ++// The file is almost empty and only present to keep other IDL files ++// that include GIOP.pidl happy. ++// ================================================================ ++#ifndef TAO_IDL_GIOP1_2S_T_CPP ++#define TAO_IDL_GIOP1_2S_T_CPP + + #include "GIOPS_T.h" + diff --git a/TAO/tao/diffs/GIOPS_T.h.diff b/TAO/tao/diffs/GIOPS_T.h.diff new file mode 100644 index 00000000000..d7e1925657f --- /dev/null +++ b/TAO/tao/diffs/GIOPS_T.h.diff @@ -0,0 +1,71 @@ +--- orig/GIOPS_T.h Thu Jan 10 11:45:43 2002 ++++ GIOPS_T.h Fri Dec 15 14:06:47 2000 +@@ -1,41 +1,20 @@ +-// -*- C++ -*- +-// +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ +-// +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- +-#ifndef _TAO_IDL_GIOPS_T_H_ +-#define _TAO_IDL_GIOPS_T_H_ +- +-#include "ace/pre.h" +-#if defined(_MSC_VER) +-#if (_MSC_VER >= 1200) +-#pragma warning(push) +-#endif /* _MSC_VER >= 1200 */ +-#pragma warning(disable:4250) +-#endif /* _MSC_VER */ +- +-#if defined (ACE_HAS_USING_KEYWORD) +-TAO_NAMESPACE POA_GIOP +-{ +-} +-TAO_NAMESPACE_CLOSE // module GIOP +-#endif /* ACE_HAS_USING_KEYWORD */ ++/* -*- C++ -*- $Id$ */ ++//============================================================================= ++/** ++ * @file GIOPS_T.h ++ * ++ * $Id$ ++ * ++ * Generated from GIOP.pidl ++ * The file is almost empty and only present to keep other IDL files ++ * that include GIOP.pidl happy. ++ * ++ */ ++//============================================================================= ++ ++#ifndef TAO_IDL_GIOP1_2S_T_H ++#define TAO_IDL_GIOP1_2S_T_H ++ + + #if defined (__ACE_INLINE__) + #include "GIOPS_T.i" +@@ -51,9 +30,4 @@ + #pragma implementation ("GIOPS_T.cpp") + #endif /* defined REQUIRED PRAGMA */ + +-#if defined(_MSC_VER) && (_MSC_VER >= 1200) +-#pragma warning(pop) +-#endif /* _MSC_VER */ +- +-#include "ace/post.h" + #endif /* ifndef */ diff --git a/TAO/tao/diffs/GIOPS_T.i.diff b/TAO/tao/diffs/GIOPS_T.i.diff new file mode 100644 index 00000000000..27f779ada9e --- /dev/null +++ b/TAO/tao/diffs/GIOPS_T.i.diff @@ -0,0 +1,25 @@ +--- orig/GIOPS_T.i Thu Jan 10 11:45:43 2002 ++++ GIOPS_T.i Tue Sep 12 18:04:48 2000 +@@ -1,21 +1 @@ +-// -*- C++ -*- +-// +-// $Id$ +- +-// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +-// TAO and the TAO IDL Compiler have been developed by: +-// Center for Distributed Object Computing +-// Washington University +-// St. Louis, MO +-// USA +-// http://www.cs.wustl.edu/~schmidt/doc-center.html +-// and +-// Distributed Object Computing Laboratory +-// University of California at Irvine +-// Irvine, CA +-// USA +-// http://doc.ece.uci.edu/ +-// +-// Information about TAO is available at: +-// http://www.cs.wustl.edu/~schmidt/TAO.html +- ++/* -*- C++ -*- $Id$ */ -- cgit v1.2.1