From f8d98275cf4eaae74055d4998dc24aa40501bcb3 Mon Sep 17 00:00:00 2001 From: coryan Date: Thu, 22 Jan 1998 17:27:39 +0000 Subject: ChangeLogTag:Thu Jan 22 10:40:13 1998 Carlos O'Ryan --- TAO/ChangeLog-98c | 5 + TAO/INSTALL | 26 +- TAO/Makefile | 20 +- TAO/TAO_IDL/be/be_attribute.cpp | 48 ++- TAO/TAO_IDL/be/be_operation.cpp | 10 +- TAO/TAO_IDL/be/be_state_attribute.cpp | 5 +- TAO/TAO_IDL/be/be_state_operation.cpp | 6 +- TAO/VERSION | 2 +- TAO/orbsvcs/Event_Service/GPlot_File.cpp | 8 +- TAO/orbsvcs/Event_Service/Makefile | 1 - TAO/orbsvcs/Naming_Service/Naming_Service.cpp | 2 +- TAO/orbsvcs/orbsvcs/AVStreams.idl | 29 +- TAO/orbsvcs/orbsvcs/Makefile | 1 + TAO/orbsvcs/tests/Simple_Naming/clnt.cpp | 16 +- TAO/performance-tests/Cubit/TAO/MT_Cubit/Makefile | 11 +- TAO/performance-tests/Cubit/TAO/MT_Cubit/README | 5 +- .../Cubit/TAO/MT_Cubit/client.cpp | 10 +- .../Cubit/TAO/MT_Cubit/server.cpp | 9 +- TAO/tao/corbacom.h | 6 +- TAO/tao/decode.cpp | 9 +- TAO/tao/default_server.cpp | 48 --- TAO/tao/default_server.h | 10 +- TAO/tao/encode.cpp | 14 +- TAO/tao/giop.cpp | 23 +- TAO/tao/giop.h | 9 +- TAO/tao/interp.cpp | 6 +- TAO/tao/nvlist.h | 2 +- TAO/tao/nvlist.i | 4 +- TAO/tao/sequence.cpp | 57 +-- TAO/tao/sequence.h | 11 +- TAO/tao/sequence.i | 18 +- TAO/tao/sequence_T.cpp | 440 ++++++++++++++------- TAO/tao/sequence_T.i | 72 +++- TAO/tao/servant_base.cpp | 2 + TAO/tests/Cubit/TAO/IDL_Cubit/Makefile | 6 +- TAO/tests/Cubit/TAO/IDL_Cubit/README | 4 +- TAO/tests/Cubit/TAO/IDL_Cubit/clnt.cpp | 5 +- TAO/tests/Cubit/TAO/MT_Cubit/Makefile | 11 +- TAO/tests/Cubit/TAO/MT_Cubit/README | 5 +- TAO/tests/Cubit/TAO/MT_Cubit/client.cpp | 10 +- TAO/tests/Cubit/TAO/MT_Cubit/server.cpp | 9 +- 41 files changed, 628 insertions(+), 367 deletions(-) diff --git a/TAO/ChangeLog-98c b/TAO/ChangeLog-98c index 34d4c90b850..b372ab0a593 100644 --- a/TAO/ChangeLog-98c +++ b/TAO/ChangeLog-98c @@ -1,3 +1,8 @@ +Thu Jan 22 10:40:13 1998 Carlos O'Ryan + + * Merged changes from main_to_poa_merge_10 up to + main_to_poa_merge_11 + Wed Jan 21 00:31:40 1998 Irfan Pyarali * tao/servant_base.cpp (_default_POA): Changed to use diff --git a/TAO/INSTALL b/TAO/INSTALL index 649909c5961..d5f5c52e9bf 100644 --- a/TAO/INSTALL +++ b/TAO/INSTALL @@ -1,6 +1,6 @@ _________________________________________________________________ - + Building and Installing TAO TAO has been ported and tested Windows NT, Solaris, VxWorks, and @@ -17,9 +17,8 @@ linking TAO with a version of ACE that must also be linked against another ORB vendor's library, e.g., liborbix.so, will produce undefined and most likely unpredictable and erroneous results. - _________________________________________________________________ - + On UNIX platforms 1. Set ACE_ROOT environment variable as outlined in the [5]ACE @@ -33,16 +32,16 @@ 6. Follow instructions on executing the various examples under $TAO_ROOT/tests. - _A Note On Make_ + A Note On Make Since TAO is built atop ACE, TAO re-uses ACE's Makefile structure as well. Thus, just like ACE requires GNU Make, so too does TAO. More - exactly, versions of make which are known to _not_ work include those + exactly, versions of make which are known to not work include those from Solaris 4.x and 5.x, HP-UX, the latest BSD, etc. GNU Make can be obtained from various places in source form. _________________________________________________________________ - + On Windows NT Before compiling TAO_IDL on NT, you may need to set the environment @@ -62,9 +61,7 @@ 1. Make sure ACE is built (For Visual C++ 5.0, use ace.dsw or ace-vc50.dsw, whichever is in your copy of ACE). - 2. Load the workspace tao\TAO.dsw and build the TAO library. - 3. To build the Cubit test, load the workspace tests\Cubit\TAO\test.dsw and build both client and server. @@ -77,19 +74,18 @@ 2. Load the project file tao\TAO.mdp and build the TAO library. 3. To build the Cubit test, load the project file tests\Cubit\TAO\test.mdp and build both client and server. - _________________________________________________________________ - + Back to the [9]TAO home page. References - 1. file://localhost/.automount/tango/root/export2/project/doc/chris/ACE_wrappers/TAO/TAO-obtain.html + 1. file://localhost/project/adaptive/ACE_wrappers/TAO/TAO-obtain.html 2. http://siesta.cs.wustl.edu/~schmidt/TAO-obtain.html 3. http://siesta.cs.wustl.edu/~schmidt/ACE-obtain.html 4. http://www.cs.wustl.edu/~schmidt/ACE_wrappers/ACE.tar.gz - 5. file://localhost/.automount/tango/root/export2/project/doc/chris/ACE_wrappers/ACE-INSTALL.html - 6. file://localhost/.automount/tango/root/export2/project/doc/chris/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes - 7. file://localhost/.automount/tango/root/export2/project/doc/chris/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes - 8. file://localhost/.automount/tango/root/export2/project/doc/chris/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes + 5. http://www.cs.wustl.edu/~schmidt/ACE-INSTALL.html + 6. file://localhost/project/adaptive/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes + 7. file://localhost/project/adaptive/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes + 8. file://localhost/project/adaptive/ACE_wrappers/TAO/TAO-INSTALL.html#makenotes 9. http://www.cs.wustl.edu/~schmidt/TAO.html diff --git a/TAO/Makefile b/TAO/Makefile index b17aaf387af..3097eb12799 100644 --- a/TAO/Makefile +++ b/TAO/Makefile @@ -77,27 +77,9 @@ INSTALL: TAO-INSTALL.html ifeq ($(shell pwd),/project/adaptive/ACE_wrappers/TAO) TIMESTAMP = (CHANGELOG='ChangeLog'; export CHANGELOG; \ if [ -z "$$CHANGELOG" ]; then echo unable to find latest ChangeLog file; exit 1; fi; \ - DATE=`/usr/bin/date +"%a %b %d %T %Y"`; export DATE; \ cd ..; UPTODATE=`cvs -nq update $(RELEASE_FILES) | egrep -v '/tests/log/' | perl -pi -e 's%/TAO%%g; s/$$/\\\n /g'`; cd TAO; \ if [ "$$UPTODATE" ]; then /pkg/gnu/bin/echo -e ERROR: workspace must be updated, and/or non-controlled files must be removed or added/committed: $$UPTODATE; exit 1; fi; \ - TAO_VERSION=`perl -pi -e \ - 'BEGIN { $$date=$$ENV{"DATE"} } \ - s/(TAO version \d+\.\d+\.)(\d+)/sprintf("$$1%d",$$2+1)/e; \ - if (s/(, released ).*/$$1$$date./) { \ - ($$version = $$_) =~ s/^This is //; } \ - END { print $$version } ' VERSION;` export TAO_VERSION; \ - perl -i -e \ - 'BEGIN {($$message = \ - $$ENV{"DATE"} . " " . \ - $$ENV{"SIGNATURE"} . " <" . \ - $$ENV{"LOGNAME"} . "\@cs.wustl.edu>\n\n\t* " . \ - $$ENV{"TAO_VERSION"} . "\n"); \ - $$message_printed = 0;} \ - while (<>) { \ - if ( ! $$message_printed++ ) { print "$$message\n"; } \ - print; } ' $$CHANGELOG; \ - cvs commit -m"$$TAO_VERSION" VERSION $$CHANGELOG; \ - chmod 644 VERSION $$CHANGELOG) && + perl release.pl) && else TIMESTAMP = endif diff --git a/TAO/TAO_IDL/be/be_attribute.cpp b/TAO/TAO_IDL/be/be_attribute.cpp index 294a7c4c0b2..28b4ff9c168 100644 --- a/TAO/TAO_IDL/be/be_attribute.cpp +++ b/TAO/TAO_IDL/be/be_attribute.cpp @@ -158,13 +158,24 @@ be_attribute::gen_client_stubs (void) *cs << "{" << bt->tc_name () << ", PARAM_RETURN, "; // Are we returning a pointer to value? i.e., is the type variable? If it is, // we must tell the stub what is the size of the top level structure - if (bt->size_type () == be_decl::VARIABLE) + be_type *prim; + if (bt->node_type () == AST_Decl::NT_typedef) { - switch (bt->node_type ()) + be_typedef *tdef = be_typedef::narrow_from_decl (bt); + prim = tdef->primitive_base_type (); + } + else + prim = bt; + if (prim->size_type () == be_decl::VARIABLE) + { + switch (prim->node_type ()) { case AST_Decl::NT_interface: case AST_Decl::NT_interface_fwd: case AST_Decl::NT_string: + case AST_Decl::NT_sequence: + case AST_Decl::NT_struct: + case AST_Decl::NT_union: // no need of size here *cs << "0}"; break; @@ -264,7 +275,38 @@ be_attribute::gen_client_stubs (void) // call do_call with appropriate number of arguments *cs << "istub->do_call (env, &_get_" << this->flatname () << - "_calldata, &retval);" << nl; + "_calldata"; + + if (bt->node_type () == AST_Decl::NT_typedef) + { + be_typedef *tdef = be_typedef::narrow_from_decl (bt); + prim = tdef->primitive_base_type (); + } + else + prim = bt; + + if (prim->size_type () == be_decl::VARIABLE) + { + switch (prim->node_type ()) + { + case AST_Decl::NT_interface: + case AST_Decl::NT_interface_fwd: + case AST_Decl::NT_string: + *cs << ", &retval"; + break; + case AST_Decl::NT_sequence: + case AST_Decl::NT_struct: + case AST_Decl::NT_union: + *cs << ", retval"; + break; + default: + *cs << ", &retval"; + } + } + else + *cs << ", &retval"; + + *cs << ");" << nl; // return the retval cg->push (TAO_CodeGen::TAO_ATTRIBUTE_RETVAL_RETURN_CS); diff --git a/TAO/TAO_IDL/be/be_operation.cpp b/TAO/TAO_IDL/be/be_operation.cpp index c7339340121..09b84b5612f 100644 --- a/TAO/TAO_IDL/be/be_operation.cpp +++ b/TAO/TAO_IDL/be/be_operation.cpp @@ -212,7 +212,15 @@ be_operation::gen_client_stubs (void) // Are we returning a pointer to value? i.e., is the type // variable? If it is, we must tell the stub what is the size of // the top level structure - if (bt->size_type () == be_decl::VARIABLE) + be_type *prim; + if (bt->node_type () == AST_Decl::NT_typedef) + { + be_typedef *tdef = be_typedef::narrow_from_decl (bt); + prim = tdef->primitive_base_type (); + } + else + prim = bt; + if (prim->size_type () == be_decl::VARIABLE) { switch (bt->node_type ()) { diff --git a/TAO/TAO_IDL/be/be_state_attribute.cpp b/TAO/TAO_IDL/be/be_state_attribute.cpp index 315503929cf..94cf9500bae 100644 --- a/TAO/TAO_IDL/be/be_state_attribute.cpp +++ b/TAO/TAO_IDL/be/be_state_attribute.cpp @@ -930,11 +930,12 @@ be_state_attribute::gen_code (be_type *bt, be_decl *d, be_type *type) { // nothing } - break; + break; break; case TAO_CodeGen::TAO_ATTRIBUTE_RETVAL_DECL_CS: { - *os << bt->name () << " *retval = 0;" << nl; + *os << bt->name () << " *retval = new " << bt->name () << ";" << + nl; } break; case TAO_CodeGen::TAO_ATTRIBUTE_RETVAL_EXCEPTION_CS: diff --git a/TAO/TAO_IDL/be/be_state_operation.cpp b/TAO/TAO_IDL/be/be_state_operation.cpp index b0f25bf33f8..8e0a255232e 100644 --- a/TAO/TAO_IDL/be/be_state_operation.cpp +++ b/TAO/TAO_IDL/be/be_state_operation.cpp @@ -475,7 +475,8 @@ be_state_operation::gen_code (be_type *bt, be_decl *d, be_type *type) break; case TAO_CodeGen::TAO_OPERATION_RETVAL_DECL_CS: { - *os << bt->name () << " *retval = 0;" << nl; + *os << bt->name () << " *retval = new " << bt->name () << ";" << + nl; } break; case TAO_CodeGen::TAO_OPERATION_RETVAL_EXCEPTION_CS: @@ -603,7 +604,8 @@ be_state_operation::gen_code (be_type *bt, be_decl *d, be_type *type) { if (bt->size_type () == be_decl::VARIABLE) { - *os << bt->name () << " *retval;" << nl; + *os << bt->name () << " *retval = new " << bt->name () << ";" + << nl; } else { diff --git a/TAO/VERSION b/TAO/VERSION index b02178fb16e..5342674e9a3 100644 --- a/TAO/VERSION +++ b/TAO/VERSION @@ -1,4 +1,4 @@ -This is TAO version 0.0.53, released Sun Jan 04 17:19:34 1998. +This is TAO version 0.0.54, released Wed Jan 21 20:49:51 1998. If you have any problems with TAO, please send email to Douglas C. Schmidt (schmidt@cs.wustl.edu) and Chris Cleeland diff --git a/TAO/orbsvcs/Event_Service/GPlot_File.cpp b/TAO/orbsvcs/Event_Service/GPlot_File.cpp index 926fc16537d..6967cc932fe 100644 --- a/TAO/orbsvcs/Event_Service/GPlot_File.cpp +++ b/TAO/orbsvcs/Event_Service/GPlot_File.cpp @@ -165,15 +165,15 @@ ACE_GPlot_File::set (long entry, float value) #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) -template class ACE_Map_Entry; +template class ACE_Map_Manager; template class ACE_Map_Iterator_Base; template class ACE_Map_Iterator; template class ACE_Map_Reverse_Iterator; -template class ACE_Map_Manager; +template class ACE_Map_Entry; #elif defined(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -#pragma instantiate ACE_Map_Entry +#pragma instantiate ACE_Map_Manager #pragma instantiate ACE_Map_Iterator_Base #pragma instantiate ACE_Map_Iterator #pragma instantiate ACE_Map_Reverse_Iterator -#pragma instantiate ACE_Map_Manager +#pragma instantiate ACE_Map_Entry #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/orbsvcs/Event_Service/Makefile b/TAO/orbsvcs/Event_Service/Makefile index a1b69ec958b..1cfda509b38 100644 --- a/TAO/orbsvcs/Event_Service/Makefile +++ b/TAO/orbsvcs/Event_Service/Makefile @@ -11,7 +11,6 @@ LSRC = \ CORBA_Utils_T.cpp \ Dispatching_Modules.cpp \ Event_Channel.cpp \ - GPlot_File.cpp \ Local_ESTypes.cpp \ Memory_Pools.cpp \ RT_Task.cpp \ diff --git a/TAO/orbsvcs/Naming_Service/Naming_Service.cpp b/TAO/orbsvcs/Naming_Service/Naming_Service.cpp index 1632fe77168..bffdf3c9fc8 100644 --- a/TAO/orbsvcs/Naming_Service/Naming_Service.cpp +++ b/TAO/orbsvcs/Naming_Service/Naming_Service.cpp @@ -1,7 +1,7 @@ // // $Id$ // -#include +#include "ace/streams.h" #include "CosNaming_i.h" #include "Naming_Service.h" diff --git a/TAO/orbsvcs/orbsvcs/AVStreams.idl b/TAO/orbsvcs/orbsvcs/AVStreams.idl index bd8de25c306..cef01d8a67d 100644 --- a/TAO/orbsvcs/orbsvcs/AVStreams.idl +++ b/TAO/orbsvcs/orbsvcs/AVStreams.idl @@ -1,3 +1,5 @@ +// -*-c++-*- + // $Id$ // IDL for Control and Management of Audio/Video Streams @@ -9,7 +11,7 @@ module AVStreams{ struct QoS{ string QoSType; - PropertyService::Properties QoSParams; + CosPropertyService::Properties QoSParams; }; typedef sequence streamQoS; @@ -46,7 +48,7 @@ module AVStreams{ QoS theQoS; }; - typedef PropertyService::Property streamEvent; + typedef CosPropertyService::Property streamEvent; exception notSupported {}; exception PropertyException {}; @@ -61,7 +63,7 @@ module AVStreams{ exception QoSRequestFailed{ string reason;}; - interface Basic_StreamCtrl : PropertyService::PropertySet { + interface Basic_StreamCtrl : CosPropertyService::PropertySet { // Empty flowSpec => apply operation to all flows void stop(in flowSpec the_spec) raises (noSuchFlow); @@ -124,7 +126,7 @@ module AVStreams{ raises (streamOpFailed); }; - interface MCastConfigIf : PropertyService::PropertySet{ + interface MCastConfigIf : CosPropertyService::PropertySet{ boolean set_peer( in Object peer, @@ -132,10 +134,9 @@ module AVStreams{ in flowSpec the_spec) raises (QoSRequestFailed, streamOpFailed); - void configure(in PropertyService::Property a_configuration); + void configure(in CosPropertyService::Property a_configuration); - void set_initial_configuration( - in PropertyService::Properties initial); + void set_initial_configuration(in CosPropertyService::Properties initial); // Uses standardised by OMG and IETF void set_format(in string flowName, in string format_name) @@ -143,13 +144,13 @@ module AVStreams{ // Note, some of these device params are standardised by OMG void set_dev_params(in string flowName, - in PropertyService::Properties new_params) - raises(PropertyService::PropertyException, + in CosPropertyService::Properties new_params) + raises(CosPropertyService::PropertyException, streamOpFailed); }; - interface StreamEndPoint : PropertyService::PropertySet{ + interface StreamEndPoint : CosPropertyService::PropertySet{ void stop(in flowSpec the_spec) raises (noSuchFlow); void start(in flowSpec the_spec) raises (noSuchFlow); @@ -222,7 +223,7 @@ module AVStreams{ QoSRequestFailed, FPError); }; - interface VDev : PropertyService::PropertySet{ + interface VDev : CosPropertyService::PropertySet{ boolean set_peer( in StreamCtrl the_ctrl, @@ -237,7 +238,7 @@ module AVStreams{ in flowSpec the_spec) raises (noSuchFlow, QoSRequestFailed, streamOpFailed); - void configure(in PropertyService::Property the_config_mesg) + void configure(in CosPropertyService::Property the_config_mesg) raises(PropertyException, streamOpFailed); // Uses standardised by OMG and IETF @@ -246,7 +247,7 @@ module AVStreams{ // Note, some of these device params are standardised by OMG void set_dev_params(in string flowName, - in PropertyService::Properties new_params) + in CosPropertyService::Properties new_params) raises(PropertyException, streamOpFailed); boolean modify_QoS(inout streamQoS the_qos, @@ -255,7 +256,7 @@ module AVStreams{ }; - interface MMDevice : PropertyService::PropertySet { + interface MMDevice : CosPropertyService::PropertySet { StreamEndPoint_A create_A( in StreamCtrl the_requester, out VDev the_vdev, diff --git a/TAO/orbsvcs/orbsvcs/Makefile b/TAO/orbsvcs/orbsvcs/Makefile index 8e954a7b0c4..fb84cd685e6 100644 --- a/TAO/orbsvcs/orbsvcs/Makefile +++ b/TAO/orbsvcs/orbsvcs/Makefile @@ -24,6 +24,7 @@ FILES= $(IDL_FILES) \ Scheduler_Factory \ Runtime_Scheduler \ Scheduler_Utilities \ + TAO_IDL_templates \ DEFS = $(addsuffix .h,$(FILES)) LSRC = $(addsuffix .cpp,$(FILES)) diff --git a/TAO/orbsvcs/tests/Simple_Naming/clnt.cpp b/TAO/orbsvcs/tests/Simple_Naming/clnt.cpp index f657ce240e8..10ecfeefada 100644 --- a/TAO/orbsvcs/tests/Simple_Naming/clnt.cpp +++ b/TAO/orbsvcs/tests/Simple_Naming/clnt.cpp @@ -28,7 +28,7 @@ CosNaming_Client::CosNaming_Client (void) factory_ (CORBA::Object::_nil ()), objref_ (CORBA::Object::_nil ()), CosNaming_ (CosNaming::NamingContext::_nil ()), - cosnaming_factory_key_ ("naming_context") + cosnaming_factory_key_ ("NameService") { } @@ -109,12 +109,12 @@ CosNaming_Client::init (int argc, char **argv) if (this->env_.exception () != 0) { this->env_.print_exception ("ORB initialization"); - return 1; + return -1; } // Parse command line and verify parameters. if (this->parse_args () == -1) - return 1; + return -1; // Retrieve a factory objref. this->objref_ = CosNaming::NamingContext::_bind (this->hostname_, @@ -125,7 +125,7 @@ CosNaming_Client::init (int argc, char **argv) if (this->env_.exception () != 0) { this->env_.print_exception ("CosNaming_Factory::_bind"); - return 1; + return -1; } if (CORBA::is_nil (this->objref_) == CORBA::B_TRUE) @@ -134,7 +134,7 @@ CosNaming_Client::init (int argc, char **argv) this->cosnaming_factory_key_, this->hostname_, this->portnum_), - 1); + -1); // Narrow the CORBA::Object reference to the stub object, checking // the type along the way using _is_a. There is really no need to @@ -148,18 +148,18 @@ CosNaming_Client::init (int argc, char **argv) if (this->CosNaming_ == 0) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to narrow object reference to a CosNaming_ptr.\n"), - 1); + -1); if (this->env_.exception () != 0) { this->env_.print_exception ("CosNaming::NamingContext::_narrow"); - return 1; + return -1; } if (CORBA::is_nil (this->CosNaming_)) ACE_ERROR_RETURN ((LM_ERROR, "null CosNaming objref returned by factory\n"), - 1); + -1); return 0; } diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Makefile b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Makefile index a516f6b3cfc..7e372e3ba2a 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Makefile +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Makefile @@ -12,12 +12,17 @@ LDLIBS = -lTAO IDL_SRC = cubitC.cpp cubitS.cpp -PROG_SRCS = server.cpp cubit_i.cpp Task_Client.cpp client.cpp Util_Thread.cpp +PROG_SRCS = server.cpp \ + cubit_i.cpp \ + Task_Client.cpp \ + client.cpp \ + Util_Thread.cpp \ + tmplinst.cpp LSRC = $(IDL_SRC) $(PROG_SRCS) -CUBIT_SVR_OBJS = cubitC.o cubitS.o server.o cubit_i.o -CUBIT_CLIENT_OBJS = cubitC.o Task_Client.o client.o Util_Thread.o +CUBIT_SVR_OBJS = cubitC.o cubitS.o server.o cubit_i.o tmplinst.o +CUBIT_CLIENT_OBJS = cubitC.o Task_Client.o client.o Util_Thread.o tmplinst.o BIN = server client BUILD = $(BIN) diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/README b/TAO/performance-tests/Cubit/TAO/MT_Cubit/README index ecf6fc3a6d1..0027aca76b9 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/README +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/README @@ -12,7 +12,7 @@ the client or open a separate window for the client and server. server: ------- -./svr -p -h -t +./server -p -h -t port_num is the port number at which the server will start the first (and highest priority) servant. Successive servants (with successively @@ -25,7 +25,8 @@ by the client. client: ------- -./client -d -p -h -n -t [-r] +./client -ORBobjrefstyle url -p -h + -d -n -t [-r] is one of the following: diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.cpp index 5d8ba4d0da0..4ec478f6ea9 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.cpp +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.cpp @@ -59,8 +59,15 @@ do_priority_inversion_test (Task_State &ts) // Now activate the high priority client. - + + // @@ The ifdef here is temporarily placed here until + // I figure out how to map NT's thread priorities + // into pthread's priorities. +#if defined (ACE_THR_PRI_FIFO_DEF) priority = ACE_THR_PRI_FIFO_DEF; +#else + priority = ACE_DEFAULT_THREAD_PRIORITY; +#endif if (high_priority_client.activate (THR_BOUND | ACE_SCHED_FIFO, 1, @@ -213,4 +220,5 @@ main (int argc, char *argv []) do_priority_inversion_test (ts); else do_thread_per_rate_test (ts); + return 0; } diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.cpp index d21f6c81194..4158bd5fc2c 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.cpp +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.cpp @@ -168,7 +168,7 @@ Cubit_Task::create_servants () ACE_DEBUG ((LM_DEBUG,"Object Created at: '%ul'", obj)); CORBA::string_free (obj_str); } - + return 0; } // Global options used to configure various parameters. @@ -269,7 +269,14 @@ start_servants () ACE_Sched_Priority priority; + // @@ The ifdef here is temporarily placed here until + // I figure out how to map NT's thread priorities + // into pthread's priorities. +#if defined (ACE_THR_PRI_FIFO_DEF) priority = ACE_THR_PRI_FIFO_DEF; +#else + priority = ACE_DEFAULT_THREAD_PRIORITY; +#endif /* ACE_THR_PRI_FIFO_DEF */ ACE_DEBUG ((LM_DEBUG, "Creating servant with high priority\n")); diff --git a/TAO/tao/corbacom.h b/TAO/tao/corbacom.h index 2a00436af26..ae6d6ce4328 100644 --- a/TAO/tao/corbacom.h +++ b/TAO/tao/corbacom.h @@ -71,6 +71,8 @@ class CORBA_NVList; //typedef class CORBA_NVList *CORBA_NVList_ptr; class CORBA_ORB; +class CORBA_ORB_var; +class CORBA_ORB_out; //typedef class CORBA_ORB *CORBA_ORB_ptr; class CORBA_Object; @@ -451,7 +453,9 @@ public: typedef CORBA_Principal *Principal_ptr; typedef CORBA_ORB ORB; - typedef ORB *ORB_ptr; + typedef CORBA_ORB *ORB_ptr; + typedef CORBA_ORB_var ORB_var; + typedef CORBA_ORB_out ORB_out; typedef CORBA_Request Request; typedef Request *Request_ptr; diff --git a/TAO/tao/decode.cpp b/TAO/tao/decode.cpp index 97bf949b825..eac7514c125 100644 --- a/TAO/tao/decode.cpp +++ b/TAO/tao/decode.cpp @@ -680,6 +680,8 @@ TAO_Marshal_Struct::decode (CORBA::TypeCode_ptr tc, CORBA::TypeCode_ptr param; CORBA::Long size, alignment; + void *start_addr = (void *)data; + // number of fields in the struct int member_count = tc->member_count (env); @@ -699,7 +701,9 @@ TAO_Marshal_Struct::decode (CORBA::TypeCode_ptr tc, alignment = param->alignment (env); if (env.exception () == 0) { - data = ptr_align_binary (data, alignment); + data = (const void *)((ptr_arith_t) ptr_align_binary (data, alignment) + + (ptr_arith_t) ptr_align_binary (start_addr, alignment) - + (ptr_arith_t) start_addr); switch (param->kind_) { case CORBA::tk_null: @@ -958,7 +962,7 @@ TAO_Marshal_String::decode (CORBA::TypeCode_ptr, { // note that the encoded length is 1 more than the length of the string // because it also accounts for the terminating NULL character - + str = (*(char **) data) = CORBA::string_alloc (len - 1); // only allocate the string *after* the length was validated. @@ -1127,6 +1131,7 @@ TAO_Marshal_Sequence::decode (CORBA::TypeCode_ptr tc, { continue_decoding = stream->get_long (*(CORBA::Long *) value); value += size; + } // CORBA::release (tc2); if (continue_decoding == CORBA::B_TRUE) diff --git a/TAO/tao/default_server.cpp b/TAO/tao/default_server.cpp index 71ed06e3e83..c0f86364901 100644 --- a/TAO/tao/default_server.cpp +++ b/TAO/tao/default_server.cpp @@ -13,54 +13,6 @@ #include "tao/default_server.h" #include "tao/orb_core.h" -template -TAO_Reactive_Strategy::TAO_Reactive_Strategy (void) -{} - -template -TAO_Reactive_Strategy::~TAO_Reactive_Strategy (void) -{} - -template int -TAO_Reactive_Strategy::activate_svc_handler (SH *svc_handler, void *arg) -{ - ACE_TRACE ("ACE_Reactive_Strategy::activate_svc_handler"); - - ACE_Reactor *r = TAO_ORB_Core_instance ()->reactor (); - - int result = 0; - - if (r == 0) - result = -1; - - // Register with the Reactor with the appropriate . - else if (r->register_handler (svc_handler, this->mask_) == -1) - result = -1; - - // If the implementation of the reactor uses event associations - else if (r->uses_event_associations ()) - { - // If we don't have non-block on, it won't work with - // WFMO_Reactor - // This maybe too harsh - // if (!ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK)) - // goto failure; - if (svc_handler->open ((void *) this) != -1) - return 0; - else - result = -1; - } - else - // Call up to our parent to do the SVC_HANDLER initialization. - return this->inherited::activate_svc_handler (svc_handler, arg); - - if (result == -1) - svc_handler->close (0); - - return result; -} - - TAO_Default_Server_Strategy_Factory::TAO_Default_Server_Strategy_Factory (void) : thread_flags_ (0), object_table_size_ (TAO_DEFAULT_SERVER_OBJECT_TABLE_SIZE), diff --git a/TAO/tao/default_server.h b/TAO/tao/default_server.h index d9c102568f5..7ac576a9440 100644 --- a/TAO/tao/default_server.h +++ b/TAO/tao/default_server.h @@ -19,15 +19,7 @@ #include "tao/corba.h" -template -class TAO_Reactive_Strategy : public ACE_Reactive_Strategy -{ -public: - TAO_Reactive_Strategy (void); - ~TAO_Reactive_Strategy (void); - - virtual int activate_svc_handler (SH *sh, void *arg); -}; +#include "tao/strategy_T.h" class TAO_Default_Server_Strategy_Factory : public TAO_Server_Strategy_Factory // = TITLE diff --git a/TAO/tao/encode.cpp b/TAO/tao/encode.cpp index 6ea62a79bf1..6d8e8cc98bc 100644 --- a/TAO/tao/encode.cpp +++ b/TAO/tao/encode.cpp @@ -318,6 +318,13 @@ TAO_Marshal_ObjRef::encode (CORBA::TypeCode_ptr, if (CORBA::is_nil (obj)) { + // encode an empty type_id i.e., an empty string + stream->put_ulong (1); + stream->put_char (0); + + // Number of profiles = 0 + stream->put_ulong (0); + return CORBA::TypeCode::TRAVERSE_CONTINUE; } else @@ -404,6 +411,8 @@ TAO_Marshal_Struct::encode (CORBA::TypeCode_ptr tc, CORBA::TypeCode_ptr param; CORBA::Long size, alignment; + void *start_addr = (void *)data; + if (env.exception () == 0) { int member_count = tc->member_count (env); @@ -422,7 +431,10 @@ TAO_Marshal_Struct::encode (CORBA::TypeCode_ptr tc, alignment = param->alignment (env); if (env.exception () == 0) { - data = ptr_align_binary (data, alignment); + data = (const void *) + ((ptr_arith_t) ptr_align_binary (data, alignment) + + (ptr_arith_t) ptr_align_binary (start_addr, alignment) - + (ptr_arith_t) start_addr); switch (param->kind_) { case CORBA::tk_null: diff --git a/TAO/tao/giop.cpp b/TAO/tao/giop.cpp index 2de40dfbe7c..844f943d4db 100644 --- a/TAO/tao/giop.cpp +++ b/TAO/tao/giop.cpp @@ -888,8 +888,6 @@ TAO_GIOP_Invocation::invoke (CORBA::ExceptionList &exceptions, return TAO_GIOP_SYSTEM_EXCEPTION; } - delete [] reply_ctx.buffer; - if (!this->stream_.get_ulong (request_id) || request_id != this->my_request_id_ || !this->stream_.get_ulong (reply_status) @@ -1102,14 +1100,11 @@ CORBA::Boolean TAO_GIOP_LocateRequestHeader::init (CDR &msg, CORBA::Environment &env) { - CORBA::Boolean hdr_status; - - hdr_status = hdr_status && msg.get_ulong (this->request_id); - hdr_status = hdr_status && msg.decode (&TC_opaque, - &this->object_key, - 0, - env); - return hdr_status; + return ( msg.get_ulong (this->request_id) + && msg.decode (&TC_opaque, + &this->object_key, + 0, + env)); } // Initialize the request header from , setting for errors. @@ -1177,11 +1172,15 @@ TAO_GIOP::start_message (TAO_GIOP_MsgType type, CDR &msg) } #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) -template class CORBA_SEQUENCE; +template class TAO_Unbounded_Sequence; +template class TAO_Unbounded_Sequence; +template class TAO_Unbounded_Sequence; template class CORBA_SEQUENCE; template class CORBA_SEQUENCE; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -#pragma instantiate CORBA_SEQUENCE +#pragma instantiate TAO_Unbounded_Sequence +#pragma instantiate TAO_Unbounded_Sequence +#pragma instantiate TAO_Unbounded_Sequence #pragma instantiate CORBA_SEQUENCE #pragma instantiate CORBA_SEQUENCE #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/giop.h b/TAO/tao/giop.h index 99bb59f0cce..2f5510e96c9 100644 --- a/TAO/tao/giop.h +++ b/TAO/tao/giop.h @@ -59,8 +59,7 @@ struct TAO_IOP_Tagged_Profile TAO_opaque profile_data; }; -typedef CORBA_SEQUENCE - TAO_IOP_Tagged_Profile_Sequence; +typedef TAO_Unbounded_Sequence TAO_IOP_Tagged_Profile_Sequence; struct TAO_IOP_IOR // = TITLE @@ -109,8 +108,7 @@ struct TAO_IOP_TaggedComponent TAO_opaque component_data; }; -typedef CORBA_SEQUENCE - TAO_IOP_MultipleComponentProfile; +typedef TAO_Unbounded_Sequence TAO_IOP_MultipleComponentProfile; // namespace TAO_GIOP @@ -180,8 +178,7 @@ struct TAO_GIOP_ServiceContext TAO_opaque context_data; }; -typedef CORBA_SEQUENCE - TAO_GIOP_ServiceContextList; +typedef TAO_Unbounded_Sequence TAO_GIOP_ServiceContextList; extern CORBA::TypeCode TC_ServiceContextList; diff --git a/TAO/tao/interp.cpp b/TAO/tao/interp.cpp index e1d25b20a01..6de1c818566 100644 --- a/TAO/tao/interp.cpp +++ b/TAO/tao/interp.cpp @@ -290,7 +290,8 @@ declare_entry (CORBA::Principal_ptr, tk_Principal); declare_entry (CORBA::Object_ptr, tk_objref); declare_entry (CORBA::String, tk_string); -declare_entry (CORBA::OctetSeq, tk_sequence); +//declare_entry (CORBA::OctetSeq, tk_sequence); +declare_entry (TAO_opaque, tk_sequence); declare_entry (CORBA::LongLong, tk_longlong); declare_entry (CORBA::ULongLong, tk_ulonglong); @@ -326,7 +327,8 @@ __TC_init_table (void) table [CORBA::tk_enum].alignment = sizeof (generic_enum); setup_entry (CORBA::String, tk_string); - setup_entry (CORBA::OctetSeq, tk_sequence); + // setup_entry (CORBA::OctetSeq, tk_sequence); + setup_entry (TAO_opaque, tk_sequence); setup_entry (CORBA::LongLong, tk_longlong); setup_entry (CORBA::ULongLong, tk_ulonglong); diff --git a/TAO/tao/nvlist.h b/TAO/tao/nvlist.h index 00143ce3555..f0c93970a12 100644 --- a/TAO/tao/nvlist.h +++ b/TAO/tao/nvlist.h @@ -31,7 +31,7 @@ class TAO_Export CORBA_NamedValue // the value is packaged as an Any. The flags indicate parameter // mode, and some ownership rules for "top level" memory. public: - TAO_CONST char *name (void) const; + const char *name (void) const; // optional name CORBA::Any_ptr value (void) const; diff --git a/TAO/tao/nvlist.i b/TAO/tao/nvlist.i index b7fc4ea2624..e4b35074884 100644 --- a/TAO/tao/nvlist.i +++ b/TAO/tao/nvlist.i @@ -31,7 +31,7 @@ CORBA_NamedValue::CORBA_NamedValue (void) } // return the name -ACE_INLINE TAO_CONST char* +ACE_INLINE const char* CORBA_NamedValue::name (void) const { return this->name_; @@ -41,7 +41,7 @@ CORBA_NamedValue::name (void) const ACE_INLINE CORBA::Any_ptr CORBA_NamedValue::value (void) const { - return (const CORBA::Any_ptr)&this->any_; + return ACE_const_cast(CORBA::Any_ptr,&this->any_); } // return the flags diff --git a/TAO/tao/sequence.cpp b/TAO/tao/sequence.cpp index 746ec881c06..99d2c2c0c47 100644 --- a/TAO/tao/sequence.cpp +++ b/TAO/tao/sequence.cpp @@ -32,7 +32,7 @@ TAO_String_Manager::operator=(const TAO_String_Manager &rhs) if (this == &rhs) return *this; - if (this->release_) // need to free old one + if (this->release_) { CORBA::string_free (*this->ptr_); *this->ptr_ = CORBA::string_dup (*rhs.ptr_); @@ -55,6 +55,7 @@ TAO_String_Manager::operator= (const char * p) } else { + // @@ TODO find out why was this cast needed. *this->ptr_ = ACE_const_cast(char*,p); } return *this; @@ -71,18 +72,15 @@ TAO_Unbounded_String_Sequence (CORBA::ULong maximum) } TAO_Unbounded_String_Sequence:: -TAO_Unbounded_String_Sequence (const TAO_Unbounded_String_Sequence &seq) - : TAO_Unbounded_Base_Sequence (seq) +TAO_Unbounded_String_Sequence (const TAO_Unbounded_String_Sequence &rhs) + : TAO_Unbounded_Base_Sequence (rhs) { - this->buffer_ = - TAO_Unbounded_String_Sequence::allocbuf (this->maximum_); - - char* *tmp1 = ACE_reinterpret_cast(char* *,this->buffer_); - char* *tmp2 = ACE_reinterpret_cast(char* *,seq.buffer_); - for (CORBA::ULong i = 0; i < seq.length_; ++i) - tmp1 [i] = CORBA::string_dup (tmp2 [i]); + char* *tmp1 = TAO_Unbounded_String_Sequence::allocbuf (this->maximum_); - this->release_ = 1; + char* *tmp2 = ACE_reinterpret_cast(char* *,rhs.buffer_); + for (CORBA::ULong i = 0; i < rhs.length_; ++i) + tmp1[i] = CORBA::string_dup (tmp2[i]); + this->buffer_ = tmp1; } TAO_Unbounded_String_Sequence::~TAO_Unbounded_String_Sequence (void) @@ -92,9 +90,9 @@ TAO_Unbounded_String_Sequence::~TAO_Unbounded_String_Sequence (void) TAO_Unbounded_String_Sequence& TAO_Unbounded_String_Sequence:: -operator= (const TAO_Unbounded_String_Sequence &seq) +operator= (const TAO_Unbounded_String_Sequence &rhs) { - if (this == &seq) + if (this == &rhs) return *this; if (this->release_) @@ -103,24 +101,27 @@ operator= (const TAO_Unbounded_String_Sequence &seq) for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::string_free (tmp[i]); + tmp[i] = 0; } - if (this->maximum_ < seq.maximum_) + if (this->maximum_ < rhs.maximum_) { + // free the older buffer + TAO_Unbounded_String_Sequence::freebuf (tmp); this->buffer_ = - TAO_Unbounded_String_Sequence::allocbuf (seq.maximum_); + TAO_Unbounded_String_Sequence::allocbuf (rhs.maximum_); } } else { this->buffer_ = - TAO_Unbounded_String_Sequence::allocbuf (this->maximum_); + TAO_Unbounded_String_Sequence::allocbuf (rhs.maximum_); } + TAO_Unbounded_Base_Sequence::operator= (rhs); char* *tmp1 = ACE_reinterpret_cast(char* *,this->buffer_); - char* *tmp2 = ACE_reinterpret_cast(char* *,seq.buffer_); - CORBA::ULong i=0; - for (; i < seq.length_; ++i) - tmp1 [i] = CORBA::string_dup (tmp2 [i]); + char* *tmp2 = ACE_reinterpret_cast(char* *,rhs.buffer_); + for (CORBA::ULong i=0; i < rhs.length_; ++i) + tmp1[i] = CORBA::string_dup (tmp2[i]); return *this; } @@ -152,15 +153,13 @@ TAO_Unbounded_String_Sequence::freebuf (char* *buffer) // Mark the length in the first four bytes? For the moment we let // that be. - char* *tmp = ACE_reinterpret_cast (char**,buffer); - delete[] tmp; + delete[] buffer; } void TAO_Unbounded_String_Sequence::_allocate_buffer (CORBA::ULong length) { - char* *tmp; - ACE_NEW (tmp, char* [length]); + char* *tmp = TAO_Unbounded_String_Sequence::allocbuf (length); if (this->buffer_ != 0) { @@ -194,8 +193,9 @@ TAO_Unbounded_String_Sequence::_deallocate_buffer (void) ++i) { CORBA::string_free (tmp[i]); + tmp[i] = 0; } - delete[] tmp; + TAO_Unbounded_String_Sequence::freebuf (tmp); this->buffer_ = 0; } @@ -204,6 +204,9 @@ TAO_Unbounded_String_Sequence::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { char* *tmp = ACE_reinterpret_cast (char**,this->buffer_); - for (CORBA::ULong i = ol; i < nl; ++i) - CORBA::string_free (tmp[i]); + for (CORBA::ULong i = nl; i < ol; ++i) + { + CORBA::string_free (tmp[i]); + tmp[i] = 0; + } } diff --git a/TAO/tao/sequence.h b/TAO/tao/sequence.h index 1437048dad8..c9e78425f93 100644 --- a/TAO/tao/sequence.h +++ b/TAO/tao/sequence.h @@ -61,7 +61,7 @@ protected: TAO_Base_Sequence (CORBA::ULong maximum, CORBA::ULong length, void* buffer, - CORBA::Boolean release = 0); + CORBA::Boolean release = CORBA::B_FALSE); // Constructor with control of ownership. TAO_Base_Sequence (CORBA::ULong maximum, @@ -225,15 +225,14 @@ private: // control memory managment semantics. }; -class TAO_Unbounded_String_Sequence : public TAO_Unbounded_Base_Sequence +class TAO_Export TAO_Unbounded_String_Sequence : public TAO_Unbounded_Base_Sequence { // =TITLE - // Parametric sequence for types that require managers. + // Unbounded sequence of strings. // // =DESCRIPTION - // Some IDL types require that sequences on them have a "manager" - // class, in charge of handling the object lifetime, examples are - // pseudo objects, object references and strings. + // IDL sequences of strings must automatically duplicate and + // release their members based on some global flag. // = SPEC // 16.8 Mapping for Structured Types diff --git a/TAO/tao/sequence.i b/TAO/tao/sequence.i index 9b728b899c5..5a5cb3c3fdb 100644 --- a/TAO/tao/sequence.i +++ b/TAO/tao/sequence.i @@ -43,7 +43,7 @@ TAO_Base_Sequence::TAO_Base_Sequence (CORBA::ULong maximum, : maximum_ (maximum), length_ (0), buffer_ (data), - release_ (1) + release_ (CORBA::B_TRUE) { } @@ -51,19 +51,16 @@ ACE_INLINE TAO_Base_Sequence::TAO_Base_Sequence (const TAO_Base_Sequence &rhs) : maximum_ (rhs.maximum_), length_ (rhs.length_), - release_ (1) + release_ (CORBA::B_TRUE) { } ACE_INLINE TAO_Base_Sequence & TAO_Base_Sequence::operator= (const TAO_Base_Sequence &rhs) { - if (this != &rhs) - { - this->maximum_ = rhs.maximum_; - this->length_ = rhs.length_; - this->release_ = CORBA::B_TRUE; - } + this->maximum_ = rhs.maximum_; + this->length_ = rhs.length_; + this->release_ = CORBA::B_TRUE; return *this; } @@ -111,8 +108,9 @@ TAO_Unbounded_Base_Sequence::length (CORBA::ULong length) { this->_allocate_buffer (length); this->maximum_ = length; + this->release_ = CORBA::B_TRUE; } - else + else if (length < this->length_) { this->_shrink_buffer (length, this->length_); } @@ -157,7 +155,7 @@ TAO_Bounded_Base_Sequence::length (CORBA::ULong length) { return; } - else + else if (length < this->length_) { this->_shrink_buffer (length, this->length_); } diff --git a/TAO/tao/sequence_T.cpp b/TAO/tao/sequence_T.cpp index c37df3a72e4..f12347feaeb 100644 --- a/TAO/tao/sequence_T.cpp +++ b/TAO/tao/sequence_T.cpp @@ -18,32 +18,43 @@ TAO_Unbounded_Sequence:: TAO_Unbounded_Sequence (const TAO_Unbounded_Sequence &rhs) : TAO_Unbounded_Base_Sequence (rhs) { - this->buffer_ = TAO_Unbounded_Sequence::allocbuf (this->maximum_); - T* tmp = ACE_reinterpret_cast(T*,this->buffer_); + T* tmp1 = TAO_Unbounded_Sequence::allocbuf (this->maximum_); + T* tmp2 = ACE_reinterpret_cast(T*, rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = rhs[i]; + tmp1[i] = tmp2[i]; + this->buffer_ = tmp1; } template TAO_Unbounded_Sequence & TAO_Unbounded_Sequence::operator= (const TAO_Unbounded_Sequence &rhs) { - if (this != &rhs) + if (this == &rhs) + return *this; + + if (this->release_) { - if (this->release_) - { - // free the old buffer - T* tmp = ACE_reinterpret_cast(T*,this->buffer_); - TAO_Unbounded_Sequence::freebuf (tmp); - } - - this->TAO_Base_Sequence::operator= (rhs); - this->buffer_ = TAO_Unbounded_Sequence::allocbuf (this->maximum_); - this->release_ = 1; - T* tmp = ACE_reinterpret_cast(T*,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = rhs[i]; + if (this->maximum_ < rhs.maximum_) + { + // free the old buffer + T* tmp = ACE_reinterpret_cast(T*,this->buffer_); + TAO_Unbounded_Sequence::freebuf (tmp); + this->buffer_ = + TAO_Unbounded_Sequence::allocbuf (this->maximum_); + } + } + else + { + this->buffer_ = + TAO_Unbounded_Sequence::allocbuf (rhs.maximum_); } + TAO_Unbounded_Base_Sequence::operator= (rhs); + + T* tmp1 = ACE_reinterpret_cast(T*,this->buffer_); + T* tmp2 = ACE_reinterpret_cast(T*,rhs.buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp1[i] = tmp2[i]; + return *this; } @@ -56,8 +67,7 @@ TAO_Unbounded_Sequence::~TAO_Unbounded_Sequence (void) template void TAO_Unbounded_Sequence::_allocate_buffer (CORBA::ULong length) { - T* tmp; - ACE_NEW (tmp, T[length]); + T* tmp = TAO_Unbounded_Sequence::allocbuf (length); if (this->buffer_ != 0) { @@ -66,7 +76,8 @@ void TAO_Unbounded_Sequence::_allocate_buffer (CORBA::ULong length) { tmp[i] = old[i]; } - delete[] old; + if (this->release_) + delete[] old; } this->buffer_ = tmp; } @@ -77,7 +88,7 @@ void TAO_Unbounded_Sequence::_deallocate_buffer (void) if (this->buffer_ == 0 || this->release_ == 0) return; T* tmp = ACE_reinterpret_cast (T*,this->buffer_); - delete[] tmp; + TAO_Unbounded_Sequence::freebuf (tmp); this->buffer_ = 0; } @@ -90,24 +101,48 @@ TAO_Bounded_Sequence:: TAO_Bounded_Sequence (const TAO_Bounded_Sequence &rhs) : TAO_Bounded_Base_Sequence (rhs) { - this->buffer_ = TAO_Bounded_Sequence::allocbuf (MAX); - T* tmp = ACE_reinterpret_cast(T*,this->buffer_); + T* tmp1 = TAO_Bounded_Sequence::allocbuf (MAX); + + T* tmp2 = ACE_reinterpret_cast(T*,rhs.buffer_); for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = rhs[i]; + tmp1[i] = tmp2[i]; + this->buffer_ = tmp1; } template TAO_Bounded_Sequence & -TAO_Bounded_Sequence::operator= (const TAO_Bounded_Sequence &rhs) +TAO_Bounded_Sequence:: +operator= (const TAO_Bounded_Sequence &rhs) { - if (this != &rhs) + if (this == &rhs) + return *this; + + if (this->release_) { - this->TAO_Base_Sequence::operator= (rhs); - this->buffer_ = TAO_Unbounded_Sequence::allocbuf (this->maximum_); - this->release_ = 1; - T* tmp = ACE_reinterpret_cast(T*,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = seq[i]; +#if 0 + // We never need to reallocate the buffer because they are + // always of size MAX. + if (this->maximum_ < rhs.maximum_) + { + // free the old buffer + T* tmp = ACE_reinterpret_cast(T*,this->buffer_); + TAO_Bounded_Sequence::freebuf (tmp); + this->buffer_ = + TAO_Bounded_Sequence::allocbuf (this->maximum_); + } +#endif /* 0 */ + } + else + { + this->buffer_ = + TAO_Unbounded_Sequence::allocbuf (rhs.maximum_); } + TAO_Bounded_Base_Sequence::operator= (rhs); + + T* tmp1 = ACE_reinterpret_cast(T*,this->buffer_); + T* tmp2 = ACE_reinterpret_cast(T*,rhs.buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp1[i] = tmp2[i]; + return *this; } @@ -122,8 +157,8 @@ void TAO_Bounded_Sequence::_allocate_buffer (CORBA::ULong) { // For this class memory is never reallocated so the implementation // is *really* simple. - ACE_NEW (this->buffer_, T[MAX]); - this->maximum_ = MAX; + this->buffer_ = + TAO_Bounded_Sequence::allocbuf (MAX); } template @@ -132,7 +167,7 @@ void TAO_Bounded_Sequence::_deallocate_buffer (void) if (this->buffer_ == 0 || this->release_ == 0) return; T* tmp = ACE_reinterpret_cast (T*,this->buffer_); - delete[] tmp; + TAO_Bounded_Sequence::freebuf (MAX); this->buffer_ = 0; } @@ -140,19 +175,6 @@ void TAO_Bounded_Sequence::_deallocate_buffer (void) // class TAO_Object_Manager // ************************************************************* -// destructor -template -TAO_Object_Manager::~TAO_Object_Manager (void) -{ -} - -template -TAO_Object_Manager::TAO_Object_Manager (const TAO_Object_Manager &rhs) - : ptr_ (rhs.ptr_), - release_ (rhs.release_) -{ -} - template TAO_Object_Manager& TAO_Object_Manager::operator= (const TAO_Object_Manager &rhs) @@ -167,7 +189,7 @@ TAO_Object_Manager::operator= (const TAO_Object_Manager &rhs) } else { - this->ptr_ = rhs.ptr_; + *this->ptr_ = *rhs.ptr_; } return *this; } @@ -176,9 +198,18 @@ template TAO_Object_Manager & TAO_Object_Manager::operator=(T* p) { - if (this->release_) // need to free old one - CORBA::release (*this->ptr_); - *this->ptr_ = p; // no copy + if (this->release_) + { + // Only release after increasing refcount, otherwise it can fail + // for assignment on the same object. + T* tmp = *this->ptr_; + *this->ptr_ = T::_duplicate (p); + CORBA::release (tmp); + } + else + { + *this->ptr_ = p; + } return *this; } @@ -195,36 +226,18 @@ TAO_Unbounded_Object_Sequence (CORBA::ULong maximum) { } -// copy constructor template TAO_Unbounded_Object_Sequence:: -TAO_Unbounded_Object_Sequence (const TAO_Unbounded_Object_Sequence &seq) - : TAO_Unbounded_Base_Sequence (seq) +TAO_Unbounded_Object_Sequence (const TAO_Unbounded_Object_Sequence &rhs) + : TAO_Unbounded_Base_Sequence (rhs) { - if (this->release_) - { - T* *tmp = ACE_reinterpret_cast(T* *,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - { - CORBA::release (tmp[i]); - } - if (this->maximum_ < seq.maximum_) - { - this->buffer_ = - TAO_Unbounded_Object_Sequence::allocbuf (seq.maximum_); - } - } - else - { - this->buffer_ = - TAO_Unbounded_Object_Sequence::allocbuf (this->maximum_); - } + T* *tmp1 = TAO_Unbounded_Object_Sequence::allocbuf (this->maximum_); - T* *tmp1 = ACE_reinterpret_cast(T* *,this->buffer_); - T* *tmp2 = ACE_reinterpret_cast(T* *,seq.buffer_); - for (CORBA::ULong i=0; i < seq.length_; i++) - tmp1 [i] = T::_duplicate (tmp2 [i]); - this->release_ = 1; + T* *tmp2 = ACE_reinterpret_cast(T* *,rhs.buffer_); + for (CORBA::ULong i = 0; i < rhs.length_; ++i) + tmp1[i] = T::_duplicate (tmp2[i]); + + this->buffer_ = tmp1; } template @@ -237,9 +250,9 @@ TAO_Unbounded_Object_Sequence::~TAO_Unbounded_Object_Sequence (void) template TAO_Unbounded_Object_Sequence& TAO_Unbounded_Object_Sequence:: -operator= (const TAO_Unbounded_Object_Sequence &seq) +operator= (const TAO_Unbounded_Object_Sequence &rhs) { - if (this == &seq) + if (this == &rhs) return *this; if (this->release_) @@ -248,24 +261,27 @@ operator= (const TAO_Unbounded_Object_Sequence &seq) for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::release (tmp[i]); + tmp[i] = T::_nil (); } - if (this->maximum_ < seq.maximum_) + if (this->maximum_ < rhs.maximum_) { + TAO_Unbounded_Object_Sequence::freebuf (tmp); this->buffer_ = - TAO_Unbounded_Object_Sequence::allocbuf (seq.maximum_); + TAO_Unbounded_Object_Sequence::allocbuf (rhs.maximum_); } } else { this->buffer_ = - TAO_Unbounded_Object_Sequence::allocbuf (this->maximum_); + TAO_Unbounded_Object_Sequence::allocbuf (rhs.maximum_); } + TAO_Unbounded_Base_Sequence::operator= (rhs); T* *tmp1 = ACE_reinterpret_cast(T* *,this->buffer_); - T* *tmp2 = ACE_reinterpret_cast(T* *,seq.buffer_); - for (CORBA::ULong i=0; i < seq.length_; i++) - tmp1 [i] = T::_duplicate (tmp2 [i]); - this->release_ = 1; + T* *tmp2 = ACE_reinterpret_cast(T* *,rhs.buffer_); + for (CORBA::ULong i = 0; i < rhs.length_; ++i) + tmp1[i] = T::_duplicate (tmp2[i]); + return *this; } @@ -296,15 +312,13 @@ TAO_Unbounded_Object_Sequence::freebuf (T* *buffer) // Mark the length in the first four bytes? For the moment we let // that be. - T* *tmp = ACE_reinterpret_cast (T**,buffer); - delete[] tmp; + delete[] buffer; } template void TAO_Unbounded_Object_Sequence::_allocate_buffer (CORBA::ULong length) { - T* *tmp; - ACE_NEW (tmp, T* [length]); + T* *tmp = TAO_Unbounded_Object_Sequence::allocbuf (length); if (this->buffer_ != 0) { @@ -317,9 +331,9 @@ void TAO_Unbounded_Object_Sequence::_allocate_buffer (CORBA::ULong length) // no need to copy them, if we did we would also have to // remove the old instances. if (!this->release_) - tmp [i] = T::_duplicate (old[i]); + tmp[i] = T::_duplicate (old[i]); else - tmp [i] = old[i]; + tmp[i] = old[i]; } if (this->release_) delete[] old; @@ -338,8 +352,9 @@ void TAO_Unbounded_Object_Sequence::_deallocate_buffer (void) ++i) { CORBA::release (tmp[i]); + tmp[i] = T::_nil (); } - delete[] tmp; + TAO_Unbounded_Object_Sequence::freebuf (tmp); this->buffer_ = 0; } @@ -348,76 +363,112 @@ TAO_Unbounded_Object_Sequence::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { T* *tmp = ACE_reinterpret_cast (T**,this->buffer_); - for (CORBA::ULong i = ol; i < nl; ++i) - CORBA::release (tmp[i]); + for (CORBA::ULong i = nl; i < ol; ++i) + { + CORBA::release (tmp[i]); + tmp[i] = T::_nil (); + } } // ************************************************************* // Operations for class TAO_Bounded_Object_Sequence // ************************************************************* -template -TAO_Bounded_Object_Sequence::~TAO_Bounded_Object_Sequence (void) +template +TAO_Bounded_Object_Sequence:: +TAO_Bounded_Object_Sequence (void) + : TAO_Bounded_Base_Sequence (MAX, + TAO_Bounded_Sequence::allocbuf(MAX)) { - this->_deallocate_buffer (); } template TAO_Bounded_Object_Sequence:: -TAO_Bounded_Object_Sequence (const TAO_Bounded_Object_Sequence &seq) - : TAO_Bounded_Base_Sequence (seq) +TAO_Bounded_Object_Sequence (const TAO_Bounded_Object_Sequence &rhs) + : TAO_Bounded_Base_Sequence (rhs) { - this->buffer_ = TAO_Bounded_Object_Sequence:: - allocbuf (this->maximum_); - T* *tmp1 = ACE_reinterpret_cast(T* *,this->buffer_); - T* *tmp2 = ACE_reinterpret_cast(T* *,seq.buffer_); - for (CORBA::ULong i=0; i < seq.length_; i++) - tmp1 [i] = T::_duplicate (tmp2 [i]); + T* *tmp1 = + TAO_Bounded_Object_Sequence::allocbuf (MAX); + T* *tmp2 = ACE_reinterpret_cast(T* *,rhs.buffer_); + for (CORBA::ULong i=0; i < rhs.length_; i++) + tmp1[i] = T::_duplicate (tmp2[i]); + this->buffer_ = tmp1; } -// assignment operator template TAO_Bounded_Object_Sequence& TAO_Bounded_Object_Sequence::operator= -(const TAO_Bounded_Object_Sequence &seq) +(const TAO_Bounded_Object_Sequence &rhs) { - if (this == &seq) + if (this == &rhs) return *this; + if (this->release_) { T* *tmp = ACE_reinterpret_cast (T* *,this->buffer_); - TAO_Bounded_Object_Sequence::freebuf (tmp); + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + CORBA::release (tmp[i]); + tmp[i] = T::_nil (); + } + // No need to reallocate the buffer since it is always of size + // MAX +#if 0 + if (this->maximum_ < rhs.maximum_) + { + TAO_Bounded_Object_Sequence::freebuf (tmp); + this->buffer_ = + TAO_Bounded_Object_Sequence::allocbuf (rhs.maximum_); + } +#endif /* 0 */ + } + else + { + this->buffer_ = + TAO_Bounded_Object_Sequence::allocbuf (rhs.maximum_); } + TAO_Bounded_Base_Sequence::operator= (rhs); + T* *tmp1 = ACE_reinterpret_cast(T* *,this->buffer_); - T* *tmp2 = ACE_reinterpret_cast(T* *,seq.buffer_); - for (CORBA::ULong i=0; i < seq.length_; i++) - tmp1 [i] = T::_duplicate (tmp2 [i]); + T* *tmp2 = ACE_reinterpret_cast(T* *,rhs.buffer_); + for (CORBA::ULong i=0; i < rhs.length_; ++i) + tmp1[i] = T::_duplicate (tmp2[i]); return *this; } template T* * -TAO_Bounded_Object_Sequence::allocbuf (CORBA::ULong nelems) +TAO_Bounded_Object_Sequence::allocbuf (CORBA::ULong) { - T* *buf = new T*[nelems]; // allocate from heap - for (CORBA::ULong i=0; i < nelems; i++) + T* *buf = new T*[MAX]; + for (CORBA::ULong i=0; i < MAX; i++) buf[i] = T::_nil (); return buf; } -template void -TAO_Bounded_Object_Sequence::_allocate_buffer (CORBA::ULong length) +template void +TAO_Bounded_Object_Sequence::freebuf (T* *buffer) { - T* *tmp; - ACE_NEW (tmp, T* [length]); - - if (this->buffer_ != 0) + // How much do we deallocate? Easy! allocbuf() always creates MAX + // elements and initialize them to T::_nil(). So we can be + // complaint and call CORBA::release() on each one. + for (CORBA::ULong i = 0; i < MAX; ++i) { - T* *old = ACE_reinterpret_cast(T**,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp [i] = old[i]; - delete[] old; + if (buffer[i] != T::_nil ()) + { + CORBA::release (buffer[i]); + buffer[i] = T::_nil (); + } } - this->buffer_ = tmp; + delete[] buffer; +} + +template void +TAO_Bounded_Object_Sequence::_allocate_buffer (CORBA::ULong length) +{ + // For this class memory is never reallocated so the implementation + // is *really* simple. + this->buffer_ = + TAO_Bounded_Object_Sequence::allocbuf (length); } template @@ -426,9 +477,7 @@ void TAO_Bounded_Object_Sequence::_deallocate_buffer (void) if (this->buffer_ == 0 || this->release_ == 0) return; T* *tmp = ACE_reinterpret_cast (T**,this->buffer_); - // XXXASG: Do we release each object here? - // @@ TODO add static methods to Manager to release each object here. - delete[] tmp; + TAO_Bounded_Object_Sequence::freebuf (MAX); this->buffer_ = 0; } @@ -437,8 +486,133 @@ TAO_Bounded_Object_Sequence::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { T* *tmp = ACE_reinterpret_cast (T**,this->buffer_); - for (CORBA::ULong i = ol; i < nl; ++i) - CORBA::release (tmp[i]); + for (CORBA::ULong i = nl; i < ol; ++i) + { + CORBA::release (tmp[i]); + tmp[i] = T::_nil (); + } +} + +// ************************************************************* +// Operations for class TAO_Bounded_String_Sequence +// ************************************************************* + +template +TAO_Bounded_String_Sequence:: +TAO_Bounded_String_Sequence (void) + : TAO_Bounded_Base_Sequence (MAX, + TAO_Bounded_String_Sequence::allocbuf(MAX)) +{ +} + +template +TAO_Bounded_String_Sequence:: +TAO_Bounded_String_Sequence (const TAO_Bounded_String_Sequence &rhs) + : TAO_Bounded_Base_Sequence (rhs) +{ + char* *tmp1 = + TAO_Bounded_String_Sequence::allocbuf (this->maximum_); + char* *tmp2 = ACE_reinterpret_cast(char* *,rhs.buffer_); + for (CORBA::ULong i=0; i < rhs.length_; i++) + tmp1[i] = CORBA::string_dup (tmp2[i]); + + this->buffer_ = tmp1; +} + +template +TAO_Bounded_String_Sequence& +TAO_Bounded_String_Sequence::operator= +(const TAO_Bounded_String_Sequence &seq) +{ + if (this == &seq) + return *this; + + if (this->release_) + { + char* *tmp = ACE_reinterpret_cast (char* *,this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + CORBA::string_free (tmp[i]); + tmp[i] = 0; + } +#if 0 + if (this->maximum_ < seq.maximum_) + { + TAO_Bounded_String_Sequence::freebuf (tmp); + this->buffer_ = + TAO_Unbounded_String_Sequence::allocbuf (rhs.maximum_); + } +#endif /* 0 */ + } + else + { + this->buffer_ = + TAO_Bounded_String_Sequence::allocbuf (rhs.maximum_); + } + TAO_Bounded_Base_Sequence::operator= (rhs); + + char* *tmp1 = ACE_reinterpret_cast(char* *,this->buffer_); + char* *tmp2 = ACE_reinterpret_cast(char* *,seq.buffer_); + for (CORBA::ULong i=0; i < seq.length_; i++) + tmp1[i] = CORBA::string_dup (tmp2[i]); + return *this; +} + +template char* * +TAO_Bounded_String_Sequence::allocbuf (CORBA::ULong) +{ + char* *buf = new char*[MAX]; + for (CORBA::ULong i = 0; i < MAX; i++) + buf[i] = 0; + return buf; +} + +template void +TAO_Bounded_String_Sequence::freebuf (char* *buffer) +{ + // How much do we deallocate? Easy! allocbuf() always creates MAX + // elements and initialize them to 0 (they say NULL, yuck!). So we + // can be complaint and call CORBA::string_free() on each one. + for (CORBA::ULong i = 0; i < MAX; ++i) + { + if (buffer[i] != 0) + { + CORBA::string_free (buffer[i]); + buffer[i] = 0; + } + } + delete[] buffer; +} + +template void +TAO_Bounded_String_Sequence::_allocate_buffer (CORBA::ULong length) +{ + // For this class memory is never reallocated so the implementation + // is *really* simple. + this->buffer_ = + TAO_Bounded_String_Sequence::allocbuf (MAX); +} + +template +void TAO_Bounded_String_Sequence::_deallocate_buffer (void) +{ + if (this->buffer_ == 0 || this->release_ == 0) + return; + char* *tmp = ACE_reinterpret_cast (char**,this->buffer_); + TAO_Bounded_String_Sequence::freebuf (tmp); + this->buffer_ = 0; +} + +template void +TAO_Bounded_String_Sequence::_shrink_buffer (CORBA::ULong nl, + CORBA::ULong ol) +{ + char* *tmp = ACE_reinterpret_cast (char**,this->buffer_); + for (CORBA::ULong i = nl; i < ol; ++i) + { + CORBA::string_free (tmp[i]); + tmp[i] = 0; + } } #endif /* TAO_SEQUENCE_T_C */ diff --git a/TAO/tao/sequence_T.i b/TAO/tao/sequence_T.i index f65cc2a8401..156e779be26 100644 --- a/TAO/tao/sequence_T.i +++ b/TAO/tao/sequence_T.i @@ -1,5 +1,8 @@ +// This may look like C, but it's really -*- C++ -*- + +// // $Id$ -/* -*- C++ -*- */ +// // ============================================================================ // @@ -66,7 +69,7 @@ TAO_Unbounded_Sequence::allocbuf (CORBA::ULong size) template ACE_INLINE void TAO_Unbounded_Sequence::freebuf (T *buffer) { - delete [] buffer; + delete[] buffer; } // *************************************************** @@ -103,21 +106,33 @@ TAO_Bounded_Sequence::operator[] (CORBA::ULong i) const } template ACE_INLINE T * -TAO_Bounded_Sequence::allocbuf (CORBA::ULong size) +TAO_Bounded_Sequence::allocbuf (CORBA::ULong) { - return new T[size]; + return new T[MAX]; } template ACE_INLINE void TAO_Bounded_Sequence::freebuf (T *buffer) { - delete [] buffer; + delete[] buffer; } // ************************************************************* // Inline operations for class TAO_Object_Manager // ************************************************************* +template ACE_INLINE +TAO_Object_Manager::~TAO_Object_Manager (void) +{ +} + +template ACE_INLINE +TAO_Object_Manager::TAO_Object_Manager (const TAO_Object_Manager &rhs) + : ptr_ (rhs.ptr_), + release_ (rhs.release_) +{ +} + template ACE_INLINE TAO_Object_Manager::TAO_Object_Manager(T** buffer, CORBA::Boolean release) : ptr_ (buffer), @@ -126,7 +141,7 @@ TAO_Object_Manager::TAO_Object_Manager(T** buffer, CORBA::Boolean release) } template ACE_INLINE -TAO_Object_Manager::operator const T* &() const // cast +TAO_Object_Manager::operator const T* () const // cast { return *this->ptr_; } @@ -169,20 +184,17 @@ TAO_Unbounded_Object_Sequence::operator[] (CORBA::ULong index) const // class TAO_Bounded_Object_Sequence // ************************************************************* -template ACE_INLINE void -TAO_Bounded_Object_Sequence::freebuf (T* *seq) +template ACE_INLINE +TAO_Bounded_Object_Sequence::~TAO_Bounded_Object_Sequence (void) { - delete []seq; + this->_deallocate_buffer (); } template ACE_INLINE -TAO_Bounded_Object_Sequence::TAO_Bounded_Object_Sequence (void) -{} - -// constructor from data buffer -template ACE_INLINE -TAO_Bounded_Object_Sequence::TAO_Bounded_Object_Sequence -(CORBA::ULong length, T* *value, CORBA::Boolean release) +TAO_Bounded_Object_Sequence:: +TAO_Bounded_Object_Sequence (CORBA::ULong length, + T* *value, + CORBA::Boolean release) : TAO_Bounded_Base_Sequence (MAX, length, value, release) { } @@ -194,3 +206,31 @@ TAO_Bounded_Object_Sequence::operator[] (CORBA::ULong index) const T* tmp = ACE_reinterpret_cast (T*, this->buffer_); return Manager(tmp + index, this->release_); } + +// ************************************************************* +// class TAO_Bounded_String_Sequence +// ************************************************************* + +template ACE_INLINE +TAO_Bounded_String_Sequence::~TAO_Bounded_String_Sequence (void) +{ + this->_deallocate_buffer (); +} + +template ACE_INLINE +TAO_Bounded_String_Sequence:: +TAO_Bounded_String_Sequence (CORBA::ULong length, + char* *value, + CORBA::Boolean release) + : TAO_Bounded_Base_Sequence (MAX, length, value, release) +{ +} + +template ACE_INLINE TAO_String_Manager +TAO_Bounded_String_Sequence::operator[] (CORBA::ULong index) const +{ + ACE_ASSERT (index < this->maximum_); + char** tmp = ACE_reinterpret_cast (char**, this->buffer_); + return Manager(tmp + index, this->release_); +} + diff --git a/TAO/tao/servant_base.cpp b/TAO/tao/servant_base.cpp index ad360bb1d6b..c9f5266a4dd 100644 --- a/TAO/tao/servant_base.cpp +++ b/TAO/tao/servant_base.cpp @@ -1,6 +1,8 @@ #include "tao/corba.h" TAO_ServantBase::TAO_ServantBase (void) + : optable_ (0), + parent_ (0) { } diff --git a/TAO/tests/Cubit/TAO/IDL_Cubit/Makefile b/TAO/tests/Cubit/TAO/IDL_Cubit/Makefile index 94206e4c707..e77e4f8b56a 100644 --- a/TAO/tests/Cubit/TAO/IDL_Cubit/Makefile +++ b/TAO/tests/Cubit/TAO/IDL_Cubit/Makefile @@ -12,12 +12,12 @@ LDLIBS = -lTAO IDL_SRC = cubitC.cpp cubitS.cpp -PROG_SRCS = $(IDL_SRC) svr.cpp clnt.cpp +PROG_SRCS = $(IDL_SRC) svr.cpp clnt.cpp tmplinst.cpp LSRC = $(PROG_SRCS) -CUBIT_SVR_OBJS = cubitC.o cubitS.o svr.o cubit_i.o -CUBIT_CLT_OBJS = cubitC.o clnt.o +CUBIT_SVR_OBJS = cubitC.o cubitS.o svr.o cubit_i.o tmplinst.o +CUBIT_CLT_OBJS = cubitC.o clnt.o tmplinst.o BIN = svr clnt BUILD = $(BIN) diff --git a/TAO/tests/Cubit/TAO/IDL_Cubit/README b/TAO/tests/Cubit/TAO/IDL_Cubit/README index e24968999ae..3888349a0ef 100644 --- a/TAO/tests/Cubit/TAO/IDL_Cubit/README +++ b/TAO/tests/Cubit/TAO/IDL_Cubit/README @@ -17,7 +17,9 @@ The server cubit factory maintained num_of_cubit objects (default = When the server is started and you have used the -d flag, you should see as the first line of output something that looks like -iiop:1.0//serverhost:10013/factory. + iiop:1.0//serverhost:10013/factory (using -ORBobjrefstyle url) +or + IOR:000000000000001649444c3a43756269745... (using default -ORBobjrefstyle ior) Using -d turns on debugging messages. It is additive, i.e., the more -d options provided, the more debugging you can get. At the moment, diff --git a/TAO/tests/Cubit/TAO/IDL_Cubit/clnt.cpp b/TAO/tests/Cubit/TAO/IDL_Cubit/clnt.cpp index 8c7e12ba713..d96f6d8740e 100644 --- a/TAO/tests/Cubit/TAO/IDL_Cubit/clnt.cpp +++ b/TAO/tests/Cubit/TAO/IDL_Cubit/clnt.cpp @@ -40,7 +40,7 @@ Cubit_Client::Cubit_Client (void) call_count_ (0), error_count_ (0) { - ACE_Env_Value defport(quote(TAO_DEFAULT_SERVER_PORT), + ACE_Env_Value defport(quote(TAO_DEFAULT_SERVER_PORT), TAO_DEFAULT_SERVER_PORT); portnum_ = defport; } @@ -771,7 +771,8 @@ main (int argc, char **argv) #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) template class ACE_Env_Value; +template class ACE_Env_Value; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) #pragma instantiate ACE_Env_Value +#pragma instantiate ACE_Env_Value #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ - diff --git a/TAO/tests/Cubit/TAO/MT_Cubit/Makefile b/TAO/tests/Cubit/TAO/MT_Cubit/Makefile index a516f6b3cfc..7e372e3ba2a 100644 --- a/TAO/tests/Cubit/TAO/MT_Cubit/Makefile +++ b/TAO/tests/Cubit/TAO/MT_Cubit/Makefile @@ -12,12 +12,17 @@ LDLIBS = -lTAO IDL_SRC = cubitC.cpp cubitS.cpp -PROG_SRCS = server.cpp cubit_i.cpp Task_Client.cpp client.cpp Util_Thread.cpp +PROG_SRCS = server.cpp \ + cubit_i.cpp \ + Task_Client.cpp \ + client.cpp \ + Util_Thread.cpp \ + tmplinst.cpp LSRC = $(IDL_SRC) $(PROG_SRCS) -CUBIT_SVR_OBJS = cubitC.o cubitS.o server.o cubit_i.o -CUBIT_CLIENT_OBJS = cubitC.o Task_Client.o client.o Util_Thread.o +CUBIT_SVR_OBJS = cubitC.o cubitS.o server.o cubit_i.o tmplinst.o +CUBIT_CLIENT_OBJS = cubitC.o Task_Client.o client.o Util_Thread.o tmplinst.o BIN = server client BUILD = $(BIN) diff --git a/TAO/tests/Cubit/TAO/MT_Cubit/README b/TAO/tests/Cubit/TAO/MT_Cubit/README index ecf6fc3a6d1..0027aca76b9 100644 --- a/TAO/tests/Cubit/TAO/MT_Cubit/README +++ b/TAO/tests/Cubit/TAO/MT_Cubit/README @@ -12,7 +12,7 @@ the client or open a separate window for the client and server. server: ------- -./svr -p -h -t +./server -p -h -t port_num is the port number at which the server will start the first (and highest priority) servant. Successive servants (with successively @@ -25,7 +25,8 @@ by the client. client: ------- -./client -d -p -h -n -t [-r] +./client -ORBobjrefstyle url -p -h + -d -n -t [-r] is one of the following: diff --git a/TAO/tests/Cubit/TAO/MT_Cubit/client.cpp b/TAO/tests/Cubit/TAO/MT_Cubit/client.cpp index 5d8ba4d0da0..4ec478f6ea9 100644 --- a/TAO/tests/Cubit/TAO/MT_Cubit/client.cpp +++ b/TAO/tests/Cubit/TAO/MT_Cubit/client.cpp @@ -59,8 +59,15 @@ do_priority_inversion_test (Task_State &ts) // Now activate the high priority client. - + + // @@ The ifdef here is temporarily placed here until + // I figure out how to map NT's thread priorities + // into pthread's priorities. +#if defined (ACE_THR_PRI_FIFO_DEF) priority = ACE_THR_PRI_FIFO_DEF; +#else + priority = ACE_DEFAULT_THREAD_PRIORITY; +#endif if (high_priority_client.activate (THR_BOUND | ACE_SCHED_FIFO, 1, @@ -213,4 +220,5 @@ main (int argc, char *argv []) do_priority_inversion_test (ts); else do_thread_per_rate_test (ts); + return 0; } diff --git a/TAO/tests/Cubit/TAO/MT_Cubit/server.cpp b/TAO/tests/Cubit/TAO/MT_Cubit/server.cpp index d21f6c81194..4158bd5fc2c 100644 --- a/TAO/tests/Cubit/TAO/MT_Cubit/server.cpp +++ b/TAO/tests/Cubit/TAO/MT_Cubit/server.cpp @@ -168,7 +168,7 @@ Cubit_Task::create_servants () ACE_DEBUG ((LM_DEBUG,"Object Created at: '%ul'", obj)); CORBA::string_free (obj_str); } - + return 0; } // Global options used to configure various parameters. @@ -269,7 +269,14 @@ start_servants () ACE_Sched_Priority priority; + // @@ The ifdef here is temporarily placed here until + // I figure out how to map NT's thread priorities + // into pthread's priorities. +#if defined (ACE_THR_PRI_FIFO_DEF) priority = ACE_THR_PRI_FIFO_DEF; +#else + priority = ACE_DEFAULT_THREAD_PRIORITY; +#endif /* ACE_THR_PRI_FIFO_DEF */ ACE_DEBUG ((LM_DEBUG, "Creating servant with high priority\n")); -- cgit v1.2.1