From 01b1bdf02d4c66624500826e483a61ccf0411fe5 Mon Sep 17 00:00:00 2001 From: coryan Date: Thu, 9 Mar 2000 03:57:35 +0000 Subject: ChangeLogTag:Wed Mar 8 19:18:10 2000 Carlos O'Ryan --- TAO/ChangeLogs/ChangeLog-02a | 231 ++++- TAO/tao/Any.cpp | 781 +++++++------- TAO/tao/Any.h | 25 +- TAO/tao/Any.i | 14 - TAO/tao/BoundsC.cpp | 36 +- TAO/tao/BoundsC.h | 3 + TAO/tao/CDR.cpp | 43 - TAO/tao/CDR.h | 16 - TAO/tao/DynAny_i.cpp | 12 +- TAO/tao/Exception.cpp | 29 +- TAO/tao/Forwarding_Servant.cpp | 15 +- TAO/tao/GIOP_Server_Request.cpp | 132 +-- TAO/tao/GIOP_Server_Request.h | 13 - TAO/tao/IIOP_Profile.cpp | 6 +- TAO/tao/Invocation.cpp | 3 +- TAO/tao/Invocation.h | 2 +- TAO/tao/Makefile | 3 +- TAO/tao/Marshal.h | 150 --- TAO/tao/MessagingS.cpp | 77 +- TAO/tao/NVList.cpp | 21 +- TAO/tao/ObjectIDList.cpp | 35 +- TAO/tao/ObjectIDList.h | 5 - TAO/tao/POAC.cpp | 119 ++- TAO/tao/POAS.cpp | 497 ++++----- TAO/tao/PolicyS.cpp | 59 +- TAO/tao/PollableS.cpp | 177 ++-- TAO/tao/SHMIOP_Profile.cpp | 6 +- TAO/tao/Server_Request.h | 77 -- TAO/tao/Services.cpp | 63 +- TAO/tao/Services.h | 13 +- TAO/tao/Stub.cpp | 313 ------ TAO/tao/Stub.h | 136 --- TAO/tao/Typecode.cpp | 439 ++++++-- TAO/tao/Typecode.h | 7 + TAO/tao/UIOP_Profile.cpp | 6 +- TAO/tao/append.cpp | 365 ++++--- TAO/tao/skip.cpp | 325 +++--- TAO/tests/Param_Test/Makefile | 1601 +++++++++++++++++++---------- TAO/tests/Param_Test/any.cpp | 92 +- TAO/tests/Param_Test/any.h | 5 - TAO/tests/Param_Test/anyop.cpp | 224 ++++ TAO/tests/Param_Test/bd_array_seq.cpp | 85 +- TAO/tests/Param_Test/bd_array_seq.h | 7 +- TAO/tests/Param_Test/bd_long_seq.cpp | 83 +- TAO/tests/Param_Test/bd_long_seq.h | 5 - TAO/tests/Param_Test/bd_short_seq.cpp | 85 +- TAO/tests/Param_Test/bd_short_seq.h | 5 - TAO/tests/Param_Test/bd_str_seq.cpp | 84 +- TAO/tests/Param_Test/bd_str_seq.h | 5 - TAO/tests/Param_Test/bd_string.cpp | 89 +- TAO/tests/Param_Test/bd_string.h | 9 - TAO/tests/Param_Test/bd_struct_seq.cpp | 83 +- TAO/tests/Param_Test/bd_struct_seq.h | 5 - TAO/tests/Param_Test/bd_wstr_seq.cpp | 84 +- TAO/tests/Param_Test/bd_wstr_seq.h | 7 +- TAO/tests/Param_Test/bd_wstring.cpp | 281 +++-- TAO/tests/Param_Test/bd_wstring.h | 11 +- TAO/tests/Param_Test/big_union.cpp | 86 +- TAO/tests/Param_Test/big_union.h | 5 - TAO/tests/Param_Test/client.cpp | 62 +- TAO/tests/Param_Test/complex_any.cpp | 84 +- TAO/tests/Param_Test/complex_any.h | 5 - TAO/tests/Param_Test/except.cpp | 81 +- TAO/tests/Param_Test/except.h | 4 - TAO/tests/Param_Test/fixed_array.cpp | 86 +- TAO/tests/Param_Test/fixed_array.h | 5 - TAO/tests/Param_Test/fixed_struct.cpp | 85 +- TAO/tests/Param_Test/fixed_struct.h | 5 - TAO/tests/Param_Test/multdim_array.cpp | 74 +- TAO/tests/Param_Test/multdim_array.h | 5 - TAO/tests/Param_Test/nested_struct.cpp | 83 +- TAO/tests/Param_Test/nested_struct.h | 5 - TAO/tests/Param_Test/objref.cpp | 95 +- TAO/tests/Param_Test/objref.h | 5 - TAO/tests/Param_Test/objref_struct.cpp | 93 +- TAO/tests/Param_Test/objref_struct.h | 4 - TAO/tests/Param_Test/param_test.idl | 16 +- TAO/tests/Param_Test/recursive_struct.cpp | 91 +- TAO/tests/Param_Test/recursive_struct.h | 6 +- TAO/tests/Param_Test/recursive_union.cpp | 103 +- TAO/tests/Param_Test/recursive_union.h | 6 +- TAO/tests/Param_Test/short.cpp | 82 +- TAO/tests/Param_Test/short.h | 9 - TAO/tests/Param_Test/typecode.cpp | 100 +- TAO/tests/Param_Test/typecode.h | 5 - TAO/tests/Param_Test/ub_any_seq.cpp | 83 +- TAO/tests/Param_Test/ub_any_seq.h | 5 - TAO/tests/Param_Test/ub_array_seq.cpp | 87 +- TAO/tests/Param_Test/ub_array_seq.h | 7 +- TAO/tests/Param_Test/ub_long_seq.cpp | 83 +- TAO/tests/Param_Test/ub_long_seq.h | 5 - TAO/tests/Param_Test/ub_objref_seq.cpp | 83 +- TAO/tests/Param_Test/ub_objref_seq.h | 5 - TAO/tests/Param_Test/ub_short_seq.cpp | 83 +- TAO/tests/Param_Test/ub_short_seq.h | 5 - TAO/tests/Param_Test/ub_str_seq.cpp | 83 +- TAO/tests/Param_Test/ub_str_seq.h | 5 - TAO/tests/Param_Test/ub_string.cpp | 83 +- TAO/tests/Param_Test/ub_string.h | 9 - TAO/tests/Param_Test/ub_struct_seq.cpp | 147 +-- TAO/tests/Param_Test/ub_struct_seq.h | 10 - TAO/tests/Param_Test/ub_wstr_seq.cpp | 83 +- TAO/tests/Param_Test/ub_wstr_seq.h | 7 +- TAO/tests/Param_Test/ub_wstring.cpp | 85 +- TAO/tests/Param_Test/ub_wstring.h | 11 +- TAO/tests/Param_Test/ulonglong.cpp | 82 +- TAO/tests/Param_Test/ulonglong.h | 4 - TAO/tests/Param_Test/var_array.cpp | 84 +- TAO/tests/Param_Test/var_array.h | 5 - TAO/tests/Param_Test/var_struct.cpp | 85 +- TAO/tests/Param_Test/var_struct.h | 4 - 111 files changed, 4187 insertions(+), 5440 deletions(-) create mode 100644 TAO/tests/Param_Test/anyop.cpp diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a index 02514807d0d..375ebf1f906 100644 --- a/TAO/ChangeLogs/ChangeLog-02a +++ b/TAO/ChangeLogs/ChangeLog-02a @@ -1,35 +1,216 @@ -Wed Mar 8 17:22:32 2000 Ossama Othman +Wed Mar 8 19:18:10 2000 Carlos O'Ryan + + * tao/Makefile: + * tao/Marshal.h: + * tao/decode.cpp: + * tao/encode.cpp: + I have started the work to remove the interpretive engine. + The first step was to remove the the encode() and decode() + methods. We have re-implemented all the other components in the + ORB to use compiled marshaling instead. + + * tao/Any.h: + * tao/Any.i: + * tao/Any.cpp: + All the methods taking void* are deprecated (unfortunately due + to an editorial mistake this resolution didn't make it into the + text of the CORBA 2.3 mapping). There is no portable way to use + them anyway. + For the time beign we have commented them out, to check that no + portion of TAO invokes them, eventually we will make them + visible again, but they will raise the CORBA::NO_IMPLEMENT + exception. + Re-implement all the basic <<= and >>= operators using + _tao_replace() instead of replace(). + The extraction operators for the CORBA::Any::to_string, + CORBA::Any::to_wstring and CORBA::Any::to_object classes were + not implemented properly. First they did not unalias the types, + and next they used equivalent() with the wrong TypeCode. + Implement the CDR operators for Any using compiled marshaling. + + * tao/Makefile: + * tao/BoundsC.h: + * tao/BoundsC.cpp: + BoundsC was not compiled, though this is the right exception to + raise from certain NVList operations. + Updated to use _tao_replace() in the >>= and <<= operators. + + * tao/CDR.h: + * tao/CDR.cpp: + Remove the decode() and encode() methods + + * tao/Stub.h: + * tao/Stub.cpp: + * tao/GIOP_Server_Request.h: + * tao/GIOP_Server_Request.cpp: + * tao/Server_Request.h: + Remove the support for interpretive marshaling. + + * tao/Invocation.h: + * tao/Invocation.cpp: + Removed old comments about interpretive marshaling. + + * tao/NVList.cpp: + It was raising CORBA::TypeCode::Bounds to signal an error, but + the correct exception is CORBA::Bounds. + + * tao/Exception.cpp: + + * tao/DynAny_i.cpp: + * tao/Forwarding_Servant.cpp: + * tao/MessagingS.cpp: + * tao/ObjectIDList.cpp: + * tao/ObjectIDList.h: + * tao/POAS.cpp: + * tao/PolicyS.cpp: + * tao/PollableS.cpp: + * tao/Services.cpp: + * tao/Services.h: + * tao/Typecode.h: + * tao/Typecode.cpp: + * tao/append.cpp: + * tao/skip.cpp: + Re-implemented several stubs using compiled marshaling. + Use _tao_replace() in <<= and >>= operators. - * docs/pluggable_protocols/index.html: - Fixed typographical errors. + * TAO_IDL/be/be_visitor_operation/ami_exception_holder_operation_cs.cpp: + Use _tao_encode() and _tao_decode() to marshal and demarshal + exceptions. Those methods are implemented using compiled + marshaling. - * tao/ORB.cpp (ORB_init): + * tao/POAC.cpp: + * TAO_IDL/be/be_visitor_array/cdr_op_ci.cpp: + * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp: + Cosmetic changes. - It doesn't make sense for argc to be zero and argv to be - non-empty/zero, or for argc to be greater than zero and argv be - zero/empty. Throw a CORBA::BAD_PARAM() exception if argc/argv - combination is invalid. + * tests/Param_Test/Makefile: + * tests/Param_Test/anyop.cpp: + New test to verify that the <<= and >>= operators work + correctly. - * tao/ORB_Core.cpp (init): + * tests/Param_Test/param_test.idl: - Throw a CORBA::BAD_PARAM() exception if an unrecognized "-ORB" - option is encountered. This behavior is in accordance with the - CORBA 2.3.1 specification. + * tests/Param_Test/client.cpp: + * tests/Param_Test/any.h: + * tests/Param_Test/any.cpp: + * tests/Param_Test/bd_array_seq.h: + * tests/Param_Test/bd_array_seq.cpp: + * tests/Param_Test/bd_long_seq.h: + * tests/Param_Test/bd_long_seq.cpp: + * tests/Param_Test/bd_short_seq.h: + * tests/Param_Test/bd_short_seq.cpp: + * tests/Param_Test/bd_str_seq.h: + * tests/Param_Test/bd_str_seq.cpp: + * tests/Param_Test/bd_string.h: + * tests/Param_Test/bd_string.cpp: + * tests/Param_Test/bd_struct_seq.h: + * tests/Param_Test/bd_struct_seq.cpp: + * tests/Param_Test/bd_wstr_seq.h: + * tests/Param_Test/bd_wstr_seq.cpp: + * tests/Param_Test/bd_wstring.h: + * tests/Param_Test/bd_wstring.cpp: + * tests/Param_Test/big_union.h: + * tests/Param_Test/big_union.cpp: + * tests/Param_Test/complex_any.h: + * tests/Param_Test/complex_any.cpp: + * tests/Param_Test/except.h: + * tests/Param_Test/except.cpp: + * tests/Param_Test/fixed_array.h: + * tests/Param_Test/fixed_array.cpp: + * tests/Param_Test/fixed_struct.h: + * tests/Param_Test/fixed_struct.cpp: + * tests/Param_Test/multdim_array.h: + * tests/Param_Test/multdim_array.cpp: + * tests/Param_Test/nested_struct.h: + * tests/Param_Test/nested_struct.cpp: + * tests/Param_Test/objref.h: + * tests/Param_Test/objref.cpp: + * tests/Param_Test/objref_struct.h: + * tests/Param_Test/objref_struct.cpp: + * tests/Param_Test/recursive_struct.h: + * tests/Param_Test/recursive_struct.cpp: + * tests/Param_Test/recursive_union.h: + * tests/Param_Test/recursive_union.cpp: + * tests/Param_Test/short.h: + * tests/Param_Test/short.cpp: + * tests/Param_Test/typecode.h: + * tests/Param_Test/typecode.cpp: + * tests/Param_Test/ub_any_seq.h: + * tests/Param_Test/ub_any_seq.cpp: + * tests/Param_Test/ub_array_seq.h: + * tests/Param_Test/ub_array_seq.cpp: + * tests/Param_Test/ub_long_seq.h: + * tests/Param_Test/ub_long_seq.cpp: + * tests/Param_Test/ub_objref_seq.h: + * tests/Param_Test/ub_objref_seq.cpp: + * tests/Param_Test/ub_short_seq.h: + * tests/Param_Test/ub_short_seq.cpp: + * tests/Param_Test/ub_str_seq.h: + * tests/Param_Test/ub_str_seq.cpp: + * tests/Param_Test/ub_string.h: + * tests/Param_Test/ub_string.cpp: + * tests/Param_Test/ub_struct_seq.h: + * tests/Param_Test/ub_struct_seq.cpp: + * tests/Param_Test/ub_wstr_seq.h: + * tests/Param_Test/ub_wstr_seq.cpp: + * tests/Param_Test/ub_wstring.h: + * tests/Param_Test/ub_wstring.cpp: + * tests/Param_Test/ulonglong.h: + * tests/Param_Test/ulonglong.cpp: + * tests/Param_Test/var_array.h: + * tests/Param_Test/var_array.cpp: + * tests/Param_Test/var_struct.h: + * tests/Param_Test/var_struct.cpp: + We now use the standard <<= and >>= operators to test DII. We + also use the add_in_arg(), add_out_arg() and add_inout_arg() + helper methods. + The add_args() method was removed because it relied on the + non-portable, deprecated and ugly replace() operation in + CORBA::Any. + The SII tests are all passing, most of the DII tests pass too, + but these changes uncovered several problems with the + implementation of deep_free(), since deep_free has to be + removed we better wait for those changes instead of trying to + support the current scheme. + + * tao/IIOP_Profile.cpp: + * tao/SHMIOP_Profile.cpp: + * tao/UIOP_Profile.cpp: + Cosmetic fixes. + +Wed Mar 8 17:22:32 2000 Ossama Othman + + * docs/pluggable_protocols/index.html: + + Fixed typographical errors. + + * tao/ORB.cpp (ORB_init): + + It doesn't make sense for argc to be zero and argv to be + non-empty/zero, or for argc to be greater than zero and argv be + zero/empty. Throw a CORBA::BAD_PARAM() exception if argc/argv + combination is invalid. + + * tao/ORB_Core.cpp (init): - Use ACE_NEW_THROW_EX(), instead of ACE_NEW_RETURN() in - "-ORBLogFile" option processing code. - - Explicitly consume "-ORBid" options passed to this method since - they are specifically handled in the CORBA::ORB_init() method. - According to the CORBA specification, if the ORBid third - argument is used then any "-ORBid" options must be ignored. - However, the above fix that forces the ORB to throw an - exception when encountering an unrecognized "-ORB" option, - also forces us to explicitly recognize the "-ORBid" option in - the TAO_ORB_Core::init() method since it may "slip" through when - both the ORBid third argument to CORBA::ORB_init() and a - "-ORBid" ORB option are provided. + Throw a CORBA::BAD_PARAM() exception if an unrecognized "-ORB" + option is encountered. This behavior is in accordance with the + CORBA 2.3.1 specification. + + Use ACE_NEW_THROW_EX(), instead of ACE_NEW_RETURN() in + "-ORBLogFile" option processing code. + + Explicitly consume "-ORBid" options passed to this method since + they are specifically handled in the CORBA::ORB_init() method. + According to the CORBA specification, if the ORBid third + argument is used then any "-ORBid" options must be ignored. + However, the above fix that forces the ORB to throw an + exception when encountering an unrecognized "-ORB" option, + also forces us to explicitly recognize the "-ORBid" option in + the TAO_ORB_Core::init() method since it may "slip" through when + both the ORBid third argument to CORBA::ORB_init() and a + "-ORBid" ORB option are provided. Wed Mar 8 12:03:21 2000 Carlos O'Ryan diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp index ef0bfeec8a6..fca84306ff2 100644 --- a/TAO/tao/Any.cpp +++ b/TAO/tao/Any.cpp @@ -76,42 +76,61 @@ CORBA_Any::CORBA_Any (void) // and either holds or "consumes" an arbitrary data value satisfying // the normal binary interface rules. -CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc, - void *value, - CORBA::Boolean any_owns_data) - : type_ (CORBA::TypeCode::_duplicate (tc)), - value_ (value), +#if 0 +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr, + void *, + CORBA::Environment &ACE_TRY_ENV) + : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)), + value_ (0), byte_order_ (TAO_ENCAP_BYTE_ORDER), cdr_ (0), - any_owns_data_ (any_owns_data) + any_owns_data_ (0) { - ACE_DECLARE_NEW_CORBA_ENV; + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} - ACE_TRY - { - if (this->value_ != 0) - { - TAO_OutputCDR stream; +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr, + void *, + CORBA::Boolean, + CORBA::Environment &ACE_TRY_ENV) + : type_ (CORBA::TypeCode::_duplicate (CORBA::_tc_null)), + value_ (0), + byte_order_ (TAO_ENCAP_BYTE_ORDER), + cdr_ (0), + any_owns_data_ (0) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} - // Encode the value. - stream.encode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; +// All-at-once replacement of the contents of an "Any." - // Retrieve the start of the message block chain and save it. - this->byte_order_ = TAO_ENCAP_BYTE_ORDER; - ACE_NEW (this->cdr_, ACE_Message_Block); - ACE_CDR::consolidate (this->cdr_, stream.begin ()); - } - } - ACE_CATCHANY - { - // do nothing - } - ACE_ENDTRY; - ACE_CHECK; +void +CORBA_Any::replace (CORBA::TypeCode_ptr, + const void *, + CORBA::Boolean, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} + +void +CORBA_Any::replace (CORBA::TypeCode_ptr, + const void *, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_THROW (CORBA::NO_IMPLEMENT ()); +} +#endif /* 0 */ + +CORBA_Any::CORBA_Any (CORBA::TypeCode_ptr tc, + CORBA::Environment &) + : type_ (CORBA::TypeCode::_duplicate (tc)), + value_ (0), + byte_order_ (TAO_ENCAP_BYTE_ORDER), + cdr_ (0), + any_owns_data_ (0) +{ + // ACE_THROW (CORBA::NO_IMPLEMENT ()); } // Constructor using a message block. @@ -238,53 +257,8 @@ CORBA_Any::~CORBA_Any (void) ACE_CHECK; } -// All-at-once replacement of the contents of an "Any." - -void -CORBA_Any::replace (CORBA::TypeCode_ptr tc, - const void *value, - CORBA::Boolean any_owns_data, - CORBA::Environment &ACE_TRY_ENV) -{ - // Decrement the refcount on the Message_Block we hold, it does not - // matter if we own the data or not, because we always own the - // message block (i.e. it is always cloned or duplicated). - ACE_Message_Block::release (this->cdr_); - this->cdr_ = 0; - - this->free_value (ACE_TRY_ENV); - ACE_CHECK; - - // Duplicate tc and then release this->type_, just in case tc and - // type_ are the same thing. - CORBA::TypeCode_ptr tmp = - CORBA::TypeCode::_duplicate (tc); - CORBA::release (this->type_); - this->type_ = tmp; - - this->value_ = ACE_const_cast (void *, value); - this->any_owns_data_ = any_owns_data; - this->cdr_ = 0; - - if (value) - { - // @@ NW: I think an Any should alway owns the CDR stream, - // so I removed the check here. - // if the Any owns the data, we encode the "value" into a CDR stream - // and store it. We also destroy the "value" since we own it. - TAO_OutputCDR stream; - stream.encode (tc, - value, - 0, - ACE_TRY_ENV); - ACE_CHECK; - - // Retrieve the start of the message block chain and duplicate it. - this->byte_order_ = TAO_ENCAP_BYTE_ORDER; - ACE_NEW (this->cdr_, ACE_Message_Block); - ACE_CDR::consolidate (this->cdr_, stream.begin ()); - } -} +// TAO proprietary methods, used in the implementation of the >>= and +// <<= operators. void CORBA_Any::_tao_replace (CORBA::TypeCode_ptr tc, @@ -390,15 +364,9 @@ CORBA_Any::_tao_encode (TAO_OutputCDR &cdr, TAO_ORB_Core *orb_core, CORBA::Environment &ACE_TRY_ENV) { - // If the Any owns the data, then we have allocated space. - if (this->value_ != 0) - { - (void) cdr.encode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - return; - } + // Always append the CDR stream, even when the value_. + if (this->cdr_ == 0) + ACE_THROW (CORBA::NO_IMPLEMENT ()); TAO_InputCDR in (this->cdr_, this->byte_order_, @@ -412,15 +380,7 @@ void CORBA_Any::_tao_decode (TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { - if (this->value_ != 0) - { - // @@ Should we free that value first? - cdr.decode (this->type_, - this->value_, - 0, - ACE_TRY_ENV); - return; - } + // Just read into the CDR stream... // @@ (JP) The following code depends on the fact that // TAO_InputCDR does not contain chained message blocks, @@ -467,13 +427,16 @@ CORBA_Any::operator<<= (CORBA::Short s) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << s; CORBA::Short *ns; - ACE_NEW (ns, - CORBA::Short (s)); - this->replace (CORBA::_tc_short, - ns, - 1, - ACE_TRY_ENV); + ACE_NEW (ns, CORBA::Short (s)); + this->_tao_replace (CORBA::_tc_short, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ns, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -491,13 +454,16 @@ CORBA_Any::operator<<= (CORBA::UShort s) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << s; CORBA::UShort *ns; - ACE_NEW (ns, - CORBA::UShort (s)); - this->replace (CORBA::_tc_ushort, - ns, - 1, - ACE_TRY_ENV); + ACE_NEW (ns, CORBA::UShort (s)); + this->_tao_replace (CORBA::_tc_ushort, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ns, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -515,13 +481,16 @@ CORBA_Any::operator<<= (CORBA::Long l) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << l; CORBA::Long *nl; - ACE_NEW (nl, - CORBA::Long (l)); - this->replace (CORBA::_tc_long, - nl, - 1, - ACE_TRY_ENV); + ACE_NEW (nl, CORBA::Long (l)); + this->_tao_replace (CORBA::_tc_long, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nl, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -539,13 +508,16 @@ CORBA_Any::operator<<= (CORBA::ULong l) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << l; CORBA::ULong *nl; - ACE_NEW (nl, - CORBA::ULong (l)); - this->replace (CORBA::_tc_ulong, - nl, - 1, - ACE_TRY_ENV); + ACE_NEW (nl, CORBA::ULong (l)); + this->_tao_replace (CORBA::_tc_ulong, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nl, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -563,13 +535,16 @@ CORBA_Any::operator<<= (CORBA::LongLong l) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << l; CORBA::LongLong *nl; - ACE_NEW (nl, - CORBA::LongLong (l)); - this->replace (CORBA::_tc_longlong, - nl, - 1, - ACE_TRY_ENV); + ACE_NEW (nl, CORBA::LongLong (l)); + this->_tao_replace (CORBA::_tc_longlong, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nl, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -587,13 +562,16 @@ CORBA_Any::operator<<= (CORBA::ULongLong l) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << l; CORBA::ULongLong *nl; - ACE_NEW (nl, - CORBA::ULongLong (l)); - this->replace (CORBA::_tc_ulonglong, - nl, - 1, - ACE_TRY_ENV); + ACE_NEW (nl, CORBA::ULongLong (l)); + this->_tao_replace (CORBA::_tc_ulonglong, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nl, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -611,13 +589,16 @@ CORBA_Any::operator<<= (CORBA::Float f) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << f; CORBA::Float *nf; - ACE_NEW (nf, - CORBA::Float (f)); - this->replace (CORBA::_tc_float, - nf, - 1, - ACE_TRY_ENV); + ACE_NEW (nf, CORBA::Float (f)); + this->_tao_replace (CORBA::_tc_float, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nf, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -635,13 +616,16 @@ CORBA_Any::operator<<= (CORBA::Double d) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << d; CORBA::Double *nd; - ACE_NEW (nd, - CORBA::Double (d)); - this->replace (CORBA::_tc_double, - nd, - 1, - ACE_TRY_ENV); + ACE_NEW (nd, CORBA::Double (d)); + this->_tao_replace (CORBA::_tc_double, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nd, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -654,18 +638,21 @@ CORBA_Any::operator<<= (CORBA::Double d) } void -CORBA_Any::operator<<= (CORBA::LongDouble ld) +CORBA_Any::operator<<= (CORBA::LongDouble d) { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { - CORBA::LongDouble *nld; - ACE_NEW (nld, - CORBA::LongDouble (ld)); - this->replace (CORBA::_tc_longdouble, - nld, - 1, - ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << d; + CORBA::LongDouble *nd; + ACE_NEW (nd, CORBA::LongDouble (d)); + this->_tao_replace (CORBA::_tc_longdouble, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nd, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -684,13 +671,16 @@ CORBA_Any::operator<<= (const CORBA_Any& a) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << a; CORBA_Any_ptr na; - ACE_NEW (na, - CORBA::Any (a)); - this->replace (CORBA::_tc_any, - na, - 1, - ACE_TRY_ENV); + ACE_NEW (na, CORBA::Any (a)); + this->_tao_replace (CORBA::_tc_any, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + na, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -704,15 +694,19 @@ CORBA_Any::operator<<= (const CORBA_Any& a) // insertion of Any - non-copying void -CORBA::Any::operator<<= (CORBA::Any_ptr anyptr) +CORBA::Any::operator<<= (CORBA::Any* a) { ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { - this->replace (CORBA::_tc_any, - anyptr, - 1, - ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *a; + this->_tao_replace (CORBA::_tc_any, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + a, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -732,13 +726,16 @@ CORBA_Any::operator<<= (from_boolean b) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << b; CORBA::Boolean *nb; - ACE_NEW (nb, - CORBA::Boolean (b.val_)); - this->replace (CORBA::_tc_boolean, - nb, - 1, - ACE_TRY_ENV); + ACE_NEW (nb, CORBA::Boolean (b.val_)); + this->_tao_replace (CORBA::_tc_boolean, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nb, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -756,13 +753,16 @@ CORBA_Any::operator<<= (from_octet o) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << o; CORBA::Octet *no; - ACE_NEW (no, - CORBA::Octet (o.val_)); - this->replace (CORBA::_tc_octet, - no, - 1, - ACE_TRY_ENV); + ACE_NEW (no, CORBA::Octet (o.val_)); + this->_tao_replace (CORBA::_tc_octet, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + no, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -780,13 +780,16 @@ CORBA_Any::operator<<= (from_char c) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << c; CORBA::Char *nc; - ACE_NEW (nc, - CORBA::Char (c.val_)); - this->replace (CORBA::_tc_char, - nc, - 1, - ACE_TRY_ENV); + ACE_NEW (nc, CORBA::Char (c.val_)); + this->_tao_replace (CORBA::_tc_char, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nc, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -804,13 +807,16 @@ CORBA_Any::operator<<= (from_wchar wc) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { + TAO_OutputCDR stream; + stream << wc; CORBA::WChar *nwc; - ACE_NEW (nwc, - CORBA::WChar (wc.val_)); - this->replace (CORBA::_tc_wchar, - nwc, - 1, - ACE_TRY_ENV); + ACE_NEW (nwc, CORBA::WChar (wc.val_)); + this->_tao_replace (CORBA::_tc_wchar, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + nwc, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -829,16 +835,20 @@ CORBA_Any::operator<<= (CORBA::TypeCode_ptr tc) ACE_TRY { + TAO_OutputCDR stream; + stream << tc; CORBA::TypeCode_ptr *_tao_tc; ACE_NEW (_tao_tc, CORBA::TypeCode_ptr); *_tao_tc = CORBA::TypeCode::_duplicate (tc); - this->replace (CORBA::_tc_TypeCode, - _tao_tc, - 1, - ACE_TRY_ENV); + this->_tao_replace (CORBA::_tc_TypeCode, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_tc, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -897,16 +907,20 @@ CORBA::Any::operator<<= (CORBA::Object_ptr *objptr) ACE_TRY { + TAO_OutputCDR stream; + stream << *objptr; CORBA::Object_ptr *_tao_object_ptr; ACE_NEW (_tao_object_ptr, CORBA::Object_ptr); *_tao_object_ptr = *objptr; - this->replace (CORBA::_tc_Object, - _tao_object_ptr, - 1, - ACE_TRY_ENV); + this->_tao_replace (CORBA::_tc_Object, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_object_ptr, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -927,6 +941,9 @@ CORBA_Any::operator<<= (from_string s) ACE_TRY { + TAO_OutputCDR stream; + stream << s; + // If the inserted string is bounded, we create a typecode. static CORBA::Long _oc_string [] = { @@ -967,10 +984,12 @@ CORBA_Any::operator<<= (from_string s) char* (CORBA::string_dup (s.val_))); } - this->replace (tc, - tmp, - 1, - ACE_TRY_ENV); + this->_tao_replace (tc, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -989,6 +1008,9 @@ CORBA_Any::operator<<= (from_wstring ws) ACE_TRY { + TAO_OutputCDR stream; + stream << ws; + // If the inserted string is bounded, we create a typecode. static CORBA::Long _oc_wstring [] = { @@ -1029,10 +1051,12 @@ CORBA_Any::operator<<= (from_wstring ws) CORBA::WChar* (CORBA::wstring_dup (ws.val_))); } - this->replace (tc, - tmp, - 1, - ACE_TRY_ENV); + this->_tao_replace (tc, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -1440,17 +1464,8 @@ CORBA_Any::operator>>= (CORBA::Any &a) const { TAO_InputCDR stream (this->cdr_, this->byte_order_); - // decode the CDR - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_any, - &a, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - ? 1 - : 0); + if (stream >> a) + return 1; } } else @@ -1475,55 +1490,37 @@ CORBA_Any::operator>>= (const CORBA::Any *&a) const ACE_TRY { - CORBA::Boolean result = + CORBA::Boolean equivalent = this->type_->equivalent (CORBA::_tc_any, ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + if (!equivalent) + return 0; + if (this->any_owns_data_ && this->value_) { - if (this->any_owns_data_ && this->value_) - { - a = (CORBA::Any *) this->value_; - return 1; - } - else - { - ACE_NEW_RETURN (a, - CORBA::Any, - 0); - TAO_InputCDR stream (this->cdr_, - this->byte_order_); - // decode the CDR - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_any, - a, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - return 1; - } - else - { - delete ACE_const_cast (CORBA::Any *&, a); - a = 0; - return 0; - } - } + a = (CORBA::Any *) this->value_; + return 1; } else { - a = 0; - return 0; + ACE_NEW_RETURN (a, + CORBA::Any, + 0); + TAO_InputCDR stream (this->cdr_, + this->byte_order_); + if (stream >> *ACE_const_cast (CORBA::Any*&,a)) + return 1; + delete ACE_const_cast (CORBA::Any *&, a); } } ACE_CATCHANY { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("Exception in CORBA::Any extraction\n"))); + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("Exception in CORBA::Any extraction\n"))); + } } ACE_ENDTRY; @@ -1814,15 +1811,8 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const { TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, this->byte_order_); - CORBA::TypeCode::traverse_status retval = - stream.decode (CORBA::_tc_TypeCode, - &tc, - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - return (CORBA::Boolean) ((retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - ? 1 - : 0); + if (stream >> tc) + return 1; } } else @@ -2013,47 +2003,44 @@ CORBA_Any::operator>>= (to_string s) const ACE_TRY { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_string, - ACE_TRY_ENV); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + + while (kind == CORBA::tk_alias) { - CORBA::ULong bound = this->type_->length (ACE_TRY_ENV); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; + + kind = tcvar->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (s.bound_ == bound) // bounds are same - { - if (this->any_owns_data_ && this->value_) - { - s.val_ = *(char **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - if (stream.read_string (s.val_)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - return 1; - } - else - { - return 0; - } - } - } - else - { - return 0; - } } - else + + if (kind != CORBA::tk_string) + return 0; + + CORBA::ULong bound = tcvar->length (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (s.bound_ != bound) + return 0; + + if (this->any_owns_data_ && this->value_) { - return 0; + s.val_ = *(char **) this->value_; + return 1; + } + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + if (stream.read_string (s.val_)) + { + ACE_const_cast (CORBA_Any *,this)->any_owns_data_ = 1; + return 1; } + // FALLTHROUGH } ACE_CATCHANY { @@ -2072,46 +2059,42 @@ CORBA_Any::operator>>= (to_wstring ws) const ACE_TRY { - CORBA::Boolean result = - this->type_->equivalent (CORBA::_tc_wstring, - ACE_TRY_ENV); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + + while (kind == CORBA::tk_alias) { - CORBA::ULong bound = this->type_->length (ACE_TRY_ENV); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; + + kind = tcvar->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (ws.bound_ == bound) // bounds are same - { - if (this->any_owns_data_ && this->value_) - { - ws.val_ = *(CORBA::WChar **) this->value_; - return 1; - } - else - { - TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, - this->byte_order_); - if (stream.read_wstring (ws.val_)) - { - ACE_const_cast (CORBA_Any *, - this)->any_owns_data_ = 1; - return 1; - } - else - { - return 0; - } - } - } - else - { - return 0; - } } - else + + if (kind != CORBA::tk_wstring) + return 0; + + CORBA::ULong bound = tcvar->length (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (ws.bound_ != bound) + return 0; + + if (this->any_owns_data_ && this->value_) { - return 0; + ws.val_ = *(CORBA::WChar **) this->value_; + return 1; + } + + TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_, + this->byte_order_); + if (stream.read_wstring (ws.val_)) + { + ACE_const_cast (CORBA_Any *,this)->any_owns_data_ = 1; + return 1; } } ACE_CATCHANY @@ -2131,40 +2114,43 @@ CORBA_Any::operator>>= (to_object obj) const ACE_TRY { - // Any interface is allowed - CORBA::Boolean result = - (this->type_->kind (ACE_TRY_ENV) == CORBA::tk_objref); + CORBA::ULong kind = + this->type_->kind (ACE_TRY_ENV); ACE_TRY_CHECK; - if (result) + CORBA::TypeCode_var tcvar = + CORBA::TypeCode::_duplicate (this->type_); + + while (kind == CORBA::tk_alias) { - if (this->any_owns_data_ && this->value_) - { - // CORBA 2.3 has changed the behavior of this operator. Caller - // is now responsible for release. - obj.ref_ = - CORBA::Object::_duplicate (*(CORBA::Object_ptr *) this->value_); + tcvar = tcvar->content_type (ACE_TRY_ENV); + ACE_TRY_CHECK; - return 1; - } - else - { - // @@ This uses ORB_Core instance because we need one to - // demarshal objects (to create the right profiles for that - // object), but the Any does not belong to any ORB. - TAO_InputCDR stream (this->cdr_, - this->byte_order_, - TAO_ORB_Core_instance ()); + kind = tcvar->kind (ACE_TRY_ENV); + ACE_TRY_CHECK; + } - int result = stream >> obj.ref_; + if (kind != CORBA::tk_objref) + return 0; - return !result; - } - } - else + if (this->any_owns_data_ && this->value_) { - return 0; + // CORBA 2.3 has changed the behavior of this operator. Caller + // is now responsible for release. + obj.ref_ = + CORBA::Object::_duplicate (*(CORBA::Object_ptr *)this->value_); + return 1; } + + // @@ This uses ORB_Core instance because we need one to + // demarshal objects (to create the right profiles for that + // object), but the Any does not belong to any ORB. + TAO_InputCDR stream (this->cdr_, + this->byte_order_, + TAO_ORB_Core_instance ()); + + if (stream >> obj.ref_) + return 1; } ACE_CATCHANY { @@ -2186,15 +2172,19 @@ CORBA_Any::operator<<= (const char* s) ACE_TRY { + TAO_OutputCDR stream; + stream << s; char **tmp; ACE_NEW (tmp, char * (CORBA::string_dup (s))); - this->replace (CORBA::_tc_string, - tmp, - 1, - ACE_TRY_ENV); + this->_tao_replace (CORBA::_tc_string, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -2214,15 +2204,19 @@ CORBA_Any::operator<<= (const CORBA::WChar* s) ACE_TRY { + TAO_OutputCDR stream; + stream << s; CORBA::WChar **tmp; ACE_NEW (tmp, CORBA::WChar * (CORBA::wstring_dup (s))); - this->replace (CORBA::_tc_wstring, - tmp, - 1, - ACE_TRY_ENV); + this->_tao_replace (CORBA::_tc_wstring, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + tmp, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -2238,46 +2232,71 @@ CORBA::Boolean operator<< (TAO_OutputCDR& cdr, const CORBA::Any &x) { - // @@ This function should *not* use the interpreter, there must be - // a way to do this with just CDR operations!!!! + if (!(cdr << x.type ())) + return 0; + ACE_TRY_NEW_ENV { - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_ANY::instance ()->encode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); + TAO_InputCDR input (x._tao_get_cdr (), + x._tao_byte_order ()); + cdr.append (x.type (), + &input, + ACE_TRY_ENV); ACE_TRY_CHECK; - - if (status== CORBA::TypeCode::TRAVERSE_CONTINUE) - return 1; - // else return 0 at the end of the function } ACE_CATCH (CORBA_Exception, ex) { return 0; } ACE_ENDTRY; - return 0; + return 1; } CORBA::Boolean operator>> (TAO_InputCDR &cdr, CORBA::Any &x) { + CORBA::TypeCode_var tc; + if (!(cdr >> tc.out ())) + return 0; + ACE_TRY_NEW_ENV { + // @@ (JP) The following code depends on the fact that + // TAO_InputCDR does not contain chained message blocks, + // otherwise and could be part of + // different buffers! + + // This will be the start of a new message block. + char *begin = cdr.rd_ptr (); + + // Skip over the next aregument. CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_ANY::instance ()->decode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); - ACE_TRY_CHECK; + cdr.skip (tc.in (), ACE_TRY_ENV); + ACE_CHECK; if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - return 0; + { + ACE_THROW (CORBA::MARSHAL ()); + } + + // This will be the end of the new message block. + char *end = cdr.rd_ptr (); + + size_t size = end - begin; + ACE_Message_Block mb (size + ACE_CDR::MAX_ALIGNMENT); + ACE_CDR::mb_align (&mb); + ptr_arith_t offset = ptr_arith_t (begin) % ACE_CDR::MAX_ALIGNMENT; + mb.rd_ptr (offset); + mb.wr_ptr (offset + size); + ACE_OS::memcpy (mb.rd_ptr (), begin, size); + + // Stick it into the Any. It gets duplicated there. + x._tao_replace (tc.in (), + cdr.byte_order (), + &mb, + ACE_TRY_ENV); + ACE_CHECK; } ACE_CATCH (CORBA_Exception, ex) { diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h index 88a1d32f043..a7e719ef13e 100644 --- a/TAO/tao/Any.h +++ b/TAO/tao/Any.h @@ -74,9 +74,9 @@ public: // Default constructor. CORBA_Any (CORBA::TypeCode_ptr type, - void *value = 0, - CORBA::Boolean any_owns_data = 0); - // Constructor. The any_owns_data flag determines if the Any owns the value + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + // Constructor. // = TAO extension CORBA_Any (CORBA::TypeCode_ptr type, @@ -278,20 +278,31 @@ public: // ORBOS/90-01-11, pg 672: For C++ mapping using the CORBA_Environment // parameter, two forms of the replace method are provided. +#if 0 + CORBA_Any (CORBA::TypeCode_ptr type, + void *value, + CORBA::Boolean any_owns_data, + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + CORBA_Any (CORBA::TypeCode_ptr type, + void *value, + CORBA::Environment &ACE_TRY_ENV + = TAO_default_environment ()); + // Obsolete. Raises CORBA::NO_IMPLEMENT. + void replace (CORBA::TypeCode_ptr type, const void *value, CORBA::Boolean any_owns_data, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. + // Obsolete. Raises CORBA::NO_IMPLEMENT. void replace (CORBA::TypeCode_ptr type, const void *value, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - // Replace the current typecode and data with the specified one - - // unsafe. This uses a default value for the "any_owns_data" parameter + // Obsolete. Raises CORBA::NO_IMPLEMENT. +#endif CORBA::TypeCode_ptr type (void) const; // Return TypeCode of the element stored in the Any. diff --git a/TAO/tao/Any.i b/TAO/tao/Any.i index 370cd09cafa..1c709977d11 100644 --- a/TAO/tao/Any.i +++ b/TAO/tao/Any.i @@ -3,20 +3,6 @@ // Insertion from special types. -ACE_INLINE -void -CORBA_Any::replace (CORBA::TypeCode_ptr type, - const void *value, - CORBA::Environment &ACE_TRY_ENV) -{ - // Invoke the first form of the replace method and pass the default - // value (FALSE) for the "any_owns_data" parameter - this->replace (type, - value, - 0, - ACE_TRY_ENV); -} - ACE_INLINE CORBA::Boolean CORBA_Any::any_owns_data (void) const { diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp index eb573600bd1..9fd40aa7df2 100644 --- a/TAO/tao/BoundsC.cpp +++ b/TAO/tao/BoundsC.cpp @@ -85,7 +85,7 @@ CORBA::Exception *CORBA_Bounds::_alloc (void) -void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) { CORBA::Bounds *_tao_any_val = 0; ACE_NEW (_tao_any_val, @@ -93,7 +93,14 @@ void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copyi if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_Bounds, _tao_any_val, 1, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_any_val; + _tao_any._tao_replace (CORBA::_tc_Bounds, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -107,7 +114,14 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::Bounds *_tao_elem) // non copying { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace (CORBA::_tc_Bounds, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY {} @@ -129,24 +143,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Bounds *&_tao_ele else { ACE_NEW_RETURN (_tao_elem, CORBA::Bounds, 0); - TAO_InputCDR stream (_tao_any._tao_get_cdr (), - _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_Bounds, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order ()); + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_Bounds, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_Bounds, + 1, + ACE_reinterpret_cast (void*, _tao_elem), + ACE_TRY_ENV); ACE_TRY_CHECK; return 1; } else { delete _tao_elem; + _tao_elem = 0; } } } ACE_CATCHANY { delete _tao_elem; + _tao_elem = 0; return 0; } ACE_ENDTRY; diff --git a/TAO/tao/BoundsC.h b/TAO/tao/BoundsC.h index 88c4c544276..7be65208973 100644 --- a/TAO/tao/BoundsC.h +++ b/TAO/tao/BoundsC.h @@ -11,6 +11,9 @@ #define _TAO_IDL_BOUNDSC_H_ #include "tao/corbafwd.h" +#include "tao/Exception.h" +#include "tao/CDR.h" +#include "tao/Any.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once diff --git a/TAO/tao/CDR.cpp b/TAO/tao/CDR.cpp index 3755ec6ffe6..4a6f6405cec 100644 --- a/TAO/tao/CDR.cpp +++ b/TAO/tao/CDR.cpp @@ -123,27 +123,6 @@ TAO_OutputCDR::TAO_OutputCDR (ACE_Message_Block *data, this->wchar_translator_ = wchar_translator; } -CORBA::TypeCode::traverse_status -TAO_OutputCDR::encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_Marshal_Object *mobj = - TAO_MARSHAL_FACTORY::instance ()->make_marshal_object - (tc, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (!mobj) - return CORBA::TypeCode::TRAVERSE_STOP; - - return mobj->encode (tc, - data, - data2, - this, - ACE_TRY_ENV); -} - CORBA::TypeCode::traverse_status TAO_OutputCDR::append (CORBA::TypeCode_ptr tc, TAO_InputCDR *src, @@ -189,28 +168,6 @@ TAO_InputCDR::init_translators (void) } } -CORBA::TypeCode::traverse_status -TAO_InputCDR::decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *data2, - CORBA::Environment &ACE_TRY_ENV) -{ - TAO_Marshal_Object *mobj = - TAO_MARSHAL_FACTORY::instance ()->make_marshal_object - (tc, ACE_TRY_ENV); - - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (!mobj) - return CORBA::TypeCode::TRAVERSE_STOP; - - return mobj->decode (tc, - data, - data2, - this, - ACE_TRY_ENV); -} - CORBA::TypeCode::traverse_status TAO_InputCDR::skip (CORBA::TypeCode_ptr tc, CORBA::Environment &ACE_TRY_ENV) diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h index 45f7ab8c271..a76f387ef4a 100644 --- a/TAO/tao/CDR.h +++ b/TAO/tao/CDR.h @@ -128,14 +128,6 @@ public: // = TAO specific methods. - CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()); - // Marshalls the contents of as described by the TypeCode in - // . Any errors are reported though the parameter. - private: TAO_OutputCDR (const TAO_OutputCDR& rhs); TAO_OutputCDR& operator= (const TAO_OutputCDR& rhs); @@ -225,14 +217,6 @@ public: // = TAO specific methods. - CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()); - // Demarshall the contents of the CDR stream into as - // described by ; returning any errors in . - CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); diff --git a/TAO/tao/DynAny_i.cpp b/TAO/tao/DynAny_i.cpp index 31e4c676080..5c4a8249545 100644 --- a/TAO/tao/DynAny_i.cpp +++ b/TAO/tao/DynAny_i.cpp @@ -431,10 +431,14 @@ TAO_DynAny_i::insert_reference (CORBA::Object_ptr value, *_tao_object_ptr = CORBA::Object::_duplicate (value); - this->value_.replace (this->value_.type (), - (void*)_tao_object_ptr, - 1, - ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_object_ptr; + this->value_._tao_replace (this->value_.type (), + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + (void*)_tao_object_ptr, + ACE_TRY_ENV); ACE_CHECK; } else diff --git a/TAO/tao/Exception.cpp b/TAO/tao/Exception.cpp index 5525bad34a6..2fdf002a071 100644 --- a/TAO/tao/Exception.cpp +++ b/TAO/tao/Exception.cpp @@ -661,22 +661,20 @@ TAO_Exceptions::make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp, || stream.write_string (interface_id) == 0 || stream.write_string (name) == 0 || stream.write_ulong (1L) == 0 - || stream.write_string (field_name) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &CORBA::_tc_any, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; - + || stream.write_string (field_name) == 0; if (result) ACE_THROW (CORBA_INITIALIZE ()); + if (!(stream << CORBA::_tc_any)) + ACE_THROW (CORBA_INITIALIZE ()); + ACE_NEW_THROW_EX (tcp, CORBA::TypeCode (CORBA::tk_except, stream.length (), stream.buffer (), 1, sizeof (CORBA_UserException)), - CORBA_NO_MEMORY ()); + CORBA_INITIALIZE ()); } void @@ -737,19 +735,14 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp, || stream.write_string (full_id) == 0 || stream.write_string (name) == 0 || stream.write_ulong (2L) != 1 - || stream.write_string (minor) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &CORBA::_tc_ulong, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; // @@ Maybe we should transform this exception + || stream.write_string (minor) == 0; + + result = result || !(stream << CORBA::_tc_ulong); CORBA::string_free (full_id); // No longer need the string - result = result || stream.write_string (completed) == 0 - || stream.encode (CORBA::_tc_TypeCode, - &TC_completion_status, 0, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE; - ACE_CHECK; // @@ Maybe we should transform this exception + result = result || stream.write_string (completed) == 0; + result = result || !(stream << TC_completion_status); if (result) ACE_THROW (CORBA::INITIALIZE ()); @@ -768,7 +761,7 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp, stream.buffer (), 1, sizeof (CORBA_SystemException)), - CORBA_NO_MEMORY ()); + CORBA_INITIALIZE ()); ACE_CHECK; TAO_Exceptions::system_exceptions->add (tcp); diff --git a/TAO/tao/Forwarding_Servant.cpp b/TAO/tao/Forwarding_Servant.cpp index bd2ae762d23..54f7e33fc33 100644 --- a/TAO/tao/Forwarding_Servant.cpp +++ b/TAO/tao/Forwarding_Servant.cpp @@ -22,19 +22,12 @@ void TAO_Forwarding_Servant::invoke (CORBA::ServerRequest_ptr request, CORBA::Environment &ACE_TRY_ENV) { - ACE_UNUSED_ARG (request); + PortableServer::ForwardRequest exception (this->forward_to_.in ()); - CORBA::Exception *exception = 0; - ACE_NEW_THROW_EX (exception, - PortableServer::ForwardRequest (this->forward_to_.in ()), - CORBA::NO_MEMORY ()); + CORBA::Any any; + any <<= exception; - CORBA::Any any (exception->_type (), - exception, - 1); - - request->set_exception (any, - ACE_TRY_ENV); + request->set_exception (any, ACE_TRY_ENV); } CORBA::RepositoryId diff --git a/TAO/tao/GIOP_Server_Request.cpp b/TAO/tao/GIOP_Server_Request.cpp index 5bd45d6e149..ea277537627 100644 --- a/TAO/tao/GIOP_Server_Request.cpp +++ b/TAO/tao/GIOP_Server_Request.cpp @@ -413,9 +413,9 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV) CORBA::TypeCode_var tc = this->retval_->type (); if (this->retval_->any_owns_data ()) { - (void) this->outgoing_->encode (tc.in (), - retval_->value (), - 0, ACE_TRY_ENV); + this->retval_->_tao_encode (*this->outgoing_, + this->orb_core_, + ACE_TRY_ENV); ACE_CHECK; } else @@ -442,132 +442,6 @@ TAO_GIOP_ServerRequest::dsi_marshal (CORBA::Environment &ACE_TRY_ENV) #endif /* TAO_HAS_MINIMUM_CORBA */ -// Extension -void -TAO_GIOP_ServerRequest::demarshal (CORBA::Environment &ACE_TRY_ENV, - // ORB related exception reporting - const TAO_Call_Data_Skel *info, - // call description - ...) -{ - CORBA::ULong i; - const TAO_Param_Data_Skel *pdp; - va_list param_vector; - va_start (param_vector, info); - - for (i = 0, pdp = info->params; - i < info->param_count; - i++, pdp++) - { - void *ptr = va_arg (param_vector, void *); - - if ((pdp->mode == CORBA::ARG_IN) - || (pdp->mode == CORBA::ARG_INOUT)) - { - // Then just unmarshal the value. - (void) incoming_->decode (pdp->tc, ptr, 0, ACE_TRY_ENV); - ACE_CHECK; - } - } - va_end (param_vector); -} - -// Extension - -void -TAO_GIOP_ServerRequest::marshal (CORBA::Environment &ACE_TRY_ENV, - // ORB related exception reporting - // CORBA::Environment &skel_env, - // skeleton related exception reporting - const TAO_Call_Data_Skel *info, - // call description - ...) -{ - // what is "ACE_TRY_ENV" and "skel_env"? - // "skel_env" holds the exception that got raised inside the operation - // implementation (upcall) - // - // "orb_env" is the exception that may have been raised due to things going - // wrong in the entire dispatch process. These are always system exceptions. - - // check if we are inside with an exception. This may have happened - // since the upcall could have set some exception -#if 0 /* ASG */ - if (skel_env.exception ()) - { - // We must increase the "refcnt" on the exception, because it is - // "owned" by both and (eventually) by the - // Server_Request. - CORBA::Exception_ptr exception = skel_env.exception (); - exception->_incr_refcnt (); - - // The Any does not own the because ultimately it will be owned - // by the Server_Request via the call to "set_exception" - CORBA::Any any (skel_env.exception ()->_type (), exception); - this->set_exception (any, ACE_TRY_ENV); - } -#endif - - // Setup a Reply message so that we can marshal all the outgoing parameters - // into it. If an exception was set, then that gets marshaled into the reply - // message and we don't do anything after that - this->init_reply (ACE_TRY_ENV); - ACE_CHECK; - -#if 0 /* ASG */ - // exception? nothing to do after this - if (orb_env.exception () || skel_env.exception ()) - return; - ACE_CHECK; -#endif - - CORBA::ULong i; - const TAO_Param_Data_Skel *pdp; - va_list param_vector; - va_start (param_vector, info); - - ACE_TRY - { - for (i = 0, pdp = info->params; - i < info->param_count; - i++, pdp++) - { - void *ptr = va_arg (param_vector, void *); - - if (pdp->mode == 0) - { - // check if the return type is not void - CORBA::TCKind result = pdp->tc->kind (ACE_TRY_ENV); - ACE_TRY_CHECK; - if (result != CORBA::tk_void) - { - // Then just marshal the value. - (void) this->outgoing_->encode (pdp->tc, ptr, 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - } - else if ((pdp->mode == CORBA::ARG_INOUT) - || (pdp->mode == CORBA::ARG_OUT)) - { - // Then just marshal the value. - (void) this->outgoing_->encode (pdp->tc, ptr, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; - } - } - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_GIOP_ServerRequest::marshal - parameter encode failed"); - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; - - va_end (param_vector); -} - void TAO_GIOP_ServerRequest::init_reply (CORBA::Environment &ACE_TRY_ENV) { diff --git a/TAO/tao/GIOP_Server_Request.h b/TAO/tao/GIOP_Server_Request.h index c389c88ebe5..8dd5e4f79d5 100644 --- a/TAO/tao/GIOP_Server_Request.h +++ b/TAO/tao/GIOP_Server_Request.h @@ -101,19 +101,6 @@ public: // meant to be used internally. // - virtual void demarshal (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data_Skel *info, - ...); - // demarshal incoming parameters. Used by the SII skeleton (i.e., the IDL - // compiler generated skeleton) - - virtual void marshal (CORBA_Environment &ACE_TRY_ENV, - // CORBA_Environment &skel_env, - const TAO_Call_Data_Skel *info, - ...); - // marshal outgoing parameters and return value. This is used by the SSI - // i.e., by the IDL compiler generated skeletons. - virtual void init_reply (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); // start a Reply message diff --git a/TAO/tao/IIOP_Profile.cpp b/TAO/tao/IIOP_Profile.cpp index 24e23372347..021abe01416 100644 --- a/TAO/tao/IIOP_Profile.cpp +++ b/TAO/tao/IIOP_Profile.cpp @@ -183,7 +183,7 @@ TAO_IIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -312,7 +312,7 @@ TAO_IIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -410,7 +410,7 @@ TAO_IIOP_Profile::operator= (const TAO_IIOP_Profile &src) this->version_ = src.version_; this->object_key_ = src.object_key_; - + this->object_addr_.set (src.object_addr_); this->port_ = src.port_; diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp index e7e03d1a227..e24062fb279 100644 --- a/TAO/tao/Invocation.cpp +++ b/TAO/tao/Invocation.cpp @@ -438,8 +438,7 @@ TAO_GIOP_Invocation::close_connection (void) } // Handle the GIOP Reply with status = LOCATION_FORWARD -// Replace the IIOP Profile. The call is then automatically -// reinvoked by the TAO_Stub::do_static_call method. +// Replace the IIOP Profile. int TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream, diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h index b843567904f..2240d2a3401 100644 --- a/TAO/tao/Invocation.h +++ b/TAO/tao/Invocation.h @@ -223,7 +223,7 @@ public: CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::Exception)); - // Special purpose invoke method used by the interpretive stubs. This + // Special purpose invoke method used by the generated stubs. This // accomplishes the same task as the normal invoke except that // Exceptions are allocated and decoded here. This reduces the // footprint of the generated stubs. diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile index e76853d9e4f..e1800e95f0c 100644 --- a/TAO/tao/Makefile +++ b/TAO/tao/Makefile @@ -102,9 +102,7 @@ DEFAULT_RESOURCES_FILES = \ INTERPRETIVE_MARSHALING_FILES = \ append \ - decode \ deep_free \ - encode \ CDR_Interpreter \ Marshal \ skip @@ -175,6 +173,7 @@ ORB_CORE_FILES = \ CONV_FRAMES \ Tagged_Components \ GIOPC \ + BoundsC \ TAOC \ TAOS diff --git a/TAO/tao/Marshal.h b/TAO/tao/Marshal.h index ab4ea402a28..611c5e9e127 100644 --- a/TAO/tao/Marshal.h +++ b/TAO/tao/Marshal.h @@ -34,12 +34,6 @@ class TAO_OutputCDR; class TAO_InputCDR; -CORBA::TypeCode::traverse_status -DEEP_COPY (CORBA::TypeCode_ptr param, - const void *source, - const void *dest, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - CORBA::TypeCode::traverse_status DEEP_FREE (CORBA::TypeCode_ptr param, const void *source, @@ -117,20 +111,6 @@ class TAO_Export TAO_Marshal_Object // Provides a set of virtual methods for encoding, decoding // and deep_freeing. public: - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; - // encoding operation - - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; - // decoding operation - virtual CORBA::TypeCode::traverse_status skip (CORBA::TypeCode_ptr tc, void *context, CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0; @@ -160,16 +140,6 @@ public: virtual ~TAO_Marshal_Primitive (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -198,16 +168,6 @@ public: virtual ~TAO_Marshal_Any (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *source, const void *, @@ -236,16 +196,6 @@ public: virtual ~TAO_Marshal_TypeCode (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -274,16 +224,6 @@ public: virtual ~TAO_Marshal_Principal (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -312,16 +252,6 @@ public: virtual ~TAO_Marshal_ObjRef (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -350,16 +280,6 @@ public: virtual ~TAO_Marshal_Struct (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -388,16 +308,6 @@ public: virtual ~TAO_Marshal_Union (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -426,16 +336,6 @@ public: virtual ~TAO_Marshal_String (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -464,16 +364,6 @@ public: virtual ~TAO_Marshal_Sequence (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -502,16 +392,6 @@ public: virtual ~TAO_Marshal_Array (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -540,16 +420,6 @@ public: virtual ~TAO_Marshal_Alias (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -577,16 +447,6 @@ public: TAO_Marshal_Except (void); ~TAO_Marshal_Except (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, @@ -614,16 +474,6 @@ public: TAO_Marshal_WString (void); ~TAO_Marshal_WString (void); - virtual CORBA::TypeCode::traverse_status encode (CORBA::TypeCode_ptr tc, - const void *data, - const void *, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); - virtual CORBA::TypeCode::traverse_status decode (CORBA::TypeCode_ptr tc, - const void *data, - const void *parent_typecode, - void *context, - CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()); static CORBA::TypeCode::traverse_status deep_free (CORBA::TypeCode_ptr tc, const void *data, const void *, diff --git a/TAO/tao/MessagingS.cpp b/TAO/tao/MessagingS.cpp index b177dca761f..608e0fbc22c 100644 --- a/TAO/tao/MessagingS.cpp +++ b/TAO/tao/MessagingS.cpp @@ -2179,37 +2179,27 @@ void POA_Messaging::Poller::_get_op_name_skel ( } void POA_Messaging::Poller::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) { - static const TAO_Param_Data_Skel Messaging_Poller_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel Messaging_Poller_is_a_calldata = - {"_is_a", 1, 2, Messaging_Poller_is_a_paramdata}; - POA_Messaging::Poller_ptr _tao_impl = (POA_Messaging::Poller_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &Messaging_Poller_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_Messaging::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &Messaging_Poller_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_Messaging::Poller::_is_a ( @@ -2227,24 +2217,21 @@ CORBA::Boolean POA_Messaging::Poller::_is_a ( } void POA_Messaging::Poller::_non_existent_skel ( - CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference , + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) { - static const TAO_Param_Data_Skel Messaging_Poller_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel Messaging_Poller_non_existent_calldata = - {"_non_existent", 1, 1, Messaging_Poller_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &Messaging_Poller_non_existent_calldata, - &_tao_retval - ); + POA_MessagingCORBA::Poller *_tao_impl = (POA_Messaging::Poller *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_Messaging::Poller::_downcast ( diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp index 90baedd7f5b..2f0d49fd49a 100644 --- a/TAO/tao/NVList.cpp +++ b/TAO/tao/NVList.cpp @@ -9,6 +9,7 @@ #include "tao/Exception.h" #include "tao/Environment.h" #include "tao/ORB.h" +#include "tao/BoundsC.h" #include "tao/debug.h" #include "ace/Auto_Ptr.h" @@ -148,20 +149,10 @@ CORBA_NVList::add_value (const char *name, // The normal behaviour for parameters is that the ORB "borrows" // their memory for the duration of calls. // - if (value.value_) - { - nv->any_.replace (value.type_, - value.value_, - 0, - ACE_TRY_ENV); - } - else - { - nv->any_._tao_replace (value.type_, - value.byte_order_, - value.cdr_, - ACE_TRY_ENV); - } + nv->any_._tao_replace (value.type_, + value.byte_order_, + value.cdr_, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); } return nv; @@ -265,7 +256,7 @@ CORBA_NVList::item (CORBA::ULong n, CORBA::Environment &ACE_TRY_ENV) ACE_CHECK_RETURN (CORBA::NamedValue::_nil ()); if (n >= this->max_) // 0 based indexing - ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); + ACE_THROW_RETURN (CORBA::Bounds (), 0); CORBA::NamedValue_ptr *nv; diff --git a/TAO/tao/ObjectIDList.cpp b/TAO/tao/ObjectIDList.cpp index 4432a72ec46..4a728f5a377 100644 --- a/TAO/tao/ObjectIDList.cpp +++ b/TAO/tao/ObjectIDList.cpp @@ -91,7 +91,15 @@ void operator<<= ( if (!_tao_any_val) return; ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_any_val, 1, ACE_TRY_ENV); // copy the value + TAO_OutputCDR stream; + stream << _tao_elem; + + _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_any_val, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -135,11 +143,23 @@ operator>> (TAO_InputCDR &strm, CORBA_ORB_ObjectIdList &_tao_sequence) return 0; // error } -void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList *_tao_elem) { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV); + TAO_OutputCDR stream; + stream << *_tao_elem; + + CORBA_ORB_ObjectIdList *_tao_copy; + ACE_NEW (_tao_copy, + CORBA_ORB_ObjectIdList (*_tao_elem)); + + _tao_any._tao_replace (CORBA::ORB::_tc_ObjectIdList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_copy, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY {} @@ -163,10 +183,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ORB_ObjectIdList * ACE_NEW_RETURN (_tao_elem, CORBA_ORB_ObjectIdList, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::ORB::_tc_ObjectIdList, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::ORB::_tc_ObjectIdList, + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; return 1; } diff --git a/TAO/tao/ObjectIDList.h b/TAO/tao/ObjectIDList.h index 514fdcba836..4f4040c5200 100644 --- a/TAO/tao/ObjectIDList.h +++ b/TAO/tao/ObjectIDList.h @@ -126,14 +126,9 @@ private: #endif /* end #if !defined */ -#ifndef __ACE_INLINE__ - TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ORB_ObjectIdList &); // TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ORB_ObjectIdList &); -#endif /* __ACE_INLINE__ */ - - #if defined (__ACE_INLINE__) #include "tao/ObjectIDList.i" #endif /* defined INLINE */ diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp index 8f7c0a234fc..7fd3b87d13e 100644 --- a/TAO/tao/POAC.cpp +++ b/TAO/tao/POAC.cpp @@ -164,7 +164,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_t ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -240,7 +240,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ForwardR { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -291,7 +291,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Fo { delete ACE_const_cast (PortableServer::ForwardRequest *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3217,7 +3217,7 @@ void operator<<= ( _tao_any_val, ACE_TRY_ENV ); - ACE_TRY_CHECK; + ACE_TRY_CHECK; } else { @@ -3300,7 +3300,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::ObjectId { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3351,7 +3351,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Ob { delete ACE_const_cast (PortableServer::ObjectId *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -3424,7 +3424,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ThreadPolicy_ptr _tao_el if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ThreadPolicy, + PortableServer::_tc_ThreadPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -3561,7 +3561,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicy_ptr _tao_ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_LifespanPolicy, + PortableServer::_tc_LifespanPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -3696,7 +3696,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::IdUniquenessPolicy_ptr _ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_IdUniquenessPolicy, + PortableServer::_tc_IdUniquenessPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -3831,7 +3831,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::IdAssignmentPolicy_ptr _ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_IdAssignmentPolicy, + PortableServer::_tc_IdAssignmentPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -3968,7 +3968,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicy if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ImplicitActivationPolicy, + PortableServer::_tc_ImplicitActivationPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -4103,7 +4103,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantRetentionPolicy_p if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ServantRetentionPolicy, + PortableServer::_tc_ServantRetentionPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -4238,7 +4238,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::RequestProcessingPolicy_ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_RequestProcessingPolicy, + PortableServer::_tc_RequestProcessingPolicy, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -4329,7 +4329,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterAlread ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -4405,7 +4405,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4456,7 +4456,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::AdapterAlreadyExists *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4483,7 +4483,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterInacti ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -4559,7 +4559,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4610,7 +4610,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::AdapterInactive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4637,7 +4637,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterNonExi ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -4713,7 +4713,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ada { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4764,7 +4764,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::AdapterNonExistent *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4789,7 +4789,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::InvalidPolicy ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -4865,7 +4865,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Inv { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4916,7 +4916,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::InvalidPolicy *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -4943,7 +4943,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::NoServant &_t ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5019,7 +5019,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::NoS { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5070,7 +5070,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::NoServant *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5097,7 +5097,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlready ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5173,7 +5173,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5224,7 +5224,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::ObjectAlreadyActive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5249,7 +5249,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActi ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5325,7 +5325,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Obj { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5376,7 +5376,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::ObjectNotActive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5401,7 +5401,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantAlread ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5477,7 +5477,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5528,7 +5528,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::ServantAlreadyActive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5553,7 +5553,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantNotAct ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5629,7 +5629,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Ser { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5680,7 +5680,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::ServantNotActive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5705,7 +5705,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5781,7 +5781,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5832,7 +5832,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::WrongAdapter *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5857,7 +5857,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy & ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -5933,7 +5933,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA::Wro { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -5984,7 +5984,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POA::WrongPolicy *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -6009,7 +6009,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::Current::NoContext ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -6085,7 +6085,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::Current: { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -6136,7 +6136,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::Cu { delete ACE_const_cast (PortableServer::Current::NoContext *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -6153,7 +6153,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::Current_ptr _tao_elem) if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_Current, + PortableServer::_tc_Current, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6234,7 +6234,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POAManager_ptr _tao_elem if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_POAManager, + PortableServer::_tc_POAManager, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6377,7 +6377,7 @@ void operator<<= (CORBA::Any &_tao_any, const PortableServer::POAManager::Adapte ); ACE_TRY_CHECK; } - ACE_CATCHANY + ACE_CATCHANY { delete _tao_any_val; } @@ -6453,7 +6453,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POAManag { delete _tao_elem; _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -6504,7 +6504,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const PortableServer::PO { delete ACE_const_cast (PortableServer::POAManager::AdapterInactive *&, _tao_elem); _tao_elem = 0; - return 0; + return 0; } ACE_ENDTRY; return 0; @@ -6523,7 +6523,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::AdapterActivator_ptr _ta if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_AdapterActivator, + PortableServer::_tc_AdapterActivator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6604,7 +6604,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantLocator_ptr _tao_ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ServantLocator, + PortableServer::_tc_ServantLocator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6685,7 +6685,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantManager_ptr _tao_ if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ServantManager, + PortableServer::_tc_ServantManager, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6766,7 +6766,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::ServantActivator_ptr _ta if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_ServantActivator, + PortableServer::_tc_ServantActivator, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6849,7 +6849,7 @@ void operator<<= (CORBA::Any &_tao_any, PortableServer::POA_ptr _tao_elem) if (stream << *_tao_obj_ptr) { _tao_any._tao_replace ( - PortableServer::_tc_POA, + PortableServer::_tc_POA, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, @@ -6918,4 +6918,3 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, PortableServer::POA_ptr _tao_elem = PortableServer::POA::_nil (); return 0; } - diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp index 0fcd784cdac..83fc211a96b 100644 --- a/TAO/tao/POAS.cpp +++ b/TAO/tao/POAS.cpp @@ -133,58 +133,45 @@ void POA_PortableServer::ThreadPolicy::_get_value_skel ( } void POA_PortableServer::ThreadPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ThreadPolicy_is_a_paramdata}; - POA_PortableServer::ThreadPolicy_ptr _tao_impl = (POA_PortableServer::ThreadPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ThreadPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ThreadPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ThreadPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ThreadPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ThreadPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ThreadPolicy *_tao_impl = (POA_PortableServer::ThreadPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -429,58 +416,45 @@ void POA_PortableServer::LifespanPolicy::_get_value_skel ( } void POA_PortableServer::LifespanPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_LifespanPolicy_is_a_paramdata}; - POA_PortableServer::LifespanPolicy_ptr _tao_impl = (POA_PortableServer::LifespanPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::LifespanPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_LifespanPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_LifespanPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_LifespanPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_LifespanPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::LifespanPolicy *_tao_impl = (POA_PortableServer::LifespanPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -722,58 +696,45 @@ void POA_PortableServer::IdUniquenessPolicy::_get_value_skel ( } void POA_PortableServer::IdUniquenessPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_IdUniquenessPolicy_is_a_paramdata}; - POA_PortableServer::IdUniquenessPolicy_ptr _tao_impl = (POA_PortableServer::IdUniquenessPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::IdUniquenessPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdUniquenessPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_IdUniquenessPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdUniquenessPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::IdUniquenessPolicy *_tao_impl = (POA_PortableServer::IdUniquenessPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1018,58 +979,45 @@ void POA_PortableServer::IdAssignmentPolicy::_get_value_skel ( } void POA_PortableServer::IdAssignmentPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_IdAssignmentPolicy_is_a_paramdata}; - POA_PortableServer::IdAssignmentPolicy_ptr _tao_impl = (POA_PortableServer::IdAssignmentPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::IdAssignmentPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_IdAssignmentPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_IdAssignmentPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_IdAssignmentPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::IdAssignmentPolicy *_tao_impl = (POA_PortableServer::IdAssignmentPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1315,58 +1263,45 @@ void POA_PortableServer::ImplicitActivationPolicy::_get_value_skel ( } void POA_PortableServer::ImplicitActivationPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ImplicitActivationPolicy_is_a_paramdata}; - POA_PortableServer::ImplicitActivationPolicy_ptr _tao_impl = (POA_PortableServer::ImplicitActivationPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ImplicitActivationPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ImplicitActivationPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ImplicitActivationPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ImplicitActivationPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ImplicitActivationPolicy *_tao_impl = (POA_PortableServer::ImplicitActivationPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1610,58 +1545,45 @@ void POA_PortableServer::ServantRetentionPolicy::_get_value_skel ( } void POA_PortableServer::ServantRetentionPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_ServantRetentionPolicy_is_a_paramdata}; - POA_PortableServer::ServantRetentionPolicy_ptr _tao_impl = (POA_PortableServer::ServantRetentionPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::ServantRetentionPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_ServantRetentionPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_ServantRetentionPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_ServantRetentionPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::ServantRetentionPolicy *_tao_impl = (POA_PortableServer::ServantRetentionPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ @@ -1905,58 +1827,45 @@ void POA_PortableServer::RequestProcessingPolicy::_get_value_skel ( } void POA_PortableServer::RequestProcessingPolicy::_is_a_skel ( - CORBA::ServerRequest &_tao_server_request, - void * _tao_object_reference, - void * /*context*/, - CORBA::Environment &ACE_TRY_ENV - ) -{ - static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_is_a_calldata = - {"_is_a", 1, 2, PortableServer_RequestProcessingPolicy_is_a_paramdata}; - POA_PortableServer::RequestProcessingPolicy_ptr _tao_impl = (POA_PortableServer::RequestProcessingPolicy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + CORBA::ServerRequest &_tao_server_request, + void * _tao_object_reference, + void * /*context*/, + CORBA::Environment &ACE_TRY_ENV + ) +{ + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_PortableServer::RequestProcessingPolicy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel PortableServer_RequestProcessingPolicy_non_existent_calldata = - {"_non_existent", 1, 1, PortableServer_RequestProcessingPolicy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &PortableServer_RequestProcessingPolicy_non_existent_calldata, - &_tao_retval - ); + POA_PortableServer::RequestProcessingPolicy *_tao_impl = (POA_PortableServer::RequestProcessingPolicy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } #endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ diff --git a/TAO/tao/PolicyS.cpp b/TAO/tao/PolicyS.cpp index 3e022a5d9a1..dbd2a47d92f 100644 --- a/TAO/tao/PolicyS.cpp +++ b/TAO/tao/PolicyS.cpp @@ -182,52 +182,39 @@ void POA_CORBA::Policy::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Policy_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_Policy_is_a_calldata = - {"_is_a", 1, 2, CORBA_Policy_is_a_paramdata}; - POA_CORBA::Policy_ptr _tao_impl = (POA_CORBA::Policy_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_Policy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Policy_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_CORBA::Policy::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Policy_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_Policy_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_Policy_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Policy_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void POA_CORBA::Policy::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV) diff --git a/TAO/tao/PollableS.cpp b/TAO/tao/PollableS.cpp index 482ff6114fe..022540596c5 100644 --- a/TAO/tao/PollableS.cpp +++ b/TAO/tao/PollableS.cpp @@ -179,31 +179,21 @@ void POA_CORBA::Pollable::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Pollable_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_Pollable_is_a_calldata = - {"_is_a", 1, 2, CORBA_Pollable_is_a_paramdata}; - POA_CORBA::Pollable_ptr _tao_impl = (POA_CORBA::Pollable_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_Pollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Pollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::Pollable::_is_a ( @@ -221,23 +211,20 @@ CORBA::Boolean POA_CORBA::Pollable::_is_a ( void POA_CORBA::Pollable::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference, void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_Pollable_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_Pollable_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_Pollable_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_Pollable_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::Pollable *_tao_impl = (POA_CORBA::Pollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::Pollable::_downcast ( @@ -429,31 +416,21 @@ void POA_CORBA::DIIPollable::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_DIIPollable_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_DIIPollable_is_a_calldata = - {"_is_a", 1, 2, CORBA_DIIPollable_is_a_paramdata}; - POA_CORBA::DIIPollable_ptr _tao_impl = (POA_CORBA::DIIPollable_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::DIIPollable::_is_a ( @@ -472,23 +449,20 @@ CORBA::Boolean POA_CORBA::DIIPollable::_is_a ( void POA_CORBA::DIIPollable::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_DIIPollable_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_DIIPollable_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_DIIPollable_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_DIIPollable_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::DIIPollable *_tao_impl = (POA_CORBA::DIIPollable *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::DIIPollable::_downcast ( @@ -787,31 +761,21 @@ void POA_CORBA::PollableSet::_is_a_skel ( CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_PollableSet_is_a_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0}, - {CORBA::_tc_string, CORBA::ARG_IN, 0} - }; - static const TAO_Call_Data_Skel CORBA_PollableSet_is_a_calldata = - {"_is_a", 1, 2, CORBA_PollableSet_is_a_paramdata}; - POA_CORBA::PollableSet_ptr _tao_impl = (POA_CORBA::PollableSet_ptr) _tao_object_reference; - CORBA::Boolean _tao_retval; - CORBA::String_var _tao_value; - _tao_server_request.demarshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_InputCDR &_tao_in = _tao_server_request.incoming (); + POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference; + CORBA::Boolean _tao_retval = 0; + CORBA::String_var value; + if (!((_tao_in >> value.out ()))) + ACE_THROW (CORBA::MARSHAL ()); + + _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV); ACE_CHECK; - _tao_retval = _tao_impl->_is_a (_tao_value.in (), ACE_TRY_ENV); + + _tao_server_request.init_reply (ACE_TRY_ENV); ACE_CHECK; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_is_a_calldata, - &_tao_retval, - &_tao_value.inout () - ); + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } CORBA::Boolean POA_CORBA::PollableSet::_is_a ( @@ -829,23 +793,20 @@ CORBA::Boolean POA_CORBA::PollableSet::_is_a ( void POA_CORBA::PollableSet::_non_existent_skel ( CORBA::ServerRequest &_tao_server_request, - void * /* _tao_object_reference */ , + void * _tao_object_reference , void * /*context*/, CORBA::Environment &ACE_TRY_ENV ) { - static const TAO_Param_Data_Skel CORBA_PollableSet_non_existent_paramdata [] = - { - {CORBA::_tc_boolean, 0, 0} - }; - static const TAO_Call_Data_Skel CORBA_PollableSet_non_existent_calldata = - {"_non_existent", 1, 1, CORBA_PollableSet_non_existent_paramdata}; - CORBA::Boolean _tao_retval = 0; - _tao_server_request.marshal ( - ACE_TRY_ENV, - &CORBA_PollableSet_non_existent_calldata, - &_tao_retval - ); + POA_CORBA::PollableSet *_tao_impl = (POA_CORBA::PollableSet *) _tao_object_reference; + CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV); + ACE_CHECK; + + _tao_server_request.init_reply (ACE_TRY_ENV); + ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_server_request.outgoing (); + if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval)))) + ACE_THROW (CORBA::MARSHAL ()); } void* POA_CORBA::PollableSet::_downcast ( diff --git a/TAO/tao/SHMIOP_Profile.cpp b/TAO/tao/SHMIOP_Profile.cpp index 3dd9b9b8ce7..deef810e314 100644 --- a/TAO/tao/SHMIOP_Profile.cpp +++ b/TAO/tao/SHMIOP_Profile.cpp @@ -176,7 +176,7 @@ TAO_SHMIOP_Profile::decode (TAO_InputCDR& cdr) return -1; } - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -306,7 +306,7 @@ TAO_SHMIOP_Profile::parse_string (const char *string, this->host_ = tmp._retn (); - if (this->object_addr_.set (this->port_, + if (this->object_addr_.set (this->port_, this->host_.in ()) == -1) { if (TAO_debug_level > 0) @@ -406,7 +406,7 @@ TAO_SHMIOP_Profile::operator= (const TAO_SHMIOP_Profile &src) this->object_key_ = src.object_key_; this->object_addr_.set (src.object_addr_); - + this->port_ = src.port_; this->host_ = src.host_; diff --git a/TAO/tao/Server_Request.h b/TAO/tao/Server_Request.h index 60878bd4b99..531932b4759 100644 --- a/TAO/tao/Server_Request.h +++ b/TAO/tao/Server_Request.h @@ -34,72 +34,6 @@ class TAO_POA; class TAO_ORB_Core; -class TAO_Param_Data_Skel -{ - // = TITLE - // Description of a single parameter. - // - // = DESCRIPTION - // - // If value_size is nonzero for OUT, INOUT, or RETURN parameters, - // it's (a) an indicator that the ORB returns a pointer-to-value - // for this parameter, and also (b) is the size of the top-level - // of the value that's returned (e.g. ignoring nested sequence - // buffers). That is, it moves CPU cycles from runtime -- some - // calls to tc->size() -- to compile time where they're - // cheap/free. - // - // It _must_ only be set for cases where the ORB allocates the - // return value, which must then be ORB::free()d ... e.g. where - // the value is a pointer to data such as a struct, sequence, or - // union. (The CORBA C++ mapping doesn't require that for all - // "out" structs; only those of "variable size".) If this value - // is nonzero, the value passed to do_static_call() must be the address - // of a pointer. -public: - CORBA::TypeCode_ptr tc; - // Type of param. - - CORBA::ULong mode; - // Its mode. - - CORBA::Boolean own; - // whether we own it or not -}; - -class TAO_Call_Data_Skel -{ - // = TITLE - // Descriptions of operations, as used by the stub interpreter. - // Only interpretive marshaling/unmarshaling is used, and the - // stubs don't know what particular on-the-wire protocol is being - // used. - // - // = DESCRIPTION - // When using C++ exceptions, many C++ compilers will require the - // use of compiled code throw the exception. As binary standards - // for exception throwing evolve, it may become practical to - // interpretively throw exceptions. -public: - const char *opname; - // Operation name. - - CORBA::Boolean is_roundtrip; - // !oneway - - // When constructing tables of parameters, put them in the same - // order they appear in the IDL spec: return value, then parameters - // left to right. Other orders may produce illegal IIOP protocol - // messages. - - CORBA::ULong param_count; - // # parameters. - - const TAO_Param_Data_Skel *params; - // Their descriptions. - -}; - class TAO_Export CORBA_ServerRequest { // = TITLE @@ -192,17 +126,6 @@ public: virtual CORBA::ORB_ptr orb (void) = 0; // get the underlying ORB - virtual void demarshal (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data_Skel *info, - ...) = 0; - // demarshal incoming parameters - - virtual void marshal (CORBA_Environment &ACE_TRY_ENV, - // CORBA_Environment &skel_env, - const TAO_Call_Data_Skel *info, - ...) = 0; - // marshal outgoing parameters - virtual TAO_InputCDR &incoming (void) = 0; // Retrieve the incoming stream. diff --git a/TAO/tao/Services.cpp b/TAO/tao/Services.cpp index 9151bf96840..78e1f1f91e7 100644 --- a/TAO/tao/Services.cpp +++ b/TAO/tao/Services.cpp @@ -250,14 +250,22 @@ CORBA::ServiceInformation::_tao_seq_ServiceDetail::~_tao_seq_ServiceDetail (void #endif /* end #if !defined */ -void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceDetail &_tao_elem) { CORBA::ServiceDetail *_any_val; ACE_NEW (_any_val, CORBA::ServiceDetail (_tao_elem)); if (!_any_val) return; + TAO_OutputCDR stream; + stream << _tao_elem; + ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ServiceDetail, _any_val, 1, ACE_TRY_ENV); // copy the value + _tao_any._tao_replace (CORBA::_tc_ServiceDetail, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -271,7 +279,15 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceDetail *_tao_elem) // non { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + + _tao_any._tao_replace (CORBA::_tc_ServiceDetail, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY {} @@ -295,10 +311,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceDetail *&_ ACE_NEW_RETURN (_tao_elem, CORBA::ServiceDetail, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ServiceDetail, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceDetail, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ServiceDetail, + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; return 1; } @@ -322,9 +341,17 @@ void operator<<= (CORBA::Any &_tao_any, const CORBA::ServiceInformation &_tao_el CORBA::ServiceInformation *_any_val; ACE_NEW (_any_val, CORBA::ServiceInformation (_tao_elem)); if (!_any_val) return; + TAO_OutputCDR stream; + stream << _tao_elem; + ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ServiceInformation, _any_val, 1, ACE_TRY_ENV); // copy the value + _tao_any._tao_replace (CORBA::_tc_ServiceInformation, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _any_val, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY @@ -338,7 +365,14 @@ void operator<<= (CORBA::Any &_tao_any, CORBA::ServiceInformation *_tao_elem) // { ACE_TRY_NEW_ENV { - _tao_any.replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV); // consume it + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace (CORBA::_tc_ServiceDetail, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCHANY {} @@ -362,10 +396,13 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio ACE_NEW_RETURN (_tao_elem, CORBA::ServiceInformation, 0); TAO_InputCDR stream (_tao_any._tao_get_cdr (), _tao_any._tao_byte_order ()); - if (stream.decode (CORBA::_tc_ServiceInformation, _tao_elem, 0, ACE_TRY_ENV) - == CORBA::TypeCode::TRAVERSE_CONTINUE) + if (stream >> *_tao_elem) { - ((CORBA::Any *)&_tao_any)->replace (CORBA::_tc_ServiceInformation, _tao_elem, 1, ACE_TRY_ENV); + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ServiceInformation, + 1, + _tao_elem, + ACE_TRY_ENV); ACE_TRY_CHECK; return 1; } @@ -384,7 +421,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio return 0; } -ACE_INLINE CORBA::Boolean operator<< ( +CORBA::Boolean operator<< ( TAO_OutputCDR &strm, const CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence ) @@ -411,7 +448,7 @@ ACE_INLINE CORBA::Boolean operator<< ( return 0; // error } -ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence) +CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence) { CORBA::ULong _tao_seq_len; if (strm >> _tao_seq_len) diff --git a/TAO/tao/Services.h b/TAO/tao/Services.h index d055ef7d807..c1815fb6b0d 100644 --- a/TAO/tao/Services.h +++ b/TAO/tao/Services.h @@ -518,29 +518,22 @@ void operator<<= (CORBA::Any &, const CORBA_ServiceInformation &); // copying v void operator<<= (CORBA::Any &, CORBA_ServiceInformation*); // noncopying version CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_ServiceInformation *&); -#ifndef __ACE_INLINE__ - CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail &); // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceDetail &); CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail::_tao_seq_Octet &); // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceDetail::_tao_seq_Octet &); + CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation &); - // CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation &); -CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &); // +CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &); CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceOption &); -CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &); // +CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &); CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceDetail &); -#endif /* __ACE_INLINE__ */ - #if defined (__ACE_INLINE__) - #include "tao/Services.i" #endif /* defined INLINE */ - - #if defined(_MSC_VER) && (_MSC_VER >= 1200) #pragma warning(pop) #endif /* _MSC_VER */ diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index 9998f8333f4..82b58110a0c 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -31,41 +31,8 @@ # include "tao/Stub.i" #endif /* ! __ACE_INLINE__ */ -#include "tao/Timeprobe.h" - ACE_RCSID(tao, TAO_Stub, "$Id$") -#if defined (ACE_ENABLE_TIMEPROBES) - -static const char *TAO_TAO_Stub_Timeprobe_Description[] = - { - "TAO_Stub::do_static_call - start", - "TAO_Stub::do_static_call - end", - "TAO_Stub::do_static_call - set_cancel", - "TAO_Stub::do_static_call - grab_orb_core", - "TAO_Stub::do_static_call - invocation_ctor", - "TAO_Stub::do_static_call - invocation_start", - "TAO_Stub::do_static_call - put_params" - }; - -enum - { - // Timeprobe description table start key - TAO_STUB_OBJECT_DO_STATIC_CALL_START = 500, - TAO_STUB_OBJECT_DO_STATIC_CALL_END, - TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL, - TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE, - TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR, - TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START, - TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS - }; - -// Setup Timeprobes -ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_TAO_Stub_Timeprobe_Description, - TAO_STUB_OBJECT_DO_STATIC_CALL_START); - -#endif /* ACE_ENABLE_TIMEPROBES */ - TAO_Stub::TAO_Stub (char *repository_id, const TAO_MProfile &profiles, TAO_ORB_Core* orb_core) @@ -297,287 +264,7 @@ private: int old_type_; }; -// "Stub interpreter" for static stubs. IDL compiler (or human -// equivalent thereof :-) should just dump a read-only description of -// the call into "calldata" and do varargs calls to this routine, -// which does all the work. - -void -TAO_Stub::do_static_call (CORBA::Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - void** args) - -{ - ACE_FUNCTION_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_START); - - TAO_Synchronous_Cancellation_Required NOT_USED; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_SET_CANCEL); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_GRAB_ORB_CORE); - - // Do a locate_request if necessary/wanted. - // Suspect that you will be forwarded, so be proactive! - // strategy for reducing overhead when you think a request will - // be forwarded. No standard way now to know. - if (this->use_locate_request_ && this->first_locate_request_) - { - TAO_GIOP_Locate_Request_Invocation call (this, - this->orb_core_); - - // Simply let these exceptions propagate up - // (if any of them occurs.) - call.start (ACE_TRY_ENV); - ACE_CHECK; - - call.invoke (ACE_TRY_ENV); - ACE_CHECK; - - this->first_locate_request_ = 0; - } - - if (info->is_roundtrip) - { - TAO_GIOP_Twoway_Invocation call (this, - info->opname, - ACE_OS::strlen (info->opname), - this->orb_core_); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR); - - // We may need to loop through here more than once if we're - // forwarded to some other object reference. - // - // NOTE: A quality-of-service policy may be useful to establish - // here, specifically one controlling how many times the call is - // reissued before failing the call on the assumption that - // something is broken. - // - // NOTE: something missing is a dynamic way to change the policy - // of whether to issue LocateRequest messages or not. This code - // uses a simple, fixed policy: never use LocateRequest - // messages. - // - for (;;) - { - call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = 131; - - call.prepare_header (ACE_static_cast (CORBA::Octet, flag), - ACE_TRY_ENV); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_START); - - // Make the call ... blocking for the response. - this->put_params (ACE_TRY_ENV, info, call, args); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS); - - int status = - call.invoke (info->excepts, - info->except_count, - ACE_TRY_ENV); - ACE_CHECK; - - if (status == TAO_INVOKE_RESTART) - continue; - if (status == TAO_INVOKE_EXCEPTION) - return; // Shouldn't happen - - if (status != TAO_INVOKE_OK) - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE)); - - // The only case left is status == TAO_INVOKE_OK, exit the - // loop. We cannot retry because at this point we either - // got a reply or something with an status of - // COMPLETED_MAYBE, thus we cannot reissue the request if we - // are to satisfy the "at most once" semantics. - break; - } - - // Now, get all the "return", "out", and "inout" parameters - // from the response message body ... return parameter is - // first, the rest are in the order defined in the IDL spec - // (which is also the order that DII users are required to - // use). - - const TAO_Param_Data *pdp = info->params; - for (void** i = args; - i != args + info->param_count; - i++, pdp++) - { - void *ptr = *i; - - // if it is an inout parameter, it would become - // necessary to first release the "in" memory - if (pdp->mode == PARAM_INOUT) - { - // @@ TODO - add others as we test each case - // (ASG) will do 03/22/98. - // @@ IMHO this should be handled in the stub - // (coryan) - CORBA::TCKind kind = pdp->tc->kind (ACE_TRY_ENV); - ACE_CHECK; - - switch (kind) - { - case CORBA::tk_string: - CORBA::string_free (*(char **) ptr); - *(char **)ptr = 0; - break; - case CORBA::tk_objref: - CORBA::release (*(CORBA::Object_ptr *) ptr); - break; - case CORBA::tk_any: - break; - default: - break; - } - } - - if (pdp->mode == PARAM_RETURN - || pdp->mode == PARAM_OUT - || pdp->mode == PARAM_INOUT) - { - // The language mapping's memory allocation - // policy says that some data is heap-allocated. - // This interpreter is told about the relevant - // policy by whoever built the operation - // description (e.g. the IDL compiler) so it - // doesn't have to know the policy associated - // with a particular language binding - // (e.g. C/C++ differ, and C++ even has - // different policies for different kinds of - // structures). - if (pdp->value_size == 0) - { - (void) call.inp_stream ().decode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - ACE_CHECK; - } - else - { - // @@ (ASG) - I think we must completely - // get rid of this case because IDL compiler - // generated stubs will use this function - // and they better allocate all the memory. - - // assert (value_size == tc->size()); - ACE_NEW (*(void **)ptr, - CORBA::Octet [pdp->value_size]); - - (void) call.inp_stream ().decode (pdp->tc, - *(void**)ptr, - 0, - ACE_TRY_ENV); - ACE_CHECK; - } - } - } - } // if (two way) - else - { - TAO_GIOP_Oneway_Invocation call (this, - info->opname, - ACE_OS::strlen (info->opname), - this->orb_core_); - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_INVOCATION_CTOR); - - for (;;) - { - call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Octet flag = - ACE_static_cast (CORBA::Octet, - call.sync_scope ()); - - call.prepare_header (flag, - ACE_TRY_ENV); - ACE_CHECK; - - this->put_params (ACE_TRY_ENV, - info, - call, - args); - ACE_CHECK; - - ACE_TIMEPROBE (TAO_STUB_OBJECT_DO_STATIC_CALL_PUT_PARAMS); - - int status = call.invoke (ACE_TRY_ENV); - ACE_CHECK; - - if (status == TAO_INVOKE_RESTART) - continue; - - if (status == TAO_INVOKE_EXCEPTION) - return; // Shouldn't happen - - if (status != TAO_INVOKE_OK) - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE)); - - break; - } - } -} - -void -TAO_Stub::put_params (CORBA::Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - TAO_GIOP_Invocation &call, - void** args) -{ - // Now, put all "in" and "inout" parameters into the request - // message body. - // - // Some "inout" data have an extra level of indirection, - // specified by the language mapping's memory allocation - // policies ... the indirection only shows up here when it's - // needed later for allocating "out" memory, otherwise there's - // just one indirection. - - TAO_OutputCDR &cdr = call.out_stream (); - - const TAO_Param_Data *pdp = info->params; - for (void** i = args; - i != args + info->param_count; - i++, pdp++) - { - void *ptr = *i; - - if (pdp->mode == PARAM_IN) - { - (void) cdr.encode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - } - else if (pdp->mode == PARAM_INOUT) - { - if (pdp->value_size == 0) - (void) cdr.encode (pdp->tc, - ptr, - 0, - ACE_TRY_ENV); - else - (void) cdr.encode (pdp->tc, - *(void**)ptr, - 0, - ACE_TRY_ENV); - } - ACE_CHECK; - } -} #if !defined (TAO_HAS_MINIMUM_CORBA) diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h index a6f55df3aca..c67b7445514 100644 --- a/TAO/tao/Stub.h +++ b/TAO/tao/Stub.h @@ -70,41 +70,6 @@ enum TAO_Param_Type class TAO_Profile; -struct TAO_Param_Data -{ - // = TITLE - // TAO_Param_Data - // - // = DESCRIPTION - // Description of a single parameter. - // - // If value_size is nonzero for OUT, INOUT, or RETURN parameters, - // it's (a) an indicator that the ORB returns a pointer-to-value - // for this parameter, and also (b) is the size of the top-level - // of the value that's returned (e.g. ignoring nested sequence - // buffers). That is, it moves CPU cycles from runtime -- some - // calls to tc->size() -- to compile time where they're - // cheap/free. - // - // It _must_ only be set for cases where the ORB allocates the - // return value, which must then be ORB::free()d ... e.g. where - // the value is a pointer to data such as a struct, sequence, or - // union. (The CORBA C++ mapping doesn't require that for all - // "out" structs; only those of "variable size".) If this value - // is nonzero, the value passed to do_static_call() must be the address - // of a pointer. - - CORBA::TypeCode_ptr tc; - // TypeCode for the parameter - - TAO_Param_Type mode; - // Its mode. - - size_t value_size; - // zero or tc->size (). For SII, we always know its size since it is the IDL - // compiler which generates the stub code. -}; - // Function pointer returning a pointer to CORBA::Exception. This is used to // describe the allocator for user-defined exceptions that are used internally // by the interpreter. @@ -130,80 +95,6 @@ struct TAO_Exception_Data // the allocator for this exception }; -struct TAO_Call_Data -{ - // = TITLE - // TAO_Call_Data - // - // = DESCRIPTION - // Descriptions of operations, as used by the stub interpreter. - // Only interpretive marshaling/unmarshaling is used, and the - // stubs don't know what particular on-the-wire protocol is being - // used. - // - // When using C++ exceptions, many C++ compilers will require the - // use of compiled code throw the exception. As binary standards - // for exception throwing evolve, it may become practical to - // interpretively throw exceptions. - - const char *opname; - // Operation name. - - CORBA::Boolean is_roundtrip; - // !oneway - - // When constructing tables of parameters, put them in the same - // order they appear in the IDL spec: return value, then parameters - // left to right. Other orders may produce illegal protocol - // messages. - - u_int param_count; - // # parameters. - - const TAO_Param_Data *params; - // Their descriptions. - - // The exceptions allowed by this operation can be listed in any - // order, and need not include the system exceptions which may be - // returned by OMG-IDL operations. If an operation tries to return - // any exception not allowed by its type signature, this causes a a - // system exception to be reported. - - u_int except_count; - // # exceptions. - - // CORBA::TypeCode_ptr *excepts; - TAO_Exception_Data *excepts; - // Their descriptions. -}; - -struct TAO_Skel_Entry -{ - // = TITLE - // TAO_Skel_Entry - // - // = DESCRIPTION - // Skeletons map "ServerRequest" generic signatures to the static - // call signature required by the implementation's methods. table - // of these per implementation - // - // There are several optimizations that'd be desirable for use by - // "static skeletons", notably (a) passing of per-object data held - // by the OA so that the method doesn't need to look it up itself, - // (b) removing all mandatory heap allocation of data, and of - // course (c) handling all the built-in ORB calls like "is_a" and - // "get_implementation". This code is currently set up only for - // Dynamic Skeletons and bridging, for which none of those are - // real issues. - - const TAO_Call_Data *op_descriptor; - // pointer to the calldata structure that holds information about all the - // parameters - - TAO_Skeleton impl_skeleton; - // skeleton corresponding to the operation -}; - class TAO_Export TAO_Stub { // = TITLE @@ -222,26 +113,6 @@ class TAO_Export TAO_Stub // The stub and DII interpreter APIs are member functions of this // type. public: - void do_static_call (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - void** args); - // The "stub interpreter" method parameters are: - // - // - ACE_TRY_ENV ... used for exception reporting - // - info ... describes the call - // - args parameters follow - // - // The varargs parameters are pointers to data instances as - // described by info->params. (If the value_size is nonzero, the - // data instance is itself a pointer.) The order on the call stack - // must be exactly the order they're listed in info->params; - // normally this is the order the values are listed in the OMG-IDL - // operation specification. - // - // NOTE: This can be sped up by eliminating some parameter - // shuffling. The stub and "do_static_call" parameters are all but the - // same, except that their order is different. - #if !defined (TAO_HAS_MINIMUM_CORBA) void do_dynamic_call (const char *opname, @@ -424,13 +295,6 @@ public: // temporary. protected: - void put_params (CORBA_Environment &ACE_TRY_ENV, - const TAO_Call_Data *info, - TAO_GIOP_Invocation &call, - void** args); - // Helper method to factor out common code in static oneway - // vs. twoway invocations. - #if !defined (TAO_HAS_MINIMUM_CORBA) void put_params (TAO_GIOP_Invocation &call, diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp index 03b27e5742b..85f7a9a5f4a 100644 --- a/TAO/tao/Typecode.cpp +++ b/TAO/tao/Typecode.cpp @@ -480,7 +480,7 @@ CORBA_TypeCode::skip_typecode (TAO_InputCDR &stream) case CORBA::tk_string: case CORBA::tk_wstring: case ~0u: - return stream.read_ulong (temp); + return (stream.read_ulong (temp) != 0); // The rest have "complex" parameter lists that are // encoded as bulk octets ... just skip them. @@ -1587,10 +1587,6 @@ CORBA_TypeCode::private_member_count (CORBA::Environment &ACE_TRY_ENV) const ACE_NOTREACHED (return 0); } -// NOTE special calling convention for stream.decode () when we're -// potentially deencapsulating an indirected typecode: the "data2" -// value indicates that this typecode is the parent. See comments at -// stream.decode () for further details. // // Applicable only to struct, union, and except // @@ -1647,27 +1643,14 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, { if (!stream.skip_string ()) // skip the name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - CORBA::TypeCode::traverse_status status = - stream.decode (CORBA::_tc_TypeCode, - // the typecode will be - // retrieved at the i-th - // location. The decode - // routine will allocate the - // storage to hold a - // typecode - &this->private_state_-> - tc_member_type_list_[i], - this, - // pass ourselves since we - // will be the parent. This - // is the case where the 3rd - // parameter is used in a - // decode method - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); + CORBA::TypeCode_ptr& member_type = + this->private_state_->tc_member_type_list_[i]; + CORBA_TypeCode::_tao_decode (this, + stream, + member_type, + ACE_TRY_ENV); + ACE_CHECK_RETURN (0); } this->private_state_->tc_member_type_list_known_ = 1; @@ -1707,10 +1690,6 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, else if (!stream.read_ulong (temp) // default used || !stream.read_ulong (temp)) // member count ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - // Always big enough because labels can only be of a - // few different types of which "long" has the - // largest size. - CORBA::Long scratch; // get the typecode for the discriminator tc = this->discriminator_type (ACE_TRY_ENV); @@ -1722,7 +1701,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, // the ith entry will have the typecode of the ith guy { CORBA::TypeCode::traverse_status status = - stream.decode (tc.in (), &scratch, this, ACE_TRY_ENV); + stream.skip (tc.in (), ACE_TRY_ENV); // member label ACE_CHECK_RETURN (0); @@ -1730,21 +1709,20 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot, || !stream.skip_string ()) // skip the name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); - status = stream.decode (CORBA::_tc_TypeCode, // get the typecode - &private_state_->tc_member_type_list_[i], - this, - ACE_TRY_ENV); + CORBA::TypeCode_ptr& member_type = + this->private_state_->tc_member_type_list_[i]; + CORBA_TypeCode::_tao_decode (this, + stream, + member_type, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); } this->private_state_->tc_member_type_list_known_ = 1; if (slot < mcount) return this->private_state_->tc_member_type_list_[slot]; else - ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), (CORBA::TypeCode_ptr)0); + ACE_THROW_RETURN (CORBA::TypeCode::Bounds (), 0); } ACE_NOTREACHED (break); @@ -1908,10 +1886,6 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); else { - CORBA::Long scratch; // always big enough because labels can - // only be of a few different types of - // which "long" has the largest size - // get the typecode for the discriminator tc = this->discriminator_type (ACE_TRY_ENV); // compute the name for all the members and return the @@ -1922,10 +1896,8 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot, { // the ith entry will have the name of the ith member CORBA::TypeCode::traverse_status status = - stream.decode (tc.in (), - &scratch, - this, - ACE_TRY_ENV); // member label + stream.skip (tc.in (), + ACE_TRY_ENV); // member label ACE_CHECK_RETURN (0); if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) @@ -2092,12 +2064,15 @@ CORBA_TypeCode::private_discriminator_type (CORBA::Environment &ACE_TRY_ENV) con // skip ID and name, and then get the discriminant TC if (!stream.skip_string () // type ID, hidden - || !stream.skip_string () // typedef name - || stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_discriminator_type_, this, - ACE_TRY_ENV) != CORBA::TypeCode::TRAVERSE_CONTINUE) + || !stream.skip_string ()) // typedef name ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_discriminator_type_, + ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + this->private_state_->tc_discriminator_type_known_ = 1; return this->private_state_->tc_discriminator_type_; } @@ -2184,8 +2159,6 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const { TAO_InputCDR stream (this->buffer_+4, this->length_-4, this->byte_order_); - CORBA::TypeCode::traverse_status status = CORBA::TypeCode::TRAVERSE_STOP; - switch (kind_) { case CORBA::tk_sequence: @@ -2198,18 +2171,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const return this->private_state_->tc_content_type_; // retrieve the content type - status = stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_content_type_, - this, ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_content_type_, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) // element type - ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - else - { - this->private_state_->tc_content_type_known_ = 1; - return this->private_state_->tc_content_type_; - } + this->private_state_->tc_content_type_known_ = 1; + return this->private_state_->tc_content_type_; } ACE_NOTREACHED (break); @@ -2225,18 +2194,14 @@ CORBA_TypeCode::private_content_type (CORBA::Environment &ACE_TRY_ENV) const || !stream.skip_string ()) // name ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - status = stream.decode (CORBA::_tc_TypeCode, - &this->private_state_->tc_content_type_, this, - ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (this, + stream, + this->private_state_->tc_content_type_, + ACE_TRY_ENV); ACE_CHECK_RETURN (0); - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0); - else - { - this->private_state_->tc_content_type_known_ = 1; - return this->private_state_->tc_content_type_; - } + this->private_state_->tc_content_type_known_ = 1; + return this->private_state_->tc_content_type_; } /*NOTREACHED*/ @@ -2271,6 +2236,248 @@ CORBA_TypeCode::private_discrim_pad_size (CORBA::Environment &ACE_TRY_ENV) this->private_state_->tc_discrim_pad_size_ = discrim_size; return discrim_size; } + +// **************************************************************** + +void +CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent, + TAO_InputCDR &cdr, + CORBA_TypeCode *&x, + CORBA::Environment &ACE_TRY_ENV) +{ + x = 0; + CORBA::ULong kind; + + if (!cdr.read_ulong (kind)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + static CORBA::TypeCode_ptr tc_consts [CORBA::TC_KIND_COUNT] = + { + CORBA::_tc_null, + CORBA::_tc_void, + CORBA::_tc_short, + CORBA::_tc_long, + CORBA::_tc_ushort, + + CORBA::_tc_ulong, + CORBA::_tc_float, + CORBA::_tc_double, + CORBA::_tc_boolean, + CORBA::_tc_char, + + CORBA::_tc_octet, + CORBA::_tc_any, + CORBA::_tc_TypeCode, + CORBA::_tc_Principal, + + 0, // CORBA::_tc_Object ... type ID is CORBA_Object + 0, // CORBA_tk_struct + 0, // CORBA_tk_union + 0, // CORBA_tk_enum + 0, // CORBA::_tc_string ... unbounded + 0, // CORBA_tk_sequence + 0, // CORBA_tk_array + 0, // CORBA_tk_alias + 0, // CORBA_tk_except + + CORBA::_tc_longlong, + CORBA::_tc_ulonglong, + CORBA::_tc_longdouble, + CORBA::_tc_wchar, + 0 // CORBA::_tc_wstring ... unbounded + }; + + if (kind < CORBA::TC_KIND_COUNT && tc_consts [kind] != 0) + { + // Easy case, the CDR contains no more data, and we can simply + // duplicate one of the TypeCode constants... + x = CORBA::TypeCode::_duplicate (tc_consts [kind]); + return; + } + + if (kind != ~0u && kind >= CORBA::TC_KIND_COUNT) + { + // Invalid kind.... cannot even determine what portion of the + // CDR corresponds to the typecode.... + ACE_THROW (CORBA::BAD_TYPECODE ()); + } + + if (kind == ~0u) + { + // Get the long indicating the encapsulation offset, + // then set up indirection stream that's like "stream" + // but has space enough only for the typecode and the + // length for the encapsulated parameters. + // + // The offset must be negative + CORBA::Long offset; + + if (!cdr.read_long (offset) || offset >= 0) + { + // Since indirected typecodes cannot occur at the + // topmost level, they can occur starting only at the + // second and subsequent levels. This means that a + // normal encoding of that typecode occurred somewhere + // before in the stream. As a result the offset field + // must always be negative. See the CORBA spec for details. + ACE_THROW (CORBA::BAD_TYPECODE ()); + } + + // Slava Galperin clarifies + // this: + // CORBA Spec says: + // + // The encoding of such an indirection is as a + // TypeCode with a TCKind value that has the special + // value 2^32 -1 (0xffffffff, all ones). Such + // typecodes have a single (simple) parameter, which + // is the long offset (in units of octets) from the + // simple parameter. (This means that an offset of + // negative four (-4) is illegal because it will be + // self-indirecting.) + // (CORBA V2.2 CDR Transfer Syntax February 1998 page 13-17) + // + // This apparently assumes offset from the + // beginning of the simple parameter. + // [Right, because otherwise the value -8 would be + // illegal] + // Because at this point stream is positioned after + // the parameter, we need to account for that when + // constructing indir_stream by subtracting 4 (length + // of the offset parameter itself). + + // TAO_InputCDR indir_stream (*stream, 8, offset + // - 4); + ACE_Message_Block *mb = (ACE_Message_Block *)cdr.start (); + TAO_InputCDR indir_stream (mb->rd_ptr () + offset - 4, + -1 * (offset - 4)); + + if (!indir_stream.good_bit ()) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // Get "kind" and length of target typecode + // + // XXX this currently assumes the TCKind to which we + // indirect is the same byte order as the "parent" + // typecode -- not the right assumption; see how the + // TypeCode interpreter does it. + + CORBA::ULong indir_kind = 0; + CORBA::ULong indir_len = 0; + + if (!indir_stream.read_ulong (indir_kind) + || indir_kind >= CORBA::TC_KIND_COUNT // no double indirections + || !indir_stream.read_ulong (indir_len)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // Now construct indirected typecode. This shares the + // typecode octets with the "parent" typecode, + // increasing the amount of memory sharing and + // reducing the cost of getting typecodes. + ACE_NEW (x, + CORBA::TypeCode ((CORBA::TCKind) indir_kind, + indir_len, + indir_stream.rd_ptr(), + 0, + 0, + // @@ TODO + // Here we lose the parent + // typecode... + ACE_const_cast(CORBA_TypeCode*,parent))); + return; + } + + // The other cases.... + switch (kind) + { + default: + ACE_THROW (CORBA::INTERNAL ()); + + // Some have "simple" parameter lists ... some of these + // also have preallocated constants that could be used. + case CORBA::tk_string: + case CORBA::tk_wstring: + { + CORBA::ULong bound; + + if (!cdr.read_ulong (bound)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + if (bound == 0) + { + // unbounded string. Let us reuse the ORB owned + // _tc_string or _tc_wstring + if (kind == CORBA::tk_string) + x = CORBA::TypeCode::_duplicate (CORBA::_tc_string); + else + x = CORBA::TypeCode::_duplicate (CORBA::_tc_wstring); + } + else + { + // bounded string. Create a TypeCode. If it is does not + // have a parent, then the application must free it. + + // allocate a new TypeCode + + // This may produce a memory leak, because + // callers are sloppy about removing these + // objects. + CORBA::Long _oc_bounded_string [] = + {TAO_ENCAP_BYTE_ORDER, 0}; + // Bounded string. Save the bounds + _oc_bounded_string [1] = (CORBA::Long) bound; + ACE_NEW (x, + CORBA::TypeCode (ACE_static_cast(CORBA::TCKind, kind), + 8, + ACE_reinterpret_cast(char*,_oc_bounded_string), + 0, + sizeof (CORBA::String_var), + 0)); + } + } + break; + + // The rest have "complex" parameter lists that are + // encoded as bulk octets ... + case CORBA::tk_objref: + case CORBA::tk_struct: + case CORBA::tk_union: + case CORBA::tk_enum: + case CORBA::tk_sequence: + case CORBA::tk_array: + case CORBA::tk_alias: + case CORBA::tk_except: + { + CORBA::ULong length; + + // get the encapsulation length + if (!cdr.read_ulong (length)) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // If the length is greater that the containing CDR stream + // that is an error... + if (length > cdr.length ()) + ACE_THROW (CORBA::BAD_TYPECODE ()); + + // create a new typecode + ACE_NEW (x, + CORBA::TypeCode ((CORBA::TCKind) kind, + length, + cdr.rd_ptr (), + 0, + 0, + ACE_const_cast (CORBA_TypeCode*,parent))); + // skip length number of bytes in the stream, otherwise we may + // leave the stream in an undefined state + (void) cdr.skip_bytes (length); + } + break; + } // end of switch +} + +// **************************************************************** + + // ************ The following are deprecated **************** // say how many parameters this typecode has; normally a fixed number, @@ -2439,28 +2646,67 @@ CORBA::TypeCode::private_alignment (CORBA::Environment &ACE_TRY_ENV) CORBA::Boolean operator<< (TAO_OutputCDR& cdr, const CORBA::TypeCode *x) { - ACE_TRY_NEW_ENV - { - // @@ This function should *not* use the interpreter, there must - // be a way to do this with just CDR operations!!!! - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_TYPECODE::instance ()->encode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); - ACE_TRY_CHECK; + CORBA::ULong kind = + x->kind_; - if (status == CORBA::TypeCode::TRAVERSE_CONTINUE) - return 1; - // else return 0 at the end of the function - } - ACE_CATCH (CORBA_Exception, ex) + if (!cdr.write_ulong (kind)) + return 0; + + switch (kind) { + default: + break; + + // Indirected typecodes can't occur at "top level" like + // this, only nested inside others! + case ~0u: + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "indirected typecode at top level!\n")); return 0; + break; + + // A few have "simple" parameter lists + case CORBA::tk_string: + case CORBA::tk_wstring: + { + ACE_TRY_NEW_ENV + { + CORBA::ULong length = + x->length (ACE_TRY_ENV); + + if (!cdr.write_ulong (length)) + return 0; + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + } + break; + + // The rest have "complex" parameter lists that are + // already encoded as bulk octets ... put length, then + // octets. + case CORBA::tk_objref: + case CORBA::tk_struct: + case CORBA::tk_union: + case CORBA::tk_enum: + case CORBA::tk_sequence: + case CORBA::tk_array: + case CORBA::tk_alias: + case CORBA::tk_except: + { + if (!cdr.write_ulong (x->length_) + || !cdr.write_octet_array ((CORBA::Octet*)x->buffer_, + x->length_)) + return 0; + } + break; } - ACE_ENDTRY; - return 0; + + return 1; } CORBA::Boolean @@ -2468,23 +2714,14 @@ operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x) { ACE_TRY_NEW_ENV { - CORBA::TypeCode::traverse_status status = - TAO_MARSHAL_TYPECODE::instance ()->decode (0, - &x, - 0, - &cdr, - ACE_TRY_ENV); + CORBA_TypeCode::_tao_decode (0, cdr, x, ACE_TRY_ENV); ACE_TRY_CHECK; - - if (status != CORBA::TypeCode::TRAVERSE_CONTINUE) - return 0; } - ACE_CATCH (CORBA_Exception, ex) + ACE_CATCHANY { return 0; } ACE_ENDTRY; - return 1; } diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h index 15656c95464..07d2957f949 100644 --- a/TAO/tao/Typecode.h +++ b/TAO/tao/Typecode.h @@ -245,6 +245,13 @@ public: // Deprecated, CORBA 1.2, not fully usable. Returns the number of // parameters that the typecode takes. + static void _tao_decode (const CORBA_TypeCode *parent, + TAO_InputCDR &cdr, + CORBA_TypeCode *&child, + CORBA::Environment &ACE_TRY_ENV); + // CDR decoding: the >> operator is not enough because we must also + // respect the parent/child relationship among TypeCodes. + // private: // // = The guts of the typecode implementation class diff --git a/TAO/tao/UIOP_Profile.cpp b/TAO/tao/UIOP_Profile.cpp index b01ac0b4189..ea3aebb26a1 100644 --- a/TAO/tao/UIOP_Profile.cpp +++ b/TAO/tao/UIOP_Profile.cpp @@ -23,7 +23,7 @@ static const char prefix_[] = "uiop"; const char TAO_UIOP_Profile::object_key_delimiter_ = '|'; -char +char TAO_UIOP_Profile::object_key_delimiter (void) const { return TAO_UIOP_Profile::object_key_delimiter_; @@ -315,7 +315,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr) if (minor <= TAO_DEF_GIOP_MINOR) this->version_.minor = minor; - + char *rendezvous = 0; // Get rendezvous_point @@ -324,7 +324,7 @@ TAO_UIOP_Profile::decode (TAO_InputCDR& cdr) ACE_DEBUG ((LM_DEBUG, "error decoding UIOP rendezvous_point")); return -1; } - + if (this->object_addr_.set (rendezvous) == -1) { if (TAO_debug_level > 0) diff --git a/TAO/tao/append.cpp b/TAO/tao/append.cpp index 050ff0d5d71..7b62bfdbef2 100644 --- a/TAO/tao/append.cpp +++ b/TAO/tao/append.cpp @@ -104,27 +104,20 @@ TAO_Marshal_Any::append (CORBA::TypeCode_ptr, // Typecode of the element that makes the Any. CORBA::TypeCode_var elem_tc; - // Status of append operation. - // Decode the typecode description for the element so that we can append the - // data appropriately + if (!(*src >> elem_tc.inout ())) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + CORBA::TypeCode::TRAVERSE_STOP); + + if (!(*dest << elem_tc.in ())) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + CORBA::TypeCode::TRAVERSE_STOP); + + // append the data CORBA::TypeCode::traverse_status retval = - src->decode (CORBA::_tc_TypeCode, - &elem_tc.inout (), - 0, - ACE_TRY_ENV); + dest->append (elem_tc.in (), src, ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // encode the typecode - retval = dest->encode (CORBA::_tc_TypeCode, &elem_tc, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // append the data - retval = dest->append (elem_tc.in (), src, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - } if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE) { @@ -358,163 +351,221 @@ TAO_Marshal_Struct::append (CORBA::TypeCode_ptr tc, // Encode unions. CORBA::TypeCode::traverse_status -TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc, +TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc, TAO_InputCDR *src, TAO_OutputCDR *dest, CORBA::Environment &ACE_TRY_ENV) { - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; + CORBA::TypeCode_ptr discrim_tc = + tc->discriminator_type (ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - CORBA::TypeCode_ptr discrim_tc; - CORBA::TypeCode_var member_tc; - CORBA::Any_ptr member_label; - CORBA::ULongLong discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - - // get the discriminator type - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); + CORBA::ULong kind = + discrim_tc->kind (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // decode the discriminator value - retval = src->decode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV); + // Save the discriminator value in a temporary variable... + CORBA::Short short_v; + CORBA::UShort ushort_v; + CORBA::Long long_v; + CORBA::ULong ulong_v; + CORBA::ULong enum_v; + CORBA::Char char_v; + CORBA::WChar wchar_v; + CORBA::Boolean boolean_v; + + switch (kind) + { + case CORBA::tk_short: + { + if (!src->read_short (short_v) + || !dest->write_short (short_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_ushort: + { + if (!src->read_ushort (ushort_v) + || !dest->write_ushort (ushort_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_long: + { + if (!src->read_long (long_v) + || !dest->write_long (long_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_ulong: + { + if (!src->read_ulong (ulong_v) + || !dest->write_ulong (ulong_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_enum: + { + if (!src->read_ulong (enum_v) + || !dest->write_ulong (enum_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_char: + { + if (!src->read_char (char_v) + || !dest->write_char (char_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_wchar: + { + if (!src->read_wchar (wchar_v) + || !dest->write_wchar (wchar_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_boolean: + { + if (!src->read_boolean (boolean_v) + || !dest->write_boolean (boolean_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + + CORBA::ULong member_count = + tc->member_count (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) + + CORBA::ULong current_member = ~0UL; + CORBA::ULong default_member = ~0UL; + for (CORBA::ULong i = 0; + i != member_count && current_member == ~0UL; + ++i) { - // write the discriminant back to the dest - retval = dest->encode (discrim_tc, &discrim_val, 0, ACE_TRY_ENV); + CORBA::Any *any = + tc->member_label (i, ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - // now get ready to marshal the actual union value - default_index = tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - member_count = tc->member_count (ACE_TRY_ENV); + CORBA::Octet o; + if ((*any >>= CORBA::Any::to_octet (o)) && o == 0) + { + CORBA::ULong default_index = + tc->default_index (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. + if (i != default_index) + ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), + CORBA::TypeCode::TRAVERSE_STOP); + // Found the default branch, save its position and continue + // trying to find the current value... + default_member = i; + continue; + } - for (i = 0; member_count-- != 0; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - CORBA::TypeCode_var type = member_label->type (); - // do the matching - switch (type->kind (ACE_TRY_ENV)) - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_enum: - { - CORBA::Long l; - TAO_InputCDR stream (member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc, &l, 0, ACE_TRY_ENV); - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_wchar: - { - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) &discrim_val) - discrim_matched = 1; - } - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch - - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - - if (default_index >= 0 && default_index-- == 0) - // have we reached the default label?, if so, - // save a handle to the typecode for the default - default_tc = member_tc.in (); - if (discrim_matched) - { - // marshal according to the matched typecode - return dest->append (member_tc.in (), src, ACE_TRY_ENV); - } - } // end of for loop - // we are here only if there was no match - if (default_tc) - { - return dest->append (default_tc, src, ACE_TRY_ENV); - } - else - return CORBA::TypeCode::TRAVERSE_CONTINUE; + switch (kind) + { + case CORBA::tk_short: + { + CORBA::Short d; + if ((*any >>= d) && d == short_v) + current_member = i; + } + break; + + case CORBA::tk_ushort: + { + CORBA::UShort d; + if ((*any >>= d) && d == ushort_v) + current_member = i; + } + break; + + case CORBA::tk_long: + { + CORBA::Long d; + if ((*any >>= d) && d == long_v) + current_member = i; + } + break; + + case CORBA::tk_ulong: + { + CORBA::ULong d; + if ((*any >>= d) && d == ulong_v) + current_member = i; + } + break; + + case CORBA::tk_enum: + { + CORBA::ULong d; + // @@ Will this work???? + if ((*any >>= d) && d == enum_v) + current_member = i; + } + break; + + case CORBA::tk_char: + { + CORBA::Char d; + if ((*any >>= CORBA::Any::to_char (d)) && d == char_v) + current_member = i; + } + break; + + case CORBA::tk_wchar: + { + CORBA::WChar d; + if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v) + current_member = i; + } + break; + + case CORBA::tk_boolean: + { + CORBA::Boolean d; + if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v) + current_member = i; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; } - else + } + + if (current_member == ~0UL) + { + // Cannot find the current member, check if there is a + // default... + if (default_member != ~0UL) { - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); + // Good, use the default to append... + CORBA::TypeCode_ptr member_tc = + tc->member_type (default_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return dest->append (member_tc, src, ACE_TRY_ENV); } + return CORBA::TypeCode::TRAVERSE_STOP; } - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - CORBA::TypeCode::TRAVERSE_STOP); + // If we found the member successfully then just use that one... + CORBA::TypeCode_ptr member_tc = + tc->member_type (current_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return dest->append (member_tc, src, ACE_TRY_ENV); } // decode string diff --git a/TAO/tao/skip.cpp b/TAO/tao/skip.cpp index de8d3194ef1..77222f77387 100644 --- a/TAO/tao/skip.cpp +++ b/TAO/tao/skip.cpp @@ -103,19 +103,10 @@ TAO_Marshal_Any::skip (CORBA::TypeCode_ptr, TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context); // Status of encode operation. - CORBA::TypeCode::traverse_status retval = - stream->decode (CORBA::_tc_TypeCode, - &elem_tc.inout (), - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + if (!(*stream >> elem_tc.inout ())) + return CORBA::TypeCode::TRAVERSE_STOP; - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) - { - retval = stream->skip (elem_tc.in (), ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - } - return retval; + return stream->skip (elem_tc.in (), ACE_TRY_ENV); } CORBA::TypeCode::traverse_status @@ -356,145 +347,211 @@ TAO_Marshal_Union::skip (CORBA::TypeCode_ptr tc, void *context, CORBA::Environment &ACE_TRY_ENV) { - // Context is the CDR stream. - TAO_InputCDR *stream = ACE_static_cast (TAO_InputCDR *, context); - - CORBA::TypeCode::traverse_status retval = - CORBA::TypeCode::TRAVERSE_CONTINUE; + TAO_InputCDR *src = + ACE_reinterpret_cast (TAO_InputCDR*, context); - CORBA::TypeCode_var discrim_tc; - CORBA::TypeCode_var member_tc; - CORBA::Any_ptr member_label; - CORBA::ULongLong discrim_val; - CORBA::ULong member_count; - CORBA::Long default_index; - CORBA::ULong i; - CORBA::TypeCode_ptr default_tc = 0; - CORBA::Boolean discrim_matched = 0; - - // get the discriminator type which will enable us to skip the discriminator - // value - discrim_tc = tc->discriminator_type (ACE_TRY_ENV); + CORBA::TypeCode_ptr discrim_tc = + tc->discriminator_type (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // decode the discriminator value - retval = stream->decode (discrim_tc.in (), &discrim_val, 0, ACE_TRY_ENV); + CORBA::ULong kind = + discrim_tc->kind (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - if (retval == CORBA::TypeCode::TRAVERSE_CONTINUE) + // Save the discriminator value in a temporary variable... + CORBA::Short short_v; + CORBA::UShort ushort_v; + CORBA::Long long_v; + CORBA::ULong ulong_v; + CORBA::ULong enum_v; + CORBA::Char char_v; + CORBA::WChar wchar_v; + CORBA::Boolean boolean_v; + + switch (kind) { - // now get ready to skip the actual union value - default_index = tc->default_index (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_short: + { + if (!src->read_short (short_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - member_count = tc->member_count (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_ushort: + { + if (!src->read_ushort (ushort_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // check which label value matches with the discriminator - // value. Accordingly, marshal the corresponding - // member_type. If none match, check if default exists - // and marshal accordingly. Otherwise it is an error. + case CORBA::tk_long: + { + if (!src->read_long (long_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - for (i = 0; i < member_count; i++) - { - member_label = tc->member_label (i, ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_ulong: + { + if (!src->read_ulong (ulong_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // do the matching - CORBA::TypeCode_var type = member_label->type (); - CORBA::ULong kind = type->kind (ACE_TRY_ENV); - ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + case CORBA::tk_enum: + { + if (!src->read_ulong (enum_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - switch (kind) - { - case CORBA::tk_short: - { - CORBA::Short s; - *member_label >>= s; - if (s == *(CORBA::Short *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ushort: - { - CORBA::UShort s; - *member_label >>= s; - if (s == *(CORBA::UShort *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_long: - { - CORBA::Long l; - *member_label >>= l; - if (l == *(CORBA::Long *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_ulong: - { - CORBA::ULong l; - *member_label >>= l; - if (l == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_enum: - { - CORBA::ULong ul; - TAO_InputCDR stream (member_label->_tao_get_cdr (), - member_label->_tao_byte_order ()); - (void)stream.decode (discrim_tc.in (), &ul, 0, ACE_TRY_ENV); - if (ul == *(CORBA::ULong *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_char: - { - CORBA::Char c; - *member_label >>= CORBA::Any::to_char (c); - if (c == *(CORBA::Char *) &discrim_val) - discrim_matched = 1; - } - break; - case CORBA::tk_wchar: - CORBA::WChar wc; - *member_label >>= CORBA::Any::to_wchar (wc); - if (wc == *(CORBA::WChar *) &discrim_val) - discrim_matched = 1; - break; - case CORBA::tk_boolean: - { - CORBA::Boolean b; - *member_label >>= CORBA::Any::to_boolean (b); - if (b == *(CORBA::Boolean *) &discrim_val) - discrim_matched = 1; - } - break; - default: - ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), - CORBA::TypeCode::TRAVERSE_STOP); - }// end of switch + case CORBA::tk_char: + { + if (!src->read_char (char_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_wchar: + { + if (!src->read_wchar (wchar_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; + + case CORBA::tk_boolean: + { + if (!src->read_boolean (boolean_v)) + return CORBA::TypeCode::TRAVERSE_STOP; + } + break; - // get the member typecode - member_tc = tc->member_type (i, ACE_TRY_ENV); + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + + CORBA::ULong member_count = + tc->member_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + + CORBA::ULong current_member = ~0UL; + CORBA::ULong default_member = ~0UL; + for (CORBA::ULong i = 0; + i != member_count && current_member == ~0UL; + ++i) + { + CORBA::Any *any = + tc->member_label (i, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + + CORBA::Octet o; + if ((*any >>= CORBA::Any::to_octet (o)) && o == 0) + { + CORBA::ULong default_index = + tc->default_index (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); - // have we reached the default label, if so save a handle to - // the typecode for the default + if (i != default_index) + ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), + CORBA::TypeCode::TRAVERSE_STOP); + // Found the default branch, save its position and continue + // trying to find the current value... + default_member = i; + continue; + } - if (default_index >= 0 && default_index-- == 0) - default_tc = member_tc.in (); - if (discrim_matched) - { - // marshal according to the matched typecode - return stream->skip (member_tc.in (), ACE_TRY_ENV); - } + switch (kind) + { + case CORBA::tk_short: + { + CORBA::Short d; + if ((*any >>= d) && d == short_v) + current_member = i; + } + break; + + case CORBA::tk_ushort: + { + CORBA::UShort d; + if ((*any >>= d) && d == ushort_v) + current_member = i; + } + break; + + case CORBA::tk_long: + { + CORBA::Long d; + if ((*any >>= d) && d == long_v) + current_member = i; + } + break; + + case CORBA::tk_ulong: + { + CORBA::ULong d; + if ((*any >>= d) && d == ulong_v) + current_member = i; + } + break; + + case CORBA::tk_enum: + { + CORBA::ULong d; + // @@ Will this work???? + if ((*any >>= d) && d == enum_v) + current_member = i; + } + break; + + case CORBA::tk_char: + { + CORBA::Char d; + if ((*any >>= CORBA::Any::to_char (d)) && d == char_v) + current_member = i; + } + break; + + case CORBA::tk_wchar: + { + CORBA::WChar d; + if ((*any >>= CORBA::Any::to_wchar (d)) && d == wchar_v) + current_member = i; + } + break; + + case CORBA::tk_boolean: + { + CORBA::Boolean d; + if ((*any >>= CORBA::Any::to_boolean (d)) && d == boolean_v) + current_member = i; + } + break; + + default: + return CORBA::TypeCode::TRAVERSE_STOP; + } + } + + if (current_member == ~0UL) + { + // Cannot find the current member, check if there is a + // default... + if (default_member != ~0UL) + { + // Good, use the default to append... + CORBA::TypeCode_ptr member_tc = + tc->member_type (default_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return src->skip (member_tc, ACE_TRY_ENV); } - if (default_tc != 0) - return stream->skip (default_tc, ACE_TRY_ENV); + return CORBA::TypeCode::TRAVERSE_STOP; } - return retval; + + // If we found the member successfully then just use that one... + CORBA::TypeCode_ptr member_tc = + tc->member_type (current_member, ACE_TRY_ENV); + ACE_CHECK_RETURN (CORBA::TypeCode::TRAVERSE_STOP); + return src->skip (member_tc, ACE_TRY_ENV); } // decode string diff --git a/TAO/tests/Param_Test/Makefile b/TAO/tests/Param_Test/Makefile index 6bb792ca728..512adb688c2 100644 --- a/TAO/tests/Param_Test/Makefile +++ b/TAO/tests/Param_Test/Makefile @@ -67,12 +67,18 @@ CLI_FILES = param_testCli \ multdim_array \ complex_any +ANYOP_FILES = param_testCli \ + anyop + + PARAM_TEST_SVR_OBJS = $(addsuffix .o,$(SVR_FILES)) PARAM_TEST_CLT_OBJS = $(addsuffix .o,$(CLI_FILES)) +PARAM_TEST_ANYOP_OBJS = $(addsuffix .o,$(ANYOP_FILES)) SRC = $(addsuffix .cpp,$(SVR_FILES)) \ - $(addsuffix .cpp,$(CLI_FILES)) + $(addsuffix .cpp,$(CLI_FILES)) \ + $(addsuffix .cpp,$(ANYOP_FILES)) -BIN = server client +BIN = server client anyop #---------------------------------------------------------------------------- # Include macros and targets @@ -111,6 +117,9 @@ server: $(addprefix $(VDIR),$(PARAM_TEST_SVR_OBJS)) client: $(addprefix $(VDIR),$(PARAM_TEST_CLT_OBJS)) $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) +anyop: $(addprefix $(VDIR),$(PARAM_TEST_ANYOP_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + realclean: clean -$(RM) param_testCli.* param_testSer.* param_testSer_T.* @@ -124,6 +133,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -140,8 +150,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -156,6 +169,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -278,14 +300,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -389,12 +403,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i .obj/param_testSer.o .obj/param_testSer.so .shobj/param_testSer.o .shobj/param_testSer.so: param_testSer.cpp param_testSer.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -411,8 +427,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -427,6 +446,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -549,14 +577,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -660,14 +680,16 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \ - param_testSer.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i param_testSer_T.h param_testSer_T.i \ + param_testSer_T.cpp param_testSer.i -.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp $(ACE_ROOT)/ace/Get_Opt.h \ +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp \ + $(ACE_ROOT)/ace/Get_Opt.h \ $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -678,16 +700,19 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Log_Priority.h \ $(ACE_ROOT)/ace/Log_Record.i \ $(ACE_ROOT)/ace/ACE.i \ - $(ACE_ROOT)/ace/Get_Opt.i param_test_i.h \ - param_testSer.h param_testCli.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + param_test_i.h param_testSer.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ $(ACE_ROOT)/ace/Message_Block.h \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -702,6 +727,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -824,14 +858,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -935,14 +961,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \ - param_testSer.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i param_testSer_T.h param_testSer_T.i \ + param_testSer_T.cpp param_testSer.i .obj/param_test_i.o .obj/param_test_i.so .shobj/param_test_i.o .shobj/param_test_i.so: param_test_i.cpp \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -959,8 +986,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -975,6 +1005,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -1097,14 +1136,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -1208,14 +1239,16 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_test_i.h \ - param_testSer.h param_testCli.h param_testCli.i param_testSer_T.h \ - param_testSer_T.i param_testSer_T.cpp param_testSer.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_test_i.h param_testSer.h param_testCli.h param_testCli.i \ + param_testSer_T.h param_testSer_T.i param_testSer_T.cpp \ + param_testSer.i .obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -1232,8 +1265,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -1248,6 +1284,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -1370,14 +1415,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -1481,12 +1518,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i .obj/param_testCli.o .obj/param_testCli.so .shobj/param_testCli.o .shobj/param_testCli.so: param_testCli.cpp param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -1503,8 +1542,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -1519,6 +1561,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -1641,14 +1692,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -1752,7 +1795,8 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i .obj/driver.o .obj/driver.so .shobj/driver.o .shobj/driver.so: driver.cpp driver.h options.h \ $(ACE_ROOT)/ace/Singleton.h \ @@ -1760,6 +1804,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -1796,6 +1841,10 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Message_Block.h \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ $(ACE_ROOT)/ace/Malloc.i \ $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ @@ -2023,21 +2072,21 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.h \ - param_testCli.i results.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.h param_testCli.i results.h \ $(ACE_ROOT)/ace/Profile_Timer.h \ $(ACE_ROOT)/ace/Time_Value.h \ $(ACE_ROOT)/ace/High_Res_Timer.h \ $(ACE_ROOT)/ace/High_Res_Timer.i \ - $(ACE_ROOT)/ace/Profile_Timer.i client.h \ - client.cpp tests.h any.h bd_long_seq.h bd_short_seq.h bd_str_seq.h \ - bd_wstr_seq.h bd_string.h bd_wstring.h bd_struct_seq.h bd_array_seq.h \ - fixed_array.h fixed_struct.h nested_struct.h recursive_struct.h \ - helper.h objref_struct.h objref.h short.h ulonglong.h typecode.h \ - ub_any_seq.h ub_long_seq.h ub_objref_seq.h ub_short_seq.h \ - ub_str_seq.h ub_wstr_seq.h ub_string.h ub_wstring.h ub_struct_seq.h \ - ub_array_seq.h var_array.h var_struct.h except.h big_union.h \ - recursive_union.h complex_any.h \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + client.h client.cpp tests.h any.h bd_long_seq.h bd_short_seq.h \ + bd_str_seq.h bd_wstr_seq.h bd_string.h bd_wstring.h bd_struct_seq.h \ + bd_array_seq.h fixed_array.h fixed_struct.h nested_struct.h \ + recursive_struct.h helper.h objref_struct.h objref.h short.h \ + ulonglong.h typecode.h ub_any_seq.h ub_long_seq.h ub_objref_seq.h \ + ub_short_seq.h ub_str_seq.h ub_wstr_seq.h ub_string.h ub_wstring.h \ + ub_struct_seq.h ub_array_seq.h var_array.h var_struct.h except.h \ + big_union.h recursive_union.h complex_any.h multdim_array.h \ $(ACE_ROOT)/ace/Get_Opt.h \ $(ACE_ROOT)/ace/Get_Opt.i @@ -2047,6 +2096,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -2083,6 +2133,10 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Message_Block.h \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ $(ACE_ROOT)/ace/Malloc.i \ $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ @@ -2310,19 +2364,21 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i results.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + results.h \ $(ACE_ROOT)/ace/Profile_Timer.h \ $(ACE_ROOT)/ace/Time_Value.h \ $(ACE_ROOT)/ace/High_Res_Timer.h \ $(ACE_ROOT)/ace/High_Res_Timer.i \ - $(ACE_ROOT)/ace/Profile_Timer.i client.h \ - param_testCli.h param_testCli.i client.cpp + $(ACE_ROOT)/ace/Profile_Timer.i \ + client.h param_testCli.h param_testCli.i client.cpp .obj/options.o .obj/options.so .shobj/options.o .shobj/options.so: options.cpp \ $(ACE_ROOT)/ace/Read_Buffer.h \ $(ACE_ROOT)/ace/ACE.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -2335,8 +2391,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -2351,6 +2410,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -2370,14 +2438,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Read_Buffer.i \ $(ACE_ROOT)/ace/Get_Opt.h \ $(ACE_ROOT)/ace/Get_Opt.i options.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -2598,13 +2658,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Log_Record.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ $(ACE_ROOT)/ace/Trace.h \ $(ACE_ROOT)/ace/OS.i \ $(ACE_ROOT)/ace/Log_Priority.h \ - $(ACE_ROOT)/ace/Log_Record.i results.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + results.h \ $(TAO_ROOT)/tao/corba.h \ $(TAO_ROOT)/tao/corbafwd.h \ $(ACE_ROOT)/ace/CDR_Stream.h \ @@ -2613,8 +2675,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -2629,6 +2694,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -2751,14 +2825,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -2873,6 +2939,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -2889,8 +2956,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -2905,6 +2975,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -3027,14 +3106,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -3138,12 +3209,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i .obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -3160,8 +3233,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -3176,6 +3252,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -3298,14 +3383,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -3409,12 +3486,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i .obj/any.o .obj/any.so .shobj/any.o .shobj/any.so: any.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -3431,8 +3510,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -3447,6 +3529,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -3569,14 +3660,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -3680,13 +3763,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - any.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i any.h .obj/bd_long_seq.o .obj/bd_long_seq.so .shobj/bd_long_seq.o .shobj/bd_long_seq.so: bd_long_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -3703,8 +3787,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -3719,6 +3806,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -3841,14 +3937,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -3952,13 +4040,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_long_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_long_seq.h .obj/bd_short_seq.o .obj/bd_short_seq.so .shobj/bd_short_seq.o .shobj/bd_short_seq.so: bd_short_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -3975,8 +4064,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -3991,6 +4083,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -4113,14 +4214,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -4224,13 +4317,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_short_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_short_seq.h .obj/bd_str_seq.o .obj/bd_str_seq.so .shobj/bd_str_seq.o .shobj/bd_str_seq.so: bd_str_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -4247,8 +4341,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -4263,6 +4360,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -4385,14 +4491,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -4496,13 +4594,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_str_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_str_seq.h .obj/bd_wstr_seq.o .obj/bd_wstr_seq.so .shobj/bd_wstr_seq.o .shobj/bd_wstr_seq.so: bd_wstr_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -4519,8 +4618,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -4535,6 +4637,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -4657,14 +4768,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -4768,13 +4871,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_wstr_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_wstr_seq.h .obj/bd_string.o .obj/bd_string.so .shobj/bd_string.o .shobj/bd_string.so: bd_string.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -4791,8 +4895,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -4807,6 +4914,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -4929,14 +5045,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -5040,13 +5148,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_string.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_string.h .obj/bd_wstring.o .obj/bd_wstring.so .shobj/bd_wstring.o .shobj/bd_wstring.so: bd_wstring.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -5063,8 +5172,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -5079,6 +5191,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -5201,14 +5322,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -5312,13 +5425,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_wstring.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_wstring.h .obj/bd_struct_seq.o .obj/bd_struct_seq.so .shobj/bd_struct_seq.o .shobj/bd_struct_seq.so: bd_struct_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -5335,8 +5449,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -5351,6 +5468,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -5473,14 +5599,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -5584,13 +5702,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_struct_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_struct_seq.h .obj/bd_array_seq.o .obj/bd_array_seq.so .shobj/bd_array_seq.o .shobj/bd_array_seq.so: bd_array_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -5607,8 +5726,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -5623,6 +5745,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -5745,14 +5876,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -5856,13 +5979,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - bd_array_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i bd_array_seq.h .obj/fixed_array.o .obj/fixed_array.so .shobj/fixed_array.o .shobj/fixed_array.so: fixed_array.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -5879,8 +6003,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -5895,6 +6022,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -6017,14 +6153,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -6128,13 +6256,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - fixed_array.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i fixed_array.h .obj/fixed_struct.o .obj/fixed_struct.so .shobj/fixed_struct.o .shobj/fixed_struct.so: fixed_struct.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -6151,8 +6280,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -6167,6 +6299,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -6289,14 +6430,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -6400,13 +6533,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - fixed_struct.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i fixed_struct.h .obj/nested_struct.o .obj/nested_struct.so .shobj/nested_struct.o .shobj/nested_struct.so: nested_struct.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -6423,8 +6557,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -6439,6 +6576,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -6561,14 +6707,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -6672,13 +6810,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - nested_struct.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i nested_struct.h .obj/objref_struct.o .obj/objref_struct.so .shobj/objref_struct.o .shobj/objref_struct.so: objref_struct.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -6695,8 +6834,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -6711,6 +6853,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -6833,14 +6984,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -6944,13 +7087,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - objref_struct.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i objref_struct.h .obj/objref.o .obj/objref.so .shobj/objref.o .shobj/objref.so: objref.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -6967,8 +7111,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -6983,6 +7130,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -7105,14 +7261,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -7216,13 +7364,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - objref.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i objref.h .obj/short.o .obj/short.so .shobj/short.o .shobj/short.so: short.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -7239,8 +7388,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -7255,6 +7407,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -7377,14 +7538,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -7488,13 +7641,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - short.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i short.h .obj/ulonglong.o .obj/ulonglong.so .shobj/ulonglong.o .shobj/ulonglong.so: ulonglong.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -7511,8 +7665,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -7527,6 +7684,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -7649,14 +7815,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -7760,13 +7918,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ulonglong.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ulonglong.h .obj/typecode.o .obj/typecode.so .shobj/typecode.o .shobj/typecode.so: typecode.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -7783,8 +7942,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -7799,6 +7961,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -7921,14 +8092,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -8032,13 +8195,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - typecode.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i typecode.h .obj/ub_any_seq.o .obj/ub_any_seq.so .shobj/ub_any_seq.o .shobj/ub_any_seq.so: ub_any_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -8055,8 +8219,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -8071,6 +8238,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -8193,14 +8369,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -8304,13 +8472,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_any_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_any_seq.h .obj/ub_long_seq.o .obj/ub_long_seq.so .shobj/ub_long_seq.o .shobj/ub_long_seq.so: ub_long_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -8327,8 +8496,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -8343,6 +8515,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -8465,14 +8646,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -8576,13 +8749,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_long_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_long_seq.h .obj/ub_objref_seq.o .obj/ub_objref_seq.so .shobj/ub_objref_seq.o .shobj/ub_objref_seq.so: ub_objref_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -8599,8 +8773,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -8615,6 +8792,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -8737,14 +8923,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -8848,13 +9026,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_objref_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_objref_seq.h .obj/ub_short_seq.o .obj/ub_short_seq.so .shobj/ub_short_seq.o .shobj/ub_short_seq.so: ub_short_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -8871,8 +9050,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -8887,6 +9069,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -9009,14 +9200,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -9120,13 +9303,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_short_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_short_seq.h .obj/ub_str_seq.o .obj/ub_str_seq.so .shobj/ub_str_seq.o .shobj/ub_str_seq.so: ub_str_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -9143,8 +9327,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -9159,6 +9346,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -9281,14 +9477,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -9392,13 +9580,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_str_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_str_seq.h .obj/ub_wstr_seq.o .obj/ub_wstr_seq.so .shobj/ub_wstr_seq.o .shobj/ub_wstr_seq.so: ub_wstr_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -9415,8 +9604,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -9431,6 +9623,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -9553,14 +9754,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -9664,13 +9857,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_wstr_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_wstr_seq.h .obj/ub_string.o .obj/ub_string.so .shobj/ub_string.o .shobj/ub_string.so: ub_string.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -9687,8 +9881,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -9703,6 +9900,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -9825,14 +10031,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -9936,13 +10134,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_string.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_string.h .obj/ub_wstring.o .obj/ub_wstring.so .shobj/ub_wstring.o .shobj/ub_wstring.so: ub_wstring.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -9959,8 +10158,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -9975,6 +10177,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -10097,14 +10308,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -10208,13 +10411,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_wstring.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_wstring.h .obj/ub_struct_seq.o .obj/ub_struct_seq.so .shobj/ub_struct_seq.o .shobj/ub_struct_seq.so: ub_struct_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -10231,8 +10435,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -10247,6 +10454,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -10369,14 +10585,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -10480,13 +10688,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_struct_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_struct_seq.h .obj/ub_array_seq.o .obj/ub_array_seq.so .shobj/ub_array_seq.o .shobj/ub_array_seq.so: ub_array_seq.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -10503,8 +10712,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -10519,6 +10731,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -10641,14 +10862,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -10752,13 +10965,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - ub_array_seq.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i ub_array_seq.h .obj/var_array.o .obj/var_array.so .shobj/var_array.o .shobj/var_array.so: var_array.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -10775,8 +10989,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -10791,6 +11008,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -10913,14 +11139,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -11024,13 +11242,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - var_array.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i var_array.h .obj/var_struct.o .obj/var_struct.so .shobj/var_struct.o .shobj/var_struct.so: var_struct.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -11047,8 +11266,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -11063,6 +11285,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -11185,14 +11416,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -11296,13 +11519,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - var_struct.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i var_struct.h .obj/recursive_struct.o .obj/recursive_struct.so .shobj/recursive_struct.o .shobj/recursive_struct.so: recursive_struct.cpp recursive_struct.h \ - param_testCli.h $(TAO_ROOT)/tao/corba.h \ + param_testCli.h \ + $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -11319,8 +11544,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -11335,6 +11563,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -11457,14 +11694,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -11568,13 +11797,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - helper.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i helper.h .obj/except.o .obj/except.so .shobj/except.o .shobj/except.so: except.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -11591,8 +11821,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -11607,6 +11840,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -11729,14 +11971,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -11840,13 +12074,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - except.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i except.h .obj/big_union.o .obj/big_union.so .shobj/big_union.o .shobj/big_union.so: big_union.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -11863,8 +12098,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -11879,6 +12117,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -12001,14 +12248,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -12112,13 +12351,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - big_union.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i big_union.h .obj/recursive_union.o .obj/recursive_union.so .shobj/recursive_union.o .shobj/recursive_union.so: recursive_union.cpp recursive_union.h \ - param_testCli.h $(TAO_ROOT)/tao/corba.h \ + param_testCli.h \ + $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -12135,8 +12376,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -12151,6 +12395,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -12273,7 +12526,152 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/Object_Adapter.h \ + $(TAO_ROOT)/tao/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map.h \ + $(ACE_ROOT)/ace/Map.i \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair.i \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(TAO_ROOT)/tao/Key_Adapters.i \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/DynAnyC.h \ + $(TAO_ROOT)/tao/DynAnyC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Active_Object_Map.i \ + $(TAO_ROOT)/tao/Object_Adapter.i \ + $(TAO_ROOT)/tao/POAManager.h \ + $(TAO_ROOT)/tao/POAManager.i \ + $(TAO_ROOT)/tao/ImplRepoC.h \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/ImplRepoC.i \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ + $(TAO_ROOT)/tao/DynAny_i.h \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/InterfaceC.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i helper.h + +.obj/multdim_array.o .obj/multdim_array.so .shobj/multdim_array.o .shobj/multdim_array.so: multdim_array.cpp helper.h param_testCli.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ $(ACE_ROOT)/ace/Singleton.i \ $(ACE_ROOT)/ace/Singleton.cpp \ $(ACE_ROOT)/ace/Object_Manager.h \ @@ -12281,6 +12679,130 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Managed_Object.h \ $(ACE_ROOT)/ace/Managed_Object.i \ $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/IOR_LookupTable.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/IORManipulation.h \ + $(TAO_ROOT)/tao/IORS.h \ + $(TAO_ROOT)/tao/IORC.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/IORC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.i \ + $(TAO_ROOT)/tao/IORS.i \ + $(TAO_ROOT)/tao/Interceptor.h \ + $(TAO_ROOT)/tao/InterceptorS.h \ + $(TAO_ROOT)/tao/InterceptorC.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/InterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Context.h \ + $(TAO_ROOT)/tao/Context.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -12384,15 +12906,14 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - helper.h - -.obj/multdim_array.o .obj/multdim_array.so .shobj/multdim_array.o .shobj/multdim_array.so: multdim_array.cpp + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i multdim_array.h .obj/complex_any.o .obj/complex_any.so .shobj/complex_any.o .shobj/complex_any.so: complex_any.cpp helper.h param_testCli.h \ $(TAO_ROOT)/tao/corba.h \ $(ACE_ROOT)/ace/OS.h \ $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/Min_Max.h \ $(ACE_ROOT)/ace/streams.h \ $(ACE_ROOT)/ace/Basic_Types.h \ $(ACE_ROOT)/ace/Basic_Types.i \ @@ -12409,8 +12930,11 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/ACE.i \ $(ACE_ROOT)/ace/Malloc.h \ $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.h \ + $(ACE_ROOT)/ace/Based_Pointer_T.i \ + $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ + $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ + $(ACE_ROOT)/ace/Singleton.h \ $(ACE_ROOT)/ace/Synch.h \ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ @@ -12425,6 +12949,15 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(ACE_ROOT)/ace/Thread.i \ $(ACE_ROOT)/ace/Atomic_Op.i \ $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ $(ACE_ROOT)/ace/Free_List.h \ $(ACE_ROOT)/ace/Free_List.i \ $(ACE_ROOT)/ace/Free_List.cpp \ @@ -12547,14 +13080,6 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/Marshal.h \ $(TAO_ROOT)/tao/Marshal.i \ $(TAO_ROOT)/tao/singletons.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ $(TAO_ROOT)/tao/POA.h \ $(TAO_ROOT)/tao/Object_Adapter.h \ $(TAO_ROOT)/tao/Key_Adapters.h \ @@ -12658,7 +13183,7 @@ endif # ! ACE_HAS_GNUG_PRE_2_8 $(TAO_ROOT)/tao/WrongTransactionC.h \ $(TAO_ROOT)/tao/InterfaceC.h \ $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i param_testCli.i \ - complex_any.h + $(TAO_ROOT)/tao/BoundsC.i \ + param_testCli.i complex_any.h # IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/Param_Test/any.cpp b/TAO/tests/Param_Test/any.cpp index c709002f44b..d6fc87c19e1 100644 --- a/TAO/tests/Param_Test/any.cpp +++ b/TAO/tests/Param_Test/any.cpp @@ -49,7 +49,30 @@ Test_Any::opname (void) const void Test_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("o1") <<= this->in_; + req->add_inout_arg ("o2") <<= this->inout_; + req->add_out_arg ("o3") = CORBA::Any (CORBA::_tc_any); + + req->set_return_type (CORBA::_tc_any); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + const CORBA::Any *tmp; + req->return_value () >>= tmp; + this->ret_ = new CORBA::Any (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = CORBA::Any (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new CORBA::Any (*tmp); } #if 0 /* any_table isn't currently used */ @@ -104,8 +127,8 @@ Test_Any::reset_parameters (void) "Param_Test: ANY_SHORT subtest\n")); CORBA::Short s; s = gen->gen_short (); - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, "setting short = %d\n", s)); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "setting short = %d\n", s)); this->in_ <<= s; this->inout_ <<= s; } @@ -117,8 +140,8 @@ Test_Any::reset_parameters (void) ACE_DEBUG ((LM_DEBUG, "Param_Test: ANY_STRING subtest\n")); char *str = gen->gen_string (); - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, "setting string = %s\n", str)); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "setting string = %s\n", str)); this->in_ <<= str; this->inout_ <<= str; CORBA::string_free (str); @@ -239,67 +262,6 @@ Test_Any::run_sii_test (Param_Test_ptr objref, return 0; } -int -Test_Any::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (CORBA::_tc_any, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_any, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_any, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("o1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("o2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("o3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_any, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Any::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Any::check_validity (void) { diff --git a/TAO/tests/Param_Test/any.h b/TAO/tests/Param_Test/any.h index ee3d68d7fc4..6b792a408fb 100644 --- a/TAO/tests/Param_Test/any.h +++ b/TAO/tests/Param_Test/any.h @@ -50,11 +50,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/anyop.cpp b/TAO/tests/Param_Test/anyop.cpp new file mode 100644 index 00000000000..d059d7eddec --- /dev/null +++ b/TAO/tests/Param_Test/anyop.cpp @@ -0,0 +1,224 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Param_Test +// +// = FILENAME +// anyop.cpp +// +// = DESCRIPTION +// +// = AUTHORS +// Carlos O'Ryan +// +// ============================================================================ + +#include "param_testCli.h" +#include "tao/corba.h" +#include "ace/Get_Opt.h" + + +ACE_RCSID(Param_Test, anyop, "$Id$") + +int +main (int argc, char *argv[]) +{ + int n = 1024; + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = CORBA::ORB_init (argc, + argv, + 0, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_Get_Opt get_opt (argc, argv, "dn:l:"); + int opt; + + while ((opt = get_opt ()) != EOF) + { + switch (opt) + { + case 'd': + TAO_debug_level++; + break; + case 'n': + n = ACE_OS::atoi (get_opt.optarg); + break; + case '?': + default: + ACE_DEBUG ((LM_DEBUG, + "Usage: %s " + "-d debug" + "-n " + "\n", + argv[0])); + return -1; + } + } + + for (int i = 0; i != n; ++i) + { + CORBA::Any any; + +#if 0 + // @@ TODO @@ This one crashes in deep_free!!! + { + Param_Test::Var_Array var_array; + any <<= Param_Test::Var_Array_forany (var_array); + + Param_Test::Var_Array_forany forany; + if (!(any >>= forany)) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for Param_Test::Var_Array\n")); + } + Param_Test::Var_Array_var var = + Param_Test::Var_Array_dup (forany.in ()); + any <<= Param_Test::Var_Array_forany (var.inout ()); + if (!(any >>= forany)) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for Param_Test::Var_Array[2]\n")); + } + } +#endif /* 0 */ + + { + CORBA::Object_var obj = + orb->string_to_object ("iioploc://localhost:12345/TheKey", + ACE_TRY_ENV); + ACE_TRY_CHECK; + + Coffee_var coffee = + Coffee::_unchecked_narrow (obj.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + + any <<= coffee.in (); + + Coffee_ptr o; + if (!(any >>= o)) + { + ACE_DEBUG ((LM_DEBUG, + "Cannot extract Coffee (oh the horror)\n")); + } + CORBA::Boolean equiv = + coffee->_is_equivalent (o, ACE_TRY_ENV); + ACE_TRY_CHECK; + if (!equiv) + { + ACE_DEBUG ((LM_DEBUG, + "Mismatched Coffee extraction\n")); + } + + CORBA::Object_ptr other; + if (!(any >>= CORBA::Any::to_object (other))) + { + ACE_DEBUG ((LM_DEBUG, + "Cannot extract Coffee as Object\n")); + } + } + + { + CORBA::Short i = 123; + any <<= i; + + CORBA::Short o; + if (!(any >>= o) + || i != o) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for CORBA::Short (%d,%d)\n", + i, o)); + } + } + + { + CORBA::Long i = 123; + any <<= i; + + CORBA::Long o; + if (!(any >>= o) + || i != o) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for CORBA::Long (%d,%d)\n", + i, o)); + } + } + + { + CORBA::ULongLong i = 123; + any <<= i; + + CORBA::ULongLong o; + if (!(any >>= o) + || i != o) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for CORBA::ULongLong (%Q,%Q)\n", + i, o)); + } + } + + { + CORBA::Double i = 123; + any <<= i; + + CORBA::Double o; + if (!(any >>= o) + || i != o) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for CORBA::Double (%f,%f)\n", + i, o)); + } + } + + { + CORBA::Any i; + i <<= CORBA::Short (123); + any <<= i; + + const CORBA::Any *o; + CORBA::Short oo; + + if (!(any >>= o) + || !(*o >>= oo) + || 123 != oo) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for CORBA::Any (%d)\n", + oo)); + } + } + + { + char *i = "123"; + any <<= i; + + char * o; + if (!(any >>= o) + || ACE_OS::strcmp (i, o) != 0) + { + ACE_DEBUG ((LM_DEBUG, + "Failure for char* (%s,%s)\n", + i, o)); + } + } + + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Basic_Types"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Param_Test/bd_array_seq.cpp b/TAO/tests/Param_Test/bd_array_seq.cpp index adf020a221d..c19db80d81b 100644 --- a/TAO/tests/Param_Test/bd_array_seq.cpp +++ b/TAO/tests/Param_Test/bd_array_seq.cpp @@ -51,7 +51,29 @@ void Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + req->set_return_type (Param_Test::_tc_Bounded_ArraySeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Bounded_ArraySeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_ArraySeq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_ArraySeq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_ArraySeq (*tmp); } int @@ -108,7 +130,7 @@ Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref, { Param_Test::Bounded_ArraySeq_out out (this->out_.out ()); - this->ret_ = + this->ret_ = objref->test_bounded_array_sequence (this->in_, this->inout_.inout (), out, @@ -127,67 +149,6 @@ Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_Array_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_ArraySeq, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_ArraySeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_ArraySeq, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_ArraySeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_Array_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_Array_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_array_seq.h b/TAO/tests/Param_Test/bd_array_seq.h index 03db2e81c8a..411cf0ec1e1 100644 --- a/TAO/tests/Param_Test/bd_array_seq.h +++ b/TAO/tests/Param_Test/bd_array_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name @@ -62,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/bd_long_seq.cpp b/TAO/tests/Param_Test/bd_long_seq.cpp index 6ba7a04d4ad..7f2e51a4f96 100644 --- a/TAO/tests/Param_Test/bd_long_seq.cpp +++ b/TAO/tests/Param_Test/bd_long_seq.cpp @@ -50,7 +50,29 @@ void Test_Bounded_Long_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + req->set_return_type (Param_Test::_tc_Bounded_Long_Seq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + const Param_Test::Bounded_Long_Seq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_Long_Seq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_Long_Seq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_Long_Seq (*tmp); } int @@ -108,67 +130,6 @@ Test_Bounded_Long_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_Long_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_Long_Seq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_Long_Seq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_Long_Seq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_Long_Seq, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_Long_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_Long_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_long_seq.h b/TAO/tests/Param_Test/bd_long_seq.h index 306da6e4a23..5dda51d2268 100644 --- a/TAO/tests/Param_Test/bd_long_seq.h +++ b/TAO/tests/Param_Test/bd_long_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/bd_short_seq.cpp b/TAO/tests/Param_Test/bd_short_seq.cpp index 8412b139fdc..b46047ad57e 100644 --- a/TAO/tests/Param_Test/bd_short_seq.cpp +++ b/TAO/tests/Param_Test/bd_short_seq.cpp @@ -47,10 +47,32 @@ Test_Bounded_Short_Sequence::opname (void) const } void -Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req, +Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + req->set_return_type (Param_Test::_tc_Bounded_Short_Seq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Bounded_Short_Seq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_Short_Seq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_Short_Seq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_Short_Seq (*tmp); } int @@ -111,67 +133,6 @@ Test_Bounded_Short_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_Short_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_Short_Seq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_Short_Seq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_Short_Seq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_Short_Seq, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_Short_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_Short_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_short_seq.h b/TAO/tests/Param_Test/bd_short_seq.h index 2198fa319fa..5efe29e22a6 100644 --- a/TAO/tests/Param_Test/bd_short_seq.h +++ b/TAO/tests/Param_Test/bd_short_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/bd_str_seq.cpp b/TAO/tests/Param_Test/bd_str_seq.cpp index 20cd5679d16..bd9aae472bd 100644 --- a/TAO/tests/Param_Test/bd_str_seq.cpp +++ b/TAO/tests/Param_Test/bd_str_seq.cpp @@ -50,7 +50,30 @@ void Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Bounded_StrSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + const Param_Test::Bounded_StrSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_StrSeq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_StrSeq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_StrSeq (*tmp); } int @@ -113,67 +136,6 @@ Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_String_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_StrSeq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_StrSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_StrSeq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_StrSeq, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_String_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_String_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_str_seq.h b/TAO/tests/Param_Test/bd_str_seq.h index ea82ac8d55a..48b60f9366b 100644 --- a/TAO/tests/Param_Test/bd_str_seq.h +++ b/TAO/tests/Param_Test/bd_str_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/bd_string.cpp b/TAO/tests/Param_Test/bd_string.cpp index c0a650a427d..b4028178f57 100644 --- a/TAO/tests/Param_Test/bd_string.cpp +++ b/TAO/tests/Param_Test/bd_string.cpp @@ -58,12 +58,35 @@ void Test_Bounded_String::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= CORBA::Any::from_string (this->in_, 128); + req->add_inout_arg ("s2") <<= CORBA::Any::from_string (this->inout_, 128); + req->add_out_arg ("s3") <<= CORBA::Any::from_string (this->out_, 128); + + req->set_return_type (Param_Test::_tc_short_string); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + char *tmp; + req->return_value () >>= CORBA::Any::to_string (tmp, 128); + this->ret_ = CORBA::string_dup (tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= CORBA::Any::to_string (tmp, 128); + this->inout_ = CORBA::string_dup (tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= CORBA::Any::to_string (tmp, 128); + this->out_ = CORBA::string_dup (tmp); } int Test_Bounded_String::init_parameters (Param_Test_ptr, - CORBA::Environment &) + CORBA::Environment &) { Generator *gen = GENERATOR::instance (); // value generator @@ -99,7 +122,7 @@ Test_Bounded_String::reset_parameters (void) int Test_Bounded_String::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { @@ -123,68 +146,6 @@ Test_Bounded_String::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_String::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // create the parameters - CORBA::Any in_arg (CORBA::_tc_string, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_string, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_string, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_string, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_String::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_String::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_string.h b/TAO/tests/Param_Test/bd_string.h index faf9bfd0fad..46291917900 100644 --- a/TAO/tests/Param_Test/bd_string.h +++ b/TAO/tests/Param_Test/bd_string.h @@ -37,15 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - - int add_args (CORBA::Request_ptr &req, - CORBA::Environment &env); - // add args to NVList using << operator - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/bd_struct_seq.cpp b/TAO/tests/Param_Test/bd_struct_seq.cpp index b2252973f3c..af50383b84f 100644 --- a/TAO/tests/Param_Test/bd_struct_seq.cpp +++ b/TAO/tests/Param_Test/bd_struct_seq.cpp @@ -53,7 +53,29 @@ void Test_Bounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + req->set_return_type (Param_Test::_tc_Bounded_StructSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Bounded_StructSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_StructSeq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_StructSeq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_StructSeq (*tmp); } int @@ -109,67 +131,6 @@ Test_Bounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_Struct_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_StructSeq, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_StructSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_StructSeq, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_StructSeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_Struct_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_Struct_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_struct_seq.h b/TAO/tests/Param_Test/bd_struct_seq.h index 9119a46c90b..a8ce07bd760 100644 --- a/TAO/tests/Param_Test/bd_struct_seq.h +++ b/TAO/tests/Param_Test/bd_struct_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/bd_wstr_seq.cpp b/TAO/tests/Param_Test/bd_wstr_seq.cpp index efd7a311f39..cd1a3072b0d 100644 --- a/TAO/tests/Param_Test/bd_wstr_seq.cpp +++ b/TAO/tests/Param_Test/bd_wstr_seq.cpp @@ -50,7 +50,30 @@ void Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Bounded_WStrSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + const Param_Test::Bounded_WStrSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Bounded_WStrSeq (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Bounded_WStrSeq (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Bounded_WStrSeq (*tmp); } int @@ -116,67 +139,6 @@ Test_Bounded_WString_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Bounded_WString_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Bounded_WStrSeq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Bounded_WStrSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Bounded_WStrSeq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("ws1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Bounded_WStrSeq, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_WString_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Bounded_WString_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/bd_wstr_seq.h b/TAO/tests/Param_Test/bd_wstr_seq.h index 43c0f4f5e9b..108d53a4057 100644 --- a/TAO/tests/Param_Test/bd_wstr_seq.h +++ b/TAO/tests/Param_Test/bd_wstr_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name @@ -62,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/bd_wstring.cpp b/TAO/tests/Param_Test/bd_wstring.cpp index fd954cf1825..ec9cbe4eabb 100644 --- a/TAO/tests/Param_Test/bd_wstring.cpp +++ b/TAO/tests/Param_Test/bd_wstring.cpp @@ -2,213 +2,174 @@ // ============================================================================ // -// = LIBRARY -// TAO/tests/Param_Test +// = Library +// Tao/Tests/Param_Test // -// = FILENAME -// bd_wstring.cpp +// = Filename +// Bd_Wstring.Cpp // -// = DESCRIPTION -// tests bounded wide strings +// = Description +// Tests Bounded Wide Strings // -// = AUTHORS +// = Authors // Jeff Parsons // // ============================================================================ -#include "helper.h" -#include "bd_wstring.h" +#Include "Helper.H" +#Include "Bd_Wstring.H" -ACE_RCSID(Param_Test, bd_wstring, "$Id$") +Ace_Rcsid(Param_Test, Bd_Wstring, "$id: Bd_Wstring.Cpp,V 1.3 1999/09/17 17:03:22 Parsons Exp $") // ************************************************************************ -// Test_Bounded_WString +// Test_Bounded_Wstring // ************************************************************************ -Test_Bounded_WString::Test_Bounded_WString (void) - : opname_ (CORBA::string_dup ("test_bounded_wstring")), - in_ (0), - inout_ (0), - out_ (0), - ret_ (0) +Test_Bounded_Wstring::Test_Bounded_Wstring (Void) + : Opname_ (Corba::String_Dup ("Test_Bounded_Wstring")), + In_ (0), + Inout_ (0), + Out_ (0), + Ret_ (0) { } -Test_Bounded_WString::~Test_Bounded_WString (void) +Test_Bounded_Wstring::~Test_Bounded_Wstring (Void) { - CORBA::string_free (this->opname_); - CORBA::wstring_free (this->in_); - CORBA::wstring_free (this->inout_); - CORBA::wstring_free (this->out_); - CORBA::wstring_free (this->ret_); - this->opname_ = 0; - this->in_ = 0; - this->inout_ = 0; - this->out_ = 0; - this->ret_ = 0; + Corba::String_Free (This->Opname_); + Corba::Wstring_Free (This->In_); + Corba::Wstring_Free (This->Inout_); + Corba::Wstring_Free (This->Out_); + Corba::Wstring_Free (This->Ret_); + This->Opname_ = 0; + This->In_ = 0; + This->Inout_ = 0; + This->Out_ = 0; + This->Ret_ = 0; } -const char * -Test_Bounded_WString::opname (void) const +Const Char * +Test_Bounded_Wstring::Opname (Void) Const { - return this->opname_; + Return This->Opname_; } -void -Test_Bounded_WString::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Void +Test_Bounded_Wstring::Dii_Req_Invoke (Corba::Request *Req, + Corba::Environment &Ace_Try_Env) { - req->invoke (ACE_TRY_ENV); + Req->Add_In_Arg ("S1") <<= Corba::Any::From_Wstring (This->In_, 128); + Req->Add_Inout_Arg ("S2") <<= Corba::Any::From_Wstring (This->Inout_, 128); + Req->Add_Out_Arg ("S3") <<= Corba::Any::From_Wstring (This->Out_, 128); + + Req->Set_Return_Type (Param_Test::_Tc_Short_Wstring); + + Req->Invoke (Ace_Try_Env); + Ace_Check; + + Corba::Wchar *Tmp; + Req->Return_Value () >>= Corba::Any::To_Wstring (Tmp, 128); + This->Ret_ = Corba::Wstring_Dup (Tmp); + + Corba::Namedvalue_Ptr Arg2 = + Req->Arguments ()->Item (1, Ace_Try_Env); + Ace_Check; + *Arg2->Value () >>= Corba::Any::To_Wstring (Tmp, 128); + This->Inout_ = Corba::Wstring_Dup (Tmp); + + Corba::Namedvalue_Ptr Arg3 = + Req->Arguments ()->Item (2, Ace_Try_Env); + Ace_Check; + *Arg3->Value () >>= Corba::Any::To_Wstring (Tmp, 128); + This->Out_ = Corba::Wstring_Dup (Tmp); } -int -Test_Bounded_WString::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Int +Test_Bounded_Wstring::Init_Parameters (Param_Test_Ptr, + Corba::Environment &) { - Generator *gen = GENERATOR::instance (); // value generator - - // release any previously occupied values - CORBA::wstring_free (this->in_); - CORBA::wstring_free (this->inout_); - CORBA::wstring_free (this->out_); - CORBA::wstring_free (this->ret_); - this->in_ = 0; - this->inout_ = 0; - this->out_ = 0; - this->ret_ = 0; - - this->in_ = gen->gen_wstring (32); - this->inout_ = CORBA::wstring_dup (this->in_); - return 0; + Generator *Gen = Generator::Instance (); // Value Generator + + // Release Any Previously Occupied Values + Corba::Wstring_Free (This->In_); + Corba::Wstring_Free (This->Inout_); + Corba::Wstring_Free (This->Out_); + Corba::Wstring_Free (This->Ret_); + This->In_ = 0; + This->Inout_ = 0; + This->Out_ = 0; + This->Ret_ = 0; + + This->In_ = Gen->Gen_Wstring (32); + This->Inout_ = Corba::Wstring_Dup (This->In_); + Return 0; } -int -Test_Bounded_WString::reset_parameters (void) +Int +Test_Bounded_Wstring::Reset_Parameters (Void) { - // release any previously occupied values - CORBA::wstring_free (this->inout_); - CORBA::wstring_free (this->out_); - CORBA::wstring_free (this->ret_); - this->inout_ = 0; - this->out_ = 0; - this->ret_ = 0; - - this->inout_ = CORBA::wstring_dup (this->in_); - return 0; + // Release Any Previously Occupied Values + Corba::Wstring_Free (This->Inout_); + Corba::Wstring_Free (This->Out_); + Corba::Wstring_Free (This->Ret_); + This->Inout_ = 0; + This->Out_ = 0; + This->Ret_ = 0; + + This->Inout_ = Corba::Wstring_Dup (This->In_); + Return 0; } -int -Test_Bounded_WString::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Int +Test_Bounded_Wstring::Run_Sii_Test (Param_Test_Ptr Objref, + Corba::Environment &Ace_Try_Env) { - ACE_TRY + Ace_Try { - CORBA::WString_out str_out (this->out_); + Corba::Wstring_Out Str_Out (This->Out_); - this->ret_ = objref->test_bounded_wstring (this->in_, - this->inout_, - str_out, - ACE_TRY_ENV); - ACE_TRY_CHECK; + This->Ret_ = Objref->Test_Bounded_Wstring (This->In_, + This->Inout_, + Str_Out, + Ace_Try_Env); + Ace_Try_Check; - return 0; + Return 0; } - ACE_CATCHANY + Ace_Catchany { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_WString::run_sii_test\n"); + Ace_Print_Exception (Ace_Any_Exception, + "Test_Bounded_Wstring::Run_Sii_Test\N"); } - ACE_ENDTRY; - return -1; + Ace_Endtry; + Return -1; } -int -Test_Bounded_WString::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) +Corba::Boolean +Test_Bounded_Wstring::Check_Validity (Void) { - ACE_TRY - { - // create the parameters - CORBA::Any in_arg (CORBA::_tc_wstring, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_wstring, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_wstring, - &this->out_, - 0); - - // add parameters - param_list->add_value ("ws1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_wstring, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Bounded_WString::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - -CORBA::Boolean -Test_Bounded_WString::check_validity (void) -{ - CORBA::ULong len = ACE_OS::wslen (this->in_); + Corba::Ulong Len = Ace_Os::Wslen (This->In_); - if (!ACE_OS::wscmp (this->in_, this->out_) && - !ACE_OS::wscmp (this->in_, this->ret_) && - ACE_OS::wslen (this->inout_) == 2*len && - !ACE_OS::wsncmp (this->in_, this->inout_, len) && - !ACE_OS::wsncmp (this->in_, &this->inout_[len], len)) - return 1; + If (!Ace_Os::Wscmp (This->In_, This->Out_) && + !Ace_Os::Wscmp (This->In_, This->Ret_) && + Ace_Os::Wslen (This->Inout_) == 2*Len && + !Ace_Os::Wsncmp (This->In_, This->Inout_, Len) && + !Ace_Os::Wsncmp (This->In_, &This->Inout_[Len], Len)) + Return 1; - return 0; // otherwise + Return 0; // Otherwise } -CORBA::Boolean -Test_Bounded_WString::check_validity (CORBA::Request_ptr) +Corba::Boolean +Test_Bounded_Wstring::Check_Validity (Corba::Request_Ptr) { - // No need to retrieve anything because, for all the args and - // the return, we provided the memory and we own it. - return this->check_validity (); + // No Need To Retrieve Anything Because, For All The Args And + // The Return, We Provided The Memory And We Own It. + Return This->Check_Validity (); } -void -Test_Bounded_WString::print_values (void) +Void +Test_Bounded_Wstring::Print_Values (Void) { } diff --git a/TAO/tests/Param_Test/bd_wstring.h b/TAO/tests/Param_Test/bd_wstring.h index 65b22fdc5f9..8e864ce6f32 100644 --- a/TAO/tests/Param_Test/bd_wstring.h +++ b/TAO/tests/Param_Test/bd_wstring.h @@ -37,15 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - - int add_args (CORBA::Request_ptr &req, - CORBA::Environment &env); - // add args to NVList using << operator - const char *opname (void) const; // return operation name @@ -65,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/big_union.cpp b/TAO/tests/Param_Test/big_union.cpp index ee26fe2d964..72ffa97fd58 100644 --- a/TAO/tests/Param_Test/big_union.cpp +++ b/TAO/tests/Param_Test/big_union.cpp @@ -48,7 +48,30 @@ void Test_Big_Union::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Big_Union); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Big_Union *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Big_Union (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = *tmp; + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Big_Union (*tmp); } int @@ -224,67 +247,6 @@ Test_Big_Union::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Big_Union::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Big_Union, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Big_Union, - &this->inout_, - 0); - - CORBA::Any out_arg (Param_Test::_tc_Big_Union, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("u1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("u2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("u3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Big_Union, - &this->ret_.inout (), - 0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Big_Union::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Big_Union::check_validity (void) { @@ -311,7 +273,7 @@ Test_Big_Union::check_validity (void) || in_array[i] != out_array[i] || in_array[i] != ret_array[i]) { - ACE_DEBUG ((LM_DEBUG, + ACE_DEBUG ((LM_DEBUG, "mismatch of arrays\n")); return 0; } diff --git a/TAO/tests/Param_Test/big_union.h b/TAO/tests/Param_Test/big_union.h index 408fb7086d7..e92b00b0046 100644 --- a/TAO/tests/Param_Test/big_union.h +++ b/TAO/tests/Param_Test/big_union.h @@ -41,11 +41,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/client.cpp b/TAO/tests/Param_Test/client.cpp index d0600e98bd3..aab49207afa 100644 --- a/TAO/tests/Param_Test/client.cpp +++ b/TAO/tests/Param_Test/client.cpp @@ -64,7 +64,7 @@ Param_Test_Client::run_sii_test (void) // Declare the Env ACE_DECLARE_NEW_CORBA_ENV; // Initialize parameters for the test. - int check = this->test_object_->init_parameters (this->param_test_, + int check = this->test_object_->init_parameters (this->param_test_, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); @@ -73,7 +73,7 @@ Param_Test_Client::run_sii_test (void) ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) client.cpp - run_sii_test:" "init_parameters failed for opname - %s", - opname), + opname), -1); } @@ -91,7 +91,7 @@ Param_Test_Client::run_sii_test (void) this->results_.start_timer (); // make the call - this->test_object_->run_sii_test (this->param_test_, + this->test_object_->run_sii_test (this->param_test_, ACE_TRY_ENV); ACE_TRY_CHECK; @@ -142,14 +142,14 @@ Param_Test_Client::run_sii_test (void) if (this->results_.error_count () != 0) { ACE_DEBUG ((LM_DEBUG, - "********** Error running %s SII *********\n", - opname)); + "********** Error running %s SII *********\n", + opname)); } else { ACE_DEBUG ((LM_DEBUG, - "********** Finished running %s SII *********\n", - opname)); + "********** Finished running %s SII *********\n", + opname)); } return this->results_.error_count ()? -1:0; } @@ -172,7 +172,7 @@ Param_Test_Client::run_dii_test (void) // Environment variable ACE_DECLARE_NEW_CORBA_ENV; // initialize parameters for the test - int check = this->test_object_->init_parameters (this->param_test_, + int check = this->test_object_->init_parameters (this->param_test_, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); @@ -181,7 +181,7 @@ Param_Test_Client::run_dii_test (void) ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) client.cpp - run_dii_test:" "init_parameters failed for opname - %s", - opname), + opname), -1); } @@ -194,50 +194,20 @@ Param_Test_Client::run_dii_test (void) // time required to create and populate the NVList this->results_.start_timer (); - // first create the argument list (length 0 because args are *added*) - CORBA::NVList_ptr nvlist; - - this->orb_->create_list (0, nvlist); - - // then the result holder (length 1 because value is *replaced*) - CORBA::NVList_var retval; - this->orb_->create_list (1, - retval.out ()); - // create the request CORBA::Request_var req; ACE_TRY { - // add arguments and typecode for return valueto the NVList - this->test_object_->add_args (nvlist, - retval.in (), - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue_ptr result = - CORBA::NamedValue::_duplicate (retval->item (0, - ACE_TRY_ENV)); - ACE_TRY_CHECK; - - this->param_test_->_create_request (CORBA_Context::_nil (), - opname, - nvlist, - result, - req.out (), - 0, //CORBA::OUT_LIST_MEMORY, - ACE_TRY_ENV); - // The OUT_LIST_MEMORY is to be used when the ORB assumes that - // we will provide the top-level storage. With 0, the returned - // values for ret, inout, and out parameters are all owned by - // the ORB and hence we must not free them explicitly. + req = this->param_test_->_request (opname, + ACE_TRY_ENV); ACE_TRY_CHECK; if (opt->debug ()) ACE_DEBUG ((LM_DEBUG, "\n****** Before call values *****\n")); // Make the invocation, verify the result. - this->test_object_->dii_req_invoke (req.in (), + this->test_object_->dii_req_invoke (req.in (), ACE_TRY_ENV); ACE_TRY_CHECK; } @@ -282,14 +252,14 @@ Param_Test_Client::run_dii_test (void) if (this->results_.error_count () != 0) { ACE_DEBUG ((LM_DEBUG, - "********** Error running %s DII *********\n", - opname)); + "********** Error running %s DII *********\n", + opname)); } else { ACE_DEBUG ((LM_DEBUG, - "********** Finished running %s DII *********\n", - opname)); + "********** Finished running %s DII *********\n", + opname)); } return this->results_.error_count () ? -1 : 0; } diff --git a/TAO/tests/Param_Test/complex_any.cpp b/TAO/tests/Param_Test/complex_any.cpp index a9d531be88b..300d0da1e36 100644 --- a/TAO/tests/Param_Test/complex_any.cpp +++ b/TAO/tests/Param_Test/complex_any.cpp @@ -53,7 +53,30 @@ void Test_Complex_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= CORBA::Any (CORBA::_tc_any); + + req->set_return_type (CORBA::_tc_any); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + const CORBA::Any *tmp; + req->return_value () >>= tmp; + this->ret_ = new CORBA::Any (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = CORBA::Any (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new CORBA::Any (*tmp); } int @@ -162,67 +185,6 @@ Test_Complex_Any::run_sii_test (Param_Test_ptr objref, return 0; } -int -Test_Complex_Any::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (CORBA::_tc_any, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_any, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_any, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("ca1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ca2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ca3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_any, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Complex_Any::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Complex_Any::check_validity (void) { diff --git a/TAO/tests/Param_Test/complex_any.h b/TAO/tests/Param_Test/complex_any.h index 562a3bb1d23..026d441ab22 100644 --- a/TAO/tests/Param_Test/complex_any.h +++ b/TAO/tests/Param_Test/complex_any.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/except.cpp b/TAO/tests/Param_Test/except.cpp index 09d7cd82cc8..b2832867328 100644 --- a/TAO/tests/Param_Test/except.cpp +++ b/TAO/tests/Param_Test/except.cpp @@ -49,8 +49,26 @@ Test_Exception::dii_req_invoke (CORBA::Request *req, { ACE_TRY { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + + req->set_return_type (CORBA::_tc_long); + req->invoke (ACE_TRY_ENV); ACE_TRY_CHECK; + + req->return_value () >>= this->ret_; + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= this->inout_; + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= this->out_; } ACE_CATCH (CORBA::UnknownUserException, user_ex) { @@ -180,69 +198,6 @@ Test_Exception::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Exception::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // we provide top level memory to the ORB to retrieve the data - CORBA::Any in_arg (CORBA::_tc_ulong, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_ulong, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_ulong, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value. Let the ORB allocate storage. We simply tell the ORB - // what type we are expecting. - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_ulong, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Exception::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Exception::check_validity (void) { diff --git a/TAO/tests/Param_Test/except.h b/TAO/tests/Param_Test/except.h index 8b28c39e956..fb85e1d71cc 100644 --- a/TAO/tests/Param_Test/except.h +++ b/TAO/tests/Param_Test/except.h @@ -34,10 +34,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/fixed_array.cpp b/TAO/tests/Param_Test/fixed_array.cpp index 3a96fc3c5c7..cad9afe1d72 100644 --- a/TAO/tests/Param_Test/fixed_array.cpp +++ b/TAO/tests/Param_Test/fixed_array.cpp @@ -47,7 +47,30 @@ void Test_Fixed_Array::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= Param_Test::Fixed_Array_forany (this->in_); + req->add_inout_arg ("s2") <<= Param_Test::Fixed_Array_forany (this->inout_); + req->add_out_arg ("s3") <<= Param_Test::Fixed_Array_forany (this->out_); + req->set_return_type (Param_Test::_tc_Fixed_Array); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Fixed_Array_forany forany; + req->return_value () >>= forany; + Param_Test::Fixed_Array_copy (this->ret_, forany.in ()); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= forany; + Param_Test::Fixed_Array_copy (this->inout_, forany.in ()); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + Param_Test::Fixed_Array_forany out_any (this->out_); + *arg3->value () >>= forany; + Param_Test::Fixed_Array_copy (this->out_, forany.in ()); } int @@ -107,69 +130,6 @@ Test_Fixed_Array::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Fixed_Array::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // We provide the top level memory - // the Any does not own any of these - CORBA::Any in_arg (Param_Test::_tc_Fixed_Array, - this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Fixed_Array, - this->inout_, - 0); - - CORBA::Any out_arg (Param_Test::_tc_Fixed_Array, - this->out_, - 0); - - // add parameters - param_list->add_value ("l1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("l2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("l3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Fixed_Array, - this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Fixed_Array::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Fixed_Array::check_validity (void) { diff --git a/TAO/tests/Param_Test/fixed_array.h b/TAO/tests/Param_Test/fixed_array.h index 578d320c9b9..51cb8d1753d 100644 --- a/TAO/tests/Param_Test/fixed_array.h +++ b/TAO/tests/Param_Test/fixed_array.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/fixed_struct.cpp b/TAO/tests/Param_Test/fixed_struct.cpp index 3e234de1955..d185f868fe0 100644 --- a/TAO/tests/Param_Test/fixed_struct.cpp +++ b/TAO/tests/Param_Test/fixed_struct.cpp @@ -46,7 +46,29 @@ void Test_Fixed_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + req->set_return_type (Param_Test::_tc_Fixed_Struct); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Fixed_Struct *tmp; + req->return_value () >>= tmp; + this->ret_ = *tmp; + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = *tmp; + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = *tmp; } int @@ -107,69 +129,6 @@ Test_Fixed_Struct::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Fixed_Struct::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // We provide the top level memory - // the Any does not own any of these - CORBA::Any in_arg (Param_Test::_tc_Fixed_Struct, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Fixed_Struct, - &this->inout_, - 0); - - CORBA::Any out_arg (Param_Test::_tc_Fixed_Struct, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value type - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Fixed_Struct, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Fixed_Struct::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Fixed_Struct::check_validity (void) { diff --git a/TAO/tests/Param_Test/fixed_struct.h b/TAO/tests/Param_Test/fixed_struct.h index b4091e90fba..81ec824b4a7 100644 --- a/TAO/tests/Param_Test/fixed_struct.h +++ b/TAO/tests/Param_Test/fixed_struct.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/multdim_array.cpp b/TAO/tests/Param_Test/multdim_array.cpp index c90a63531fd..f51c80240a9 100644 --- a/TAO/tests/Param_Test/multdim_array.cpp +++ b/TAO/tests/Param_Test/multdim_array.cpp @@ -49,7 +49,31 @@ void Test_Multdim_Array::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= Param_Test::Multdim_Array_forany (this->in_.inout ()); + req->add_inout_arg ("s2") <<= Param_Test::Multdim_Array_forany (this->inout_.inout ()); + req->add_out_arg ("s3") <<= Param_Test::Multdim_Array_forany (this->out_.inout ()); + + req->set_return_type (Param_Test::_tc_Multdim_Array); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + + Param_Test::Multdim_Array_forany forany; + req->return_value () >>= forany; + Param_Test::Multdim_Array_copy (this->ret_, forany.in ()); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= forany; + Param_Test::Multdim_Array_copy (this->inout_, forany.in ()); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= forany; + Param_Test::Multdim_Array_copy (this->out_, forany.in ()); } int @@ -116,57 +140,14 @@ Test_Multdim_Array::run_sii_test (Param_Test_ptr objref, return (ACE_TRY_ENV.exception () ? -1:0); } -int -Test_Multdim_Array::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - // We provide the top level memory - // the Any does not own any of these - CORBA::Any in_arg (Param_Test::_tc_Multdim_Array, - this->in_.inout (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Multdim_Array, - this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Multdim_Array, - this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("l1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - - param_list->add_value ("l2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - - param_list->add_value ("l3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - - // add return value type - retval->item (0, ACE_TRY_ENV)->value ()->replace (Param_Test::_tc_Multdim_Array, - this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - return 0; -} - CORBA::Boolean Test_Multdim_Array::check_validity (void) { - if (this->compare (this->in_.in (), + if (this->compare (this->in_.in (), this->inout_.in ()) && - this->compare (this->in_.in (), + this->compare (this->in_.in (), this->out_.in ()) && - this->compare (this->in_.in (), + this->compare (this->in_.in (), this->ret_.in ())) return 1; else @@ -225,4 +206,3 @@ Test_Multdim_Array::print (const Param_Test::Multdim_Array_slice *a) } } } - diff --git a/TAO/tests/Param_Test/multdim_array.h b/TAO/tests/Param_Test/multdim_array.h index 9e68775b7bf..2f8afdce885 100644 --- a/TAO/tests/Param_Test/multdim_array.h +++ b/TAO/tests/Param_Test/multdim_array.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/nested_struct.cpp b/TAO/tests/Param_Test/nested_struct.cpp index 5cbf4765aa4..b4560efd053 100644 --- a/TAO/tests/Param_Test/nested_struct.cpp +++ b/TAO/tests/Param_Test/nested_struct.cpp @@ -50,7 +50,29 @@ Test_Nested_Struct::opname (void) const void Test_Nested_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + req->set_return_type (Param_Test::_tc_Nested_Struct); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Nested_Struct *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Nested_Struct (*tmp); + + CORBA::NamedValue_ptr arg2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *arg2->value () >>= tmp; + this->inout_ = new Param_Test::Nested_Struct (*tmp); + + CORBA::NamedValue_ptr arg3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *arg3->value () >>= tmp; + this->out_ = new Param_Test::Nested_Struct (*tmp); } int @@ -112,67 +134,6 @@ Test_Nested_Struct::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Nested_Struct::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Nested_Struct, - (void *) &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Nested_Struct, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Nested_Struct, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Nested_Struct, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Nested_Struct::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Nested_Struct::check_validity (void) { diff --git a/TAO/tests/Param_Test/nested_struct.h b/TAO/tests/Param_Test/nested_struct.h index 47e6d2a8e43..cbd260906ab 100644 --- a/TAO/tests/Param_Test/nested_struct.h +++ b/TAO/tests/Param_Test/nested_struct.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/objref.cpp b/TAO/tests/Param_Test/objref.cpp index 65b20584a33..63702fdb4da 100644 --- a/TAO/tests/Param_Test/objref.cpp +++ b/TAO/tests/Param_Test/objref.cpp @@ -55,7 +55,30 @@ void Test_ObjRef::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (_tc_Coffee); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Coffee_ptr tmp; + req->return_value () >>= tmp; + this->ret_ = Coffee::_duplicate (tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = Coffee::_duplicate (tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = Coffee::_duplicate (tmp); } static const char *Coffee_Flavor [] = { @@ -182,67 +205,6 @@ Test_ObjRef::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_ObjRef::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (_tc_Coffee, - this->in_courier, - 0); - - CORBA::Any inout_arg (_tc_Coffee, - this->inout_courier, - 0); - - CORBA::Any out_arg (_tc_Coffee, - this->out_courier, - 0); - - // Add parameters. - param_list->add_value ("o1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("o2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("o3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // Add return value. - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (_tc_Coffee, - this->ret_courier, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_ObjRef::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_ObjRef::check_validity (void) { @@ -258,6 +220,11 @@ Test_ObjRef::check_validity (void) ACE_TRY { + if (CORBA::is_nil (this->in_.in ()) + || CORBA::is_nil (this->inout_.in ()) + || CORBA::is_nil (this->out_.in ()) + || CORBA::is_nil (this->ret_.in ())) + return 0; Coffee::Desc_var in_desc = this->in_->description (ACE_TRY_ENV); ACE_TRY_CHECK; @@ -309,15 +276,15 @@ Test_ObjRef::check_validity (CORBA::Request_ptr /*req*/) ACE_TRY { - this->inout_ = Coffee::_narrow (*this->inout_courier, + this->inout_ = Coffee::_narrow (*this->inout_courier, ACE_TRY_ENV); ACE_TRY_CHECK; - this->out_ = Coffee::_narrow (*this->out_courier, + this->out_ = Coffee::_narrow (*this->out_courier, ACE_TRY_ENV); ACE_TRY_CHECK; - this->ret_ = Coffee::_narrow (*this->ret_courier, + this->ret_ = Coffee::_narrow (*this->ret_courier, ACE_TRY_ENV); ACE_TRY_CHECK; diff --git a/TAO/tests/Param_Test/objref.h b/TAO/tests/Param_Test/objref.h index 0798248ab0d..6cdfd531099 100644 --- a/TAO/tests/Param_Test/objref.h +++ b/TAO/tests/Param_Test/objref.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/objref_struct.cpp b/TAO/tests/Param_Test/objref_struct.cpp index c8298fad079..eee5a67d08f 100644 --- a/TAO/tests/Param_Test/objref_struct.cpp +++ b/TAO/tests/Param_Test/objref_struct.cpp @@ -51,12 +51,35 @@ void Test_Objref_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Objref_Struct); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Objref_Struct *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Objref_Struct (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Objref_Struct (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Objref_Struct (*tmp); } int Test_Objref_Struct::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { @@ -71,7 +94,7 @@ Test_Objref_Struct::init_parameters (Param_Test_ptr objref, Coffee::Desc d; d.name = gen->gen_string (); - this->in_.y->description (d, + this->in_.y->description (d, ACE_TRY_ENV); ACE_TRY_CHECK; @@ -122,68 +145,6 @@ Test_Objref_Struct::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Objref_Struct::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Objref_Struct, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Objref_Struct, - &this->inout_.inout (), // .out () causes crash - 0); - - CORBA::Any out_arg (Param_Test::_tc_Objref_Struct, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Objref_Struct, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Objref_Struct::add_args\n"); - - } - ACE_ENDTRY; - return 0; -} - - CORBA::Boolean Test_Objref_Struct::check_validity (void) { @@ -195,7 +156,7 @@ Test_Objref_Struct::check_validity (void) ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY - { + { if (CORBA::is_nil (this->in_.y.in ()) || CORBA::is_nil (this->out_->y.in ()) || CORBA::is_nil (this->ret_->y.in ()) @@ -203,7 +164,7 @@ Test_Objref_Struct::check_validity (void) { return 0; } - + Coffee::Desc_var s_in = this->in_.y->description (ACE_TRY_ENV); ACE_TRY_CHECK; diff --git a/TAO/tests/Param_Test/objref_struct.h b/TAO/tests/Param_Test/objref_struct.h index 3c2f0bed205..5ded88f67c5 100644 --- a/TAO/tests/Param_Test/objref_struct.h +++ b/TAO/tests/Param_Test/objref_struct.h @@ -38,10 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/param_test.idl b/TAO/tests/Param_Test/param_test.idl index ca21de43115..ce69c42eae8 100644 --- a/TAO/tests/Param_Test/param_test.idl +++ b/TAO/tests/Param_Test/param_test.idl @@ -106,8 +106,8 @@ interface Param_Test typedef sequence PathSpec; PathSpec test_unbounded_struct_sequence (in PathSpec s1, - inout PathSpec s2, - out PathSpec s3); + inout PathSpec s2, + out PathSpec s3); typedef sequence Short_Seq; Short_Seq test_short_sequence (in Short_Seq s1, @@ -215,8 +215,8 @@ interface Param_Test Coffee test_objref (in Coffee o1, inout Coffee o2, out Coffee o3); // test typecodes - CORBA::TypeCode test_typecode (in CORBA::TypeCode t1, - inout CORBA::TypeCode t2, + CORBA::TypeCode test_typecode (in CORBA::TypeCode t1, + inout CORBA::TypeCode t2, out CORBA::TypeCode t3); // Anys. We try to pump in all kinds of data types thru these Anys @@ -268,8 +268,8 @@ interface Param_Test exception BadBoy { }; unsigned long test_exception (in unsigned long s1, - inout unsigned long s2, - out unsigned long s3) + inout unsigned long s2, + out unsigned long s3) raises (Ooops); union Big_Union switch (short) @@ -324,8 +324,8 @@ interface Param_Test short level9_short; }; - any test_complex_any (in any ca1, - inout any ca2, + any test_complex_any (in any ca1, + inout any ca2, out any ca3); // Recursive structs. Contains a sequence of itself. diff --git a/TAO/tests/Param_Test/recursive_struct.cpp b/TAO/tests/Param_Test/recursive_struct.cpp index 641975a6281..3f868f8aefb 100644 --- a/TAO/tests/Param_Test/recursive_struct.cpp +++ b/TAO/tests/Param_Test/recursive_struct.cpp @@ -50,7 +50,30 @@ void Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Recursive_Struct); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Recursive_Struct *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Recursive_Struct (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Recursive_Struct (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Recursive_Struct (*tmp); } int @@ -118,68 +141,6 @@ Test_Recursive_Struct::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Recursive_Struct::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Recursive_Struct, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Recursive_Struct, - &this->inout_.inout (), // .out () causes crash - 0); - - CORBA::Any out_arg (Param_Test::_tc_Recursive_Struct, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("rs1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("rs2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("rs3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Recursive_Struct, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Recursive_Struct::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - - CORBA::Boolean Test_Recursive_Struct::check_validity (void) { @@ -233,7 +194,7 @@ Test_Recursive_Struct::deep_init (Param_Test::Recursive_Struct &rs, { rs.x = gen->gen_long (); - if (level == 1) + if (level == 1) // No more recursion. { rs.children.length (0); @@ -262,7 +223,7 @@ CORBA::Boolean Test_Recursive_Struct::deep_check (const Param_Test::Recursive_Struct &in_struct, const Param_Test::Recursive_Struct &test_struct) { - // Do the CORBA::Long members match? + // Do the CORBA::Long members match? if (in_struct.x != test_struct.x) { ACE_DEBUG ((LM_DEBUG, @@ -284,7 +245,7 @@ Test_Recursive_Struct::deep_check (const Param_Test::Recursive_Struct &in_struct // Otherwise recurse. for (CORBA::ULong i = 0; i < in_struct.children.length (); i++) { - if (!this->deep_check (in_struct.children[i], + if (!this->deep_check (in_struct.children[i], test_struct.children[i])) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Param_Test/recursive_struct.h b/TAO/tests/Param_Test/recursive_struct.h index 0ba2ba048e8..cb84b23be28 100644 --- a/TAO/tests/Param_Test/recursive_struct.h +++ b/TAO/tests/Param_Test/recursive_struct.h @@ -39,10 +39,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII const char *opname (void) const; // return operation name @@ -62,7 +58,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/recursive_union.cpp b/TAO/tests/Param_Test/recursive_union.cpp index 991949e697d..bb0310d84ff 100644 --- a/TAO/tests/Param_Test/recursive_union.cpp +++ b/TAO/tests/Param_Test/recursive_union.cpp @@ -50,7 +50,30 @@ void Test_Recursive_Union::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Recursive_Union); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Recursive_Union *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Recursive_Union (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Recursive_Union (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->inout_ = new Param_Test::Recursive_Union (*tmp); } int @@ -76,7 +99,7 @@ Test_Recursive_Union::reset_parameters (void) Generator *gen = GENERATOR::instance (); // Set the depth of recursion. - CORBA::ULong depth = + CORBA::ULong depth = (CORBA::ULong) (gen->gen_long () % MAX_DEPTH) + 1; // Create a nested union to put in inout_. @@ -120,68 +143,6 @@ Test_Recursive_Union::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Recursive_Union::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Recursive_Union, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Recursive_Union, - &this->inout_.inout (), // .out () causes crash - 0); - - CORBA::Any out_arg (Param_Test::_tc_Recursive_Union, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("ru1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ru2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ru3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Recursive_Union, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Recursive_Union::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - - CORBA::Boolean Test_Recursive_Union::check_validity (void) { @@ -233,10 +194,10 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru, Generator *gen, CORBA::ULong level) { - if (level == 1) + if (level == 1) // No more recursion, just insert a nested_rec_union. { - CORBA::ULong nested_depth = + CORBA::ULong nested_depth = (CORBA::ULong) (gen->gen_long () % MAX_DEPTH) + 1; Param_Test::nested_rec_union nru; @@ -256,7 +217,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru, else { // Generate a member sequence. - CORBA::ULong len = + CORBA::ULong len = (CORBA::ULong) (gen->gen_long () % MAX_SEQ_LENGTH) + 1; // This line is TAO-specific, but some compilers we support @@ -321,7 +282,7 @@ CORBA::Boolean Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union, const Param_Test::Recursive_Union &test_union) { - // Do the discriminators match? + // Do the discriminators match? if (in_union._d () != test_union._d ()) { ACE_DEBUG ((LM_DEBUG, @@ -336,7 +297,7 @@ Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union, case 0: { // Do the sequence lengths match? - if (in_union.rec_member ().length () != + if (in_union.rec_member ().length () != test_union.rec_member ().length ()) { ACE_DEBUG ((LM_DEBUG, @@ -347,7 +308,7 @@ Test_Recursive_Union::deep_check (const Param_Test::Recursive_Union &in_union, for (CORBA::ULong i = 0; i < in_union.rec_member ().length (); i++) { - if (!this->deep_check (in_union.rec_member ()[i], + if (!this->deep_check (in_union.rec_member ()[i], test_union.rec_member ()[i])) { ACE_DEBUG ((LM_DEBUG, @@ -390,7 +351,7 @@ Test_Recursive_Union::deep_check_nested (const Param_Test::nested_rec_union &in, switch (in._d ()) { // Active member is the long integer. - case 0: + case 0: // Do the nested_rec_union member values match? if (in.value () != test.value ()) { @@ -417,7 +378,7 @@ Test_Recursive_Union::deep_check_nested (const Param_Test::nested_rec_union &in, for (CORBA::ULong i = 0; i < in.nested_rec_member ().length (); i++) { - if (!this->deep_check_nested (in.nested_rec_member ()[i], + if (!this->deep_check_nested (in.nested_rec_member ()[i], test.nested_rec_member ()[i])) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Param_Test/recursive_union.h b/TAO/tests/Param_Test/recursive_union.h index 0b371d5489b..3dad5de6eaf 100644 --- a/TAO/tests/Param_Test/recursive_union.h +++ b/TAO/tests/Param_Test/recursive_union.h @@ -39,10 +39,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII const char *opname (void) const; // return operation name @@ -62,7 +58,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/short.cpp b/TAO/tests/Param_Test/short.cpp index 704cf53718c..f8d8bd3a5f0 100644 --- a/TAO/tests/Param_Test/short.cpp +++ b/TAO/tests/Param_Test/short.cpp @@ -46,7 +46,26 @@ void Test_Short::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + + req->set_return_type (CORBA::_tc_short); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + req->return_value () >>= this->ret_; + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= this->inout_; + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= this->out_; } int @@ -93,69 +112,6 @@ Test_Short::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Short::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // we provide top level memory to the ORB to retrieve the data - CORBA::Any in_arg (CORBA::_tc_short, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_short, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_short, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value. Let the ORB allocate storage. We simply tell the ORB - // what type we are expecting. - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_short, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Short::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Short::check_validity (void) { diff --git a/TAO/tests/Param_Test/short.h b/TAO/tests/Param_Test/short.h index d512befbc31..285bd3ec428 100644 --- a/TAO/tests/Param_Test/short.h +++ b/TAO/tests/Param_Test/short.h @@ -37,15 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII -/* - int add_args (CORBA::Request_ptr &req, - CORBA::Environment &env); - // add args to DII request using << operator -*/ const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/typecode.cpp b/TAO/tests/Param_Test/typecode.cpp index f4e491f5a99..7c725f46137 100644 --- a/TAO/tests/Param_Test/typecode.cpp +++ b/TAO/tests/Param_Test/typecode.cpp @@ -46,7 +46,30 @@ void Test_TypeCode::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (CORBA::_tc_TypeCode); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::TypeCode_ptr tmp; + req->return_value () >>= tmp; + this->ret_ = CORBA::TypeCode::_duplicate (tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = CORBA::TypeCode::_duplicate (tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = CORBA::TypeCode::_duplicate (tmp); } int @@ -67,8 +90,8 @@ Test_TypeCode::init_parameters (Param_Test_ptr, }; Generator *gen = GENERATOR::instance (); // value generator - CORBA::ULong index = - (CORBA::ULong) (gen->gen_long () % sizeof(tc_table)/sizeof(CORBA::TypeCode_ptr)); + static CORBA::ULong index = 0; + // (CORBA::ULong) (gen->gen_long () % sizeof(tc_table)/sizeof(tc_table[0])); this->tc_holder_ = CORBA::TypeCode::_duplicate (tc_table [index]); this->in_ = this->tc_holder_; @@ -78,6 +101,10 @@ Test_TypeCode::init_parameters (Param_Test_ptr, this->out_ = CORBA::TypeCode::_duplicate (CORBA::_tc_null); this->ret_ = CORBA::TypeCode::_duplicate (CORBA::_tc_null); + index++; + if (index >= sizeof(tc_table)/sizeof(tc_table[0])) + index = 0; + return 0; } @@ -95,6 +122,8 @@ Test_TypeCode::run_sii_test (Param_Test_ptr objref, { ACE_TRY { + this->init_parameters (objref, ACE_TRY_ENV); + CORBA::TypeCode_out out (this->out_); this->ret_ = objref->test_typecode (this->in_.in (), @@ -115,67 +144,6 @@ Test_TypeCode::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_TypeCode::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (CORBA::_tc_TypeCode, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_TypeCode, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_TypeCode, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_TypeCode, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_TypeCode::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_TypeCode::check_validity (void) { @@ -185,15 +153,15 @@ Test_TypeCode::check_validity (void) { CORBA::Boolean one, two, three; - one = this->in_.in ()->equal (this->inout_.in (), + one = this->in_.in ()->equal (this->inout_.in (), ACE_TRY_ENV); ACE_TRY_CHECK; - two = this->in_.in ()->equal (this->out_.in (), + two = this->in_.in ()->equal (this->out_.in (), ACE_TRY_ENV); ACE_TRY_CHECK; - three = this->in_.in ()->equal (this->ret_.in (), + three = this->in_.in ()->equal (this->ret_.in (), ACE_TRY_ENV); ACE_TRY_CHECK; diff --git a/TAO/tests/Param_Test/typecode.h b/TAO/tests/Param_Test/typecode.h index 06933e73d48..cde6cfb1c2a 100644 --- a/TAO/tests/Param_Test/typecode.h +++ b/TAO/tests/Param_Test/typecode.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_any_seq.cpp b/TAO/tests/Param_Test/ub_any_seq.cpp index 3d8f4dcebf6..dd76733f011 100644 --- a/TAO/tests/Param_Test/ub_any_seq.cpp +++ b/TAO/tests/Param_Test/ub_any_seq.cpp @@ -53,7 +53,30 @@ void Test_AnySeq::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_AnySeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::AnySeq* tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::AnySeq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::AnySeq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::AnySeq (*tmp); } int @@ -198,66 +221,6 @@ Test_AnySeq::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_AnySeq::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_AnySeq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_AnySeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_AnySeq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_AnySeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_AnySeq::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_AnySeq::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_any_seq.h b/TAO/tests/Param_Test/ub_any_seq.h index 4d65e04e0d5..832921be5d0 100644 --- a/TAO/tests/Param_Test/ub_any_seq.h +++ b/TAO/tests/Param_Test/ub_any_seq.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_array_seq.cpp b/TAO/tests/Param_Test/ub_array_seq.cpp index 82296fc1fd9..c21ca596b33 100644 --- a/TAO/tests/Param_Test/ub_array_seq.cpp +++ b/TAO/tests/Param_Test/ub_array_seq.cpp @@ -49,7 +49,30 @@ void Test_Array_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_ArraySeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::ArraySeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::ArraySeq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::ArraySeq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::ArraySeq (*tmp); } int @@ -95,7 +118,7 @@ int Test_Array_Sequence::reset_parameters (void) { // Delete the previous ones. - this->inout_ = new Param_Test::ArraySeq; + this->inout_ = new Param_Test::ArraySeq; this->out_ = new Param_Test::ArraySeq; this->ret_ = new Param_Test::ArraySeq; return 0; @@ -127,66 +150,6 @@ Test_Array_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Array_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_ArraySeq, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_ArraySeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_ArraySeq, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_ArraySeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Array_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Array_Sequence::check_validity (void) { @@ -284,5 +247,3 @@ Test_Array_Sequence::print_sequence (const Param_Test::ArraySeq &s) } } } - - diff --git a/TAO/tests/Param_Test/ub_array_seq.h b/TAO/tests/Param_Test/ub_array_seq.h index 1d8b0457136..0f7a0060dbf 100644 --- a/TAO/tests/Param_Test/ub_array_seq.h +++ b/TAO/tests/Param_Test/ub_array_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name @@ -62,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/ub_long_seq.cpp b/TAO/tests/Param_Test/ub_long_seq.cpp index 318e56a6e9e..01ac31fc98b 100644 --- a/TAO/tests/Param_Test/ub_long_seq.cpp +++ b/TAO/tests/Param_Test/ub_long_seq.cpp @@ -50,7 +50,30 @@ void Test_Long_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Long_Seq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Long_Seq *tmp; + req->return_value () >>= tmp; + this->ret_ = Param_Test::Long_Seq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = Param_Test::Long_Seq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = Param_Test::Long_Seq (*tmp); } int @@ -109,66 +132,6 @@ Test_Long_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Long_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Long_Seq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Long_Seq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Long_Seq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Long_Seq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Long_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Long_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_long_seq.h b/TAO/tests/Param_Test/ub_long_seq.h index 1dfab9de0c0..0a57a526d38 100644 --- a/TAO/tests/Param_Test/ub_long_seq.h +++ b/TAO/tests/Param_Test/ub_long_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_objref_seq.cpp b/TAO/tests/Param_Test/ub_objref_seq.cpp index de46b035af2..7c540d19e52 100644 --- a/TAO/tests/Param_Test/ub_objref_seq.cpp +++ b/TAO/tests/Param_Test/ub_objref_seq.cpp @@ -60,7 +60,30 @@ void Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Coffee_Mix); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Coffee_Mix *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Coffee_Mix (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Coffee_Mix (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Coffee_Mix (*tmp); } int @@ -145,66 +168,6 @@ Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_ObjRef_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Coffee_Mix, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Coffee_Mix, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Coffee_Mix, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Coffee_Mix, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Objref_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_ObjRef_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_objref_seq.h b/TAO/tests/Param_Test/ub_objref_seq.h index e660e0aaaf2..b1736c89fd7 100644 --- a/TAO/tests/Param_Test/ub_objref_seq.h +++ b/TAO/tests/Param_Test/ub_objref_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_short_seq.cpp b/TAO/tests/Param_Test/ub_short_seq.cpp index 30c50ed6870..515336bbd94 100644 --- a/TAO/tests/Param_Test/ub_short_seq.cpp +++ b/TAO/tests/Param_Test/ub_short_seq.cpp @@ -50,7 +50,30 @@ void Test_Short_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Short_Seq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Short_Seq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Short_Seq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Short_Seq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Short_Seq (*tmp); } int @@ -111,66 +134,6 @@ Test_Short_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Short_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Short_Seq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Short_Seq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_Short_Seq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Short_Seq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Short_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Short_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_short_seq.h b/TAO/tests/Param_Test/ub_short_seq.h index b9ad0469149..9aa38e21a8e 100644 --- a/TAO/tests/Param_Test/ub_short_seq.h +++ b/TAO/tests/Param_Test/ub_short_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_str_seq.cpp b/TAO/tests/Param_Test/ub_str_seq.cpp index c64107fb3bc..301a40ce27c 100644 --- a/TAO/tests/Param_Test/ub_str_seq.cpp +++ b/TAO/tests/Param_Test/ub_str_seq.cpp @@ -50,7 +50,30 @@ void Test_String_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_StrSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::StrSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::StrSeq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::StrSeq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::StrSeq (*tmp); } int @@ -115,66 +138,6 @@ Test_String_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_String_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_StrSeq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_StrSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_StrSeq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_StrSeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_String_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_String_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_str_seq.h b/TAO/tests/Param_Test/ub_str_seq.h index 97972a1cdec..24f438c84b7 100644 --- a/TAO/tests/Param_Test/ub_str_seq.h +++ b/TAO/tests/Param_Test/ub_str_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_string.cpp b/TAO/tests/Param_Test/ub_string.cpp index ad9e101c020..7227810e0ed 100644 --- a/TAO/tests/Param_Test/ub_string.cpp +++ b/TAO/tests/Param_Test/ub_string.cpp @@ -58,7 +58,30 @@ void Test_Unbounded_String::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + + req->set_return_type (CORBA::_tc_string); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + char *tmp; + req->return_value () >>= tmp; + this->ret_ = CORBA::string_dup (tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = CORBA::string_dup (tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = CORBA::string_dup (tmp); } int @@ -124,66 +147,6 @@ Test_Unbounded_String::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Unbounded_String::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (CORBA::_tc_string, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_string, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_string, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_string, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_String_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Unbounded_String::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_string.h b/TAO/tests/Param_Test/ub_string.h index 7a5ffc45210..f20176a3e98 100644 --- a/TAO/tests/Param_Test/ub_string.h +++ b/TAO/tests/Param_Test/ub_string.h @@ -37,15 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII -/* - int add_args (CORBA::Request_ptr &req, - CORBA::Environment &env); - // add args to DII request using << operator -*/ const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_struct_seq.cpp b/TAO/tests/Param_Test/ub_struct_seq.cpp index 6c25e5863a6..0b6cbc779e7 100644 --- a/TAO/tests/Param_Test/ub_struct_seq.cpp +++ b/TAO/tests/Param_Test/ub_struct_seq.cpp @@ -51,7 +51,30 @@ void Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_StructSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::StructSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::StructSeq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::StructSeq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::StructSeq (*tmp); } int @@ -112,66 +135,6 @@ Test_Struct_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Struct_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_StructSeq, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_StructSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_StructSeq, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_StructSeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Struct_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Struct_Sequence::check_validity (void) { @@ -295,7 +258,30 @@ void Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_PathSpec); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::PathSpec *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::PathSpec (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::PathSpec (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::PathSpec (*tmp); } int @@ -345,47 +331,6 @@ Test_Unbounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref, return 0; } -int -Test_Unbounded_Struct_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - CORBA::Any in_arg (Param_Test::_tc_PathSpec, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_PathSpec, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_PathSpec, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - - // add return value type - retval->item (0, ACE_TRY_ENV)->value ()->replace (Param_Test::_tc_PathSpec, - &this->ret_.inout (), - 0, - ACE_TRY_ENV); - return 0; -} - CORBA::Boolean Test_Unbounded_Struct_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_struct_seq.h b/TAO/tests/Param_Test/ub_struct_seq.h index eeca962f963..465b6b5574d 100644 --- a/TAO/tests/Param_Test/ub_struct_seq.h +++ b/TAO/tests/Param_Test/ub_struct_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name @@ -106,11 +101,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/ub_wstr_seq.cpp b/TAO/tests/Param_Test/ub_wstr_seq.cpp index 51a279263be..d30f7caf3e9 100644 --- a/TAO/tests/Param_Test/ub_wstr_seq.cpp +++ b/TAO/tests/Param_Test/ub_wstr_seq.cpp @@ -50,7 +50,30 @@ void Test_WString_Sequence::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_.in (); + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_WStrSeq); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::WStrSeq *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::WStrSeq (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::WStrSeq (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::WStrSeq (*tmp); } int @@ -117,66 +140,6 @@ Test_WString_Sequence::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_WString_Sequence::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_WStrSeq, - (void *) &this->in_.in (), - 0); - - CORBA::Any inout_arg (Param_Test::_tc_WStrSeq, - &this->inout_.inout (), - 0); - - CORBA::Any out_arg (Param_Test::_tc_WStrSeq, - &this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("ws1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_WStrSeq, - &this->ret_.inout (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_WString_Sequence::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_WString_Sequence::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_wstr_seq.h b/TAO/tests/Param_Test/ub_wstr_seq.h index d91fd0380d2..fee0572fb65 100644 --- a/TAO/tests/Param_Test/ub_wstr_seq.h +++ b/TAO/tests/Param_Test/ub_wstr_seq.h @@ -38,11 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name @@ -62,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/ub_wstring.cpp b/TAO/tests/Param_Test/ub_wstring.cpp index 73b9f6fde18..100a2f9f691 100644 --- a/TAO/tests/Param_Test/ub_wstring.cpp +++ b/TAO/tests/Param_Test/ub_wstring.cpp @@ -58,7 +58,30 @@ void Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + + req->set_return_type (CORBA::_tc_wstring); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::WChar *tmp; + req->return_value () >>= tmp; + this->ret_ = CORBA::wstring_dup (tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = CORBA::wstring_dup (tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = CORBA::wstring_dup (tmp); } int @@ -123,68 +146,6 @@ Test_Unbounded_WString::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Unbounded_WString::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // create the parameters - CORBA::Any in_arg (CORBA::_tc_wstring, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_wstring, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_wstring, - &this->out_, - 0); - - // add parameters - param_list->add_value ("ws1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("ws3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_wstring, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Unbounded_WString::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Unbounded_WString::check_validity (void) { diff --git a/TAO/tests/Param_Test/ub_wstring.h b/TAO/tests/Param_Test/ub_wstring.h index 7b7c37d27a0..e2509254885 100644 --- a/TAO/tests/Param_Test/ub_wstring.h +++ b/TAO/tests/Param_Test/ub_wstring.h @@ -37,15 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII -/* - int add_args (CORBA::Request_ptr &req, - CORBA::Environment &env); - // add args to DII request using << operator -*/ const char *opname (void) const; // return operation name @@ -65,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, + void dii_req_invoke (CORBA::Request *, CORBA::Environment &); // invoke DII request with appropriate exception handling. diff --git a/TAO/tests/Param_Test/ulonglong.cpp b/TAO/tests/Param_Test/ulonglong.cpp index ae767374b25..9d3dad8b76e 100644 --- a/TAO/tests/Param_Test/ulonglong.cpp +++ b/TAO/tests/Param_Test/ulonglong.cpp @@ -42,7 +42,26 @@ void Test_ULongLong::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_; + req->add_out_arg ("s3") <<= this->out_; + + req->set_return_type (CORBA::_tc_ulonglong); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + req->return_value () >>= this->ret_; + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= this->inout_; + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= this->out_; } int @@ -90,69 +109,6 @@ Test_ULongLong::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_ULongLong::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - // we provide top level memory to the ORB to retrieve the data - CORBA::Any in_arg (CORBA::_tc_ulonglong, - &this->in_, - 0); - - CORBA::Any inout_arg (CORBA::_tc_ulonglong, - &this->inout_, - 0); - - CORBA::Any out_arg (CORBA::_tc_ulonglong, - &this->out_, - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value. Let the ORB allocate storage. We simply tell the ORB - // what type we are expecting. - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (CORBA::_tc_ulonglong, - &this->ret_, - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_ULongLong::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_ULongLong::check_validity (void) { diff --git a/TAO/tests/Param_Test/ulonglong.h b/TAO/tests/Param_Test/ulonglong.h index 2b27a929b0f..452f9721aa6 100644 --- a/TAO/tests/Param_Test/ulonglong.h +++ b/TAO/tests/Param_Test/ulonglong.h @@ -34,10 +34,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/var_array.cpp b/TAO/tests/Param_Test/var_array.cpp index 235659d0e85..ea7a29e70f9 100644 --- a/TAO/tests/Param_Test/var_array.cpp +++ b/TAO/tests/Param_Test/var_array.cpp @@ -48,7 +48,31 @@ void Test_Var_Array::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= Param_Test::Var_Array_forany (this->in_); + req->add_inout_arg ("s2") <<= Param_Test::Var_Array_forany (this->inout_); + req->add_out_arg ("s3") <<= Param_Test::Var_Array_forany (this->out_.inout ()); + + req->set_return_type (Param_Test::_tc_Var_Array); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Var_Array_forany forany; + + req->return_value () >>= forany; + this->ret_ = Param_Test::Var_Array_dup (forany.in ()); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= forany; + Param_Test::Var_Array_copy (this->inout_, forany.in ()); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= forany; + this->out_ = Param_Test::Var_Array_dup (forany.in ()); } int @@ -103,66 +127,6 @@ Test_Var_Array::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Var_Array::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Var_Array, - this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Var_Array, - this->inout_, - 0); - - CORBA::Any out_arg (Param_Test::_tc_Var_Array, - this->out_.inout (), // .out () causes crash - 0); - - // add parameters - param_list->add_value ("v1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("v2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("v3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Var_Array, - this->ret_.in (), - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Var_Array::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - CORBA::Boolean Test_Var_Array::check_validity (void) { diff --git a/TAO/tests/Param_Test/var_array.h b/TAO/tests/Param_Test/var_array.h index 64c362f1d61..f281f8dc558 100644 --- a/TAO/tests/Param_Test/var_array.h +++ b/TAO/tests/Param_Test/var_array.h @@ -37,11 +37,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII - const char *opname (void) const; // return operation name diff --git a/TAO/tests/Param_Test/var_struct.cpp b/TAO/tests/Param_Test/var_struct.cpp index 5104f3bcdd1..771b21dfbaa 100644 --- a/TAO/tests/Param_Test/var_struct.cpp +++ b/TAO/tests/Param_Test/var_struct.cpp @@ -51,7 +51,30 @@ void Test_Var_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) { + req->add_in_arg ("s1") <<= this->in_; + req->add_inout_arg ("s2") <<= this->inout_.in (); + req->add_out_arg ("s3") <<= this->out_.in (); + + req->set_return_type (Param_Test::_tc_Var_Struct); + req->invoke (ACE_TRY_ENV); + ACE_CHECK; + + Param_Test::Var_Struct *tmp; + req->return_value () >>= tmp; + this->ret_ = new Param_Test::Var_Struct (*tmp); + + CORBA::NamedValue_ptr o2 = + req->arguments ()->item (1, ACE_TRY_ENV); + ACE_CHECK; + *o2->value () >>= tmp; + this->inout_ = new Param_Test::Var_Struct (*tmp); + + CORBA::NamedValue_ptr o3 = + req->arguments ()->item (2, ACE_TRY_ENV); + ACE_CHECK; + *o3->value () >>= tmp; + this->out_ = new Param_Test::Var_Struct (*tmp); } int @@ -115,68 +138,6 @@ Test_Var_Struct::run_sii_test (Param_Test_ptr objref, return -1; } -int -Test_Var_Struct::add_args (CORBA::NVList_ptr param_list, - CORBA::NVList_ptr retval, - CORBA::Environment &ACE_TRY_ENV) -{ - ACE_TRY - { - CORBA::Any in_arg (Param_Test::_tc_Var_Struct, - &this->in_, - 0); - - CORBA::Any inout_arg (Param_Test::_tc_Var_Struct, - &this->inout_.inout (), // .out () causes crash - 0); - - CORBA::Any out_arg (Param_Test::_tc_Var_Struct, - &this->out_.inout (), - 0); - - // add parameters - param_list->add_value ("s1", - in_arg, - CORBA::ARG_IN, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s2", - inout_arg, - CORBA::ARG_INOUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - param_list->add_value ("s3", - out_arg, - CORBA::ARG_OUT, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - // add return value - CORBA::NamedValue *item = retval->item (0, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - item->value ()->replace (Param_Test::_tc_Var_Struct, - &this->ret_.inout (), // see above - 0, // does not own - ACE_TRY_ENV); - ACE_TRY_CHECK; - - return 0; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Test_Var_Struct::add_args\n"); - - } - ACE_ENDTRY; - return -1; -} - - CORBA::Boolean Test_Var_Struct::check_validity (void) { diff --git a/TAO/tests/Param_Test/var_struct.h b/TAO/tests/Param_Test/var_struct.h index b28e8d59bb8..de08ee37c24 100644 --- a/TAO/tests/Param_Test/var_struct.h +++ b/TAO/tests/Param_Test/var_struct.h @@ -38,10 +38,6 @@ public: CORBA::Environment &env); // run the SII test - int add_args (CORBA::NVList_ptr nvlist, - CORBA::NVList_ptr retval, - CORBA::Environment &env); - // add args to NVList for DII const char *opname (void) const; // return operation name -- cgit v1.2.1