Release Notes for OCI's Distribution of TAO 1.4a
Copyright 2000-2007 by Object Computing, Inc.

NOTE:   These release notes can be found in the distribution at ACE_wrappers/OCIReleaseNotes.html.

Table of Contents

  1. General Notes

  2. New Features Since TAO 1.3a

  3. Platforms that this release was tested on:

  4. OCI recommended build flags

General Notes

  1. Heritage -- Relationship to DOC Releases

    TAO 1.4a derives from the DOC TAO 1.4.3 beta kit with bugfix-related patches selectively applied to enhance stability. A record of applied patches can be found in OCIChangeLog files installed with the distribution.

  2. Platforms

    As the initial release of this stable series, the platform set was limited to those described below. Support for additional platforms will be added in subsequent patch levels.

  3. Tests

    The great majority of ACE/TAO tests are passing on the current set of platforms. We will report more detailed test results for the individual platforms in subsequent patch releases.

  4. Make Project Creator

    All of ACE/TAO was built using MakeProjectCreator (MPC). This tool is included with this distribution and may be used for your own projects as well. MPC will generate GNU make files, Windows project files for both VC++ 6 and 7.1, Borland make files, and others. It can be extended to other make systems as well. MPC documentation is available in the distribution at ACE_wrappers/bin/MakeProjectCreator/README or in OCI's TAO Developer's Guide, Version 1.4a, which will be available separately. This chapter can be viewed from in html or downloaded in PDF form.

  5. GNU Make on Unix

    With the exception of Windows operating systems, ACE and TAO were built with GNU Make. While one can use other tools to build applications using ACE & TAO, using GNU Make permits the leveraging of the existing build system distributed with ACE & TAO. Use gmake version 3.80 (or better), as previous versions have caused build problems on Mac OS and AIX.

  6. Compiler restrictions

    Version 1.4a of ACE/TAO, being based on DOC TAO 1.4.3, requires that the compiler be able to support namespace, at least minimally. Any compiler that does not support namespace cannot be used with this version, for example, Sun's 4.2 compiler and Tornado 2.0.

  7. Explicit template instantiation

    Explicit template instantiation is not supported in TAO 1.4a at this time.


New Features

Many important new features and bug fixes have been introduced in TAO 1.4a. They are described briefly here. These and many other features of TAO 1.4a are detailed in OCI's TAO Developer's Guide, Version 1.4a, which will be available separately.

For a detailed description of the motivation for and implementation of a particular change, see the appropriate OCIChangeLog or ChangeLog file in the TAO 1.4a source code distribution, such as ACE_wrappers/OCIChangeLog, ACE_wrappers/TAO/OCIChangeLog, ACE_wrappers/TAO/CIAO/OCIChangeLog, or ACE_wrappers/TAO/DevGuideExamples/ChangeLog. Some ChangeLog entries may include a "ticket" number (e.g., [RT 1234]), to help customers track specific changes they have sponsored.

  1. Features added and bugs/fixes in TAO 1.4a_p26

    • Back-ported fix for bugzilla 3104 to fix RT 14382. This addresses long delays and excessive CPU utilization when an interval timer has to "catch up" to a far-advanced system time.
    • Fixed a problem in the reactor's notification pipe processing where it could short-read the buffer, but still end up trying to dispatch, thus leading to a SEGV when it tries to dereference through an invalid pointer.
  2. Features added and bugs/fixes in TAO 1.4a_p25

    • Initial backporting of support for building for a VxWorks 6.7 target from OCI TAO 1.6a. As a consequence of the backporting, perliminary support for other VxWorks 6.x targets was added. Only VxWorks 6.7 has undergone testing, and it is incomplete. NOTE: At minimum, Service Pack 1 is required for many ACE features to work properly. Under stock 6.7 too many tests simply crash.
    • Support for Sun CC 5.10, fixing Bugzilla #3733.
    • Various fixes/workarounds for Visual Age 8, VxWorks 6.2, HPUX, Sun Studio 1.
    • Fixed a SEGV caused by ACE_Log_Msg where ACE threads inheriting from non-ACE threads.
  3. Features added and bugs/fixes in TAO 1.4a_p24

    • Added support for the upcoming OpenDDS 1.3 release.
    • Fixed DOC bugs 3393 and 3480.
    • Fixed DOC bug 3078.
    • Added global operator< definition for TAO_String_Manager to support string type key comparison in OpenDDS.
    • Made TAO_IDL always compare full path instead of preprocessor generated path to avoid preprocessor dependency. (RT 12461)
    • Fixed memory leaks in the SSLIOP implementation. (DOC bug 3165)
  4. Features added and bugs/fixes in TAO 1.4a_p23

    • Extended the Win32 environment variable handling improvement from p22 to also allow inheriting a large environment block from the spawning (parent) process.
    • Modified the ImR Activator to allow a user-specified maximum number of environment variables passed to the activated server. This is specified with -m, and it was previously hard-coded to 512.
  5. Features added and bugs/fixes in TAO 1.4a_p22

    • Added a method to the ACE_Process class to enable the use of a UNICODE environment when spawning processes on Windows only. This works around a 32Kb environment buffer limit.
    • Modified the ImR Activator to utilize the UNICODE environment when spawning servers.
    • Added support for VxWorks 6.3 and VxWorks 6.4.
    • Added ACE_Stack_Trace class to allow users to obtain a stack trace within their application on supported platforms. A new conversion character, the question mark, was added to ACE_Log_Msg for stack trace logging.
  6. Features added and bugs/fixes in TAO 1.4a_p21

    • Fixed a bug in the AV Streams core that caused problems with multi-stage communications.
    • Added a method to the ACE namespace to get the fully qualified host name.
    • Generated GNU makefiles for statically linked executables will no longer be generated with both -lfoo and libfoo.a in the link line.
  7. Features added and bugs/fixes in TAO 1.4a_p20

    • Fixed send side logic (both synchronous and asynchronous) to honor timeouts. An RTT enabled two-way or one-way invocation could earlier hang indefinately if tcp buffers were flooded.
  8. Features added and bugs/fixes in TAO 1.4a_p19

    • Added fixes for VxWorks 6.2 RTP
    • Multiple Notification Service bug fixes
  9. Features added and bugs/fixes in TAO 1.4a_p18

    • Fixed a hanging issue in persistent Notify Service during disconnection.
    • Fixed bugzilla bug #2548. The OMG spec says that GIOP request messages invoking a no-arg method should not be packed for alignment. However TAO used to align them. This patch fixes the problem.
  10. Features added and bugs/fixes in TAO 1.4a_p17

    • Added a -e option to the ImR_Activator to set the environment buffer length for activated servants.
    • Fixed a bug in the Trading_Service where the introduction of the CORBA::LongLong broke the CORBA::Long support.
    • The TAO_IORManip library now has a filter class that allows users to create new object references based on existing multi-profile object references by filtering out profiles using user defined criteria. The use of -ORBUseSharedProfile 0 is required for this to function.
    • Changed the Notify Event Channel POA to be persistent to allow restarting the Notify_Service on the same host and port to have the same IOR as a previous run.
    • Changed the idl compiler to accept #line pragmas put in by the C preprocessor that have numbers after the file name.
    • ACE/TAO now supports Sun Solaris 10 on Opteron or X86-64 using Sun Studio 11 (SunCC 5.8) in 64-bit mode. Previous versions only supported 32-bit mode (the default for Sun compilers). ACE/TAO does not support Sun Solaris 10 on Opteron or X86-64 using Sun Studio 10 (SunCC 5.7) in 64-bit mode.
    • ACE/TAO running Sun Solaris 10 on x86 (including Opteron or X86-64) will likely require the define "#define ACE_HAS_BROKEN_STATIC_CONSTRUCTION" in the config.h file. The sparc version does not require this define.
    • Enhanced TAO_IDL's support for OpenDDS. This version of TAO is compatible with OpenDDS 1.0. See for details.
  11. Features added and bugs/fixes in TAO 1.4a_p16

    • Corrected bugs related to IPv6, and also related to timer queues.
    • Corrected bugs related to sending/recieving large requests. Improved the ORB robustness in low-memory situations by strenghtening the checks and eliminating possibilities for memory corruption.
    • Added an OCI preamble to the README file describing the support proceedures for OCI distributions of ACE and TAO.
    • Fixed bug inOut_Var_Array_SArgument_T<>::marshal() that did not use correct type to output to CDR stream. This resolved compilation errors when using array of non-primary data type as out parameter.
    • Fixed bug in DynamicAny that did not fully support DynAny from longdouble.
    • Fixed bug in DynamicAny that did not check if member is nil before accessing the member. This resolved access violation when destroying DynAny from a union with no active member.
    • Fixed bug in TAO_DynEnum_i that get_as_string/set_as_string and get_as_ulong/set_as_ulong methods did not strip the alias to find the member information. This resolved the problem when calling these functions for typedef'd enums encapsulated in structs.
    • Fixed bug in TAO_IDL compiler that did not generate the correct key comparison for DDS when the DCPS key is an array.
    • Fixed a bug in the IORTable where it was possible to cause a process crash if it were used before it were open or after it was closed.
    • Added an option, -a, to the RT Event_Service to use the thread-per-consumer dispatching strategy instead of the default dispatching strategy.
    • Added new macro ACE_DEFAULT_ASYNCH_BACKLOG and used it instead of ACE_DEFAULT_BACKLOG in Asynch_Acceptor to resolve problem of the backlog be set to a huge value on Windows.
  12. Features added and bugs/fixes in TAO 1.4a_p15

    • Corrected a minor bug where CORBA::ULongLong and CORBA::LongLong types could not be exported to the CosTrading Service.
  13. Features added and bugs/fixes in TAO 1.4a_p14

    • Fixed RT 8881, a problem in the Notification Service's -UseSeparateDispatchingORB option where nested upcalls still could occur and could create a deadlock. See ChangeLog entry Tue Nov 21 23:55:52 UTC 2006 Chris Cleeland <> for more details.
    • Corrected a bug in the Select/Thread Pool reactor where an ACCESS VIOLATION would occur on Windows due to an event handler not being associated with a file handle passed to the method that removes an evant handler from the set.
    • Added a work-around for bug in SunCC 5.3 where a core dump would result when the destructor of an ACE_Process_Mutex would run.
    • Building ACE and TAO in single-threaded mode with gcc is now supported.
    • Provided a hook to allow users to enable the conversion of a local objext (such as a Smart Proxy) into an IOR.
    • Fixed issues relating to the CosTrading Server library. The constraint language lexer now allow negative floating point values, 64-bit signed and unsigned integers (which can currently be represented as octal or decimal). Also, fixed a bug where negative integers were being stored and compared as unsigned integers which resulted in -3 > 0 evaluating to true.
    • Added support for building ACE as a shared library on VxWorks RTP.
    • Added ace/config-vxworks6.2.overrides.h, which fixes an incorrect type in the WindRiver header files for VxWorks 6.2 RTP and corrects a hang in select() issue on that platform.
    • Fixed IDL-generated code that compiled incorrectly when a valuetype is used in either a bound sequence or in a union.
  14. Features added and bugs/fixes in TAO 1.4a_p13

    • Resolved an interoperability/marshaling bug causing Orbacus client to throw java.lang.OutOfMemoryError instead of the correct CORBA exception provided by the server. The problem occurred when TAO-based server's reply contained an exception (CORBA::MARSHALING, in this particular case but others may have been affected, too)

    • Added support to ACE for Green Hills INTEGRITY 5.0.7.
    • Some embedded platforms, such as INTEGRITY, have a way to use real memory as shared memory, but not in the ways currently provided by ACE, such as MMAP or SYSV shared memory which has a disk backup. Instead, the memory is predefined to the system outside of the C++ source code, in INTEGRITY, through integrate files, used by an integrate step during the build process.

      I've created a wrapper to use the shared memory available on INTEGRITY. It is embodied in a class named "ACE_Fixed_Shared_Memory_Pool" that is used with ACE_Malloc_T just as the MMAP or SV classes would be.

      The shared memory is defined in the integrate files, for example

                      Name                    shm_area
                      Length                  0x1000

      This section can be in the kernel or any other Virtual Address Space (VAS) that is loaded on the system. The "Clear" word insures that the memory is initially zeroed and that fact is used by ACE to know to initialize it on first use.

      Virtual Address Spaces use the shared memory by including this in their integrate files, for example.

                      MapTo                   shm_area
                      First                   0x7000000

      The "First" and "Length" are constants that are used in the application code to map to the shared memory with the new class "ACE_Fixed_Shared_Memory_Pool" as shown below.

      The "First" address is the virtual address in this VAS. It can be different in each VAS and, if it is, then the ACE_PI_Control_Block must be used. But, if "First" is chosen the same in all the VASs using it, then the ACE_Control_Block can be used for efficiency.

      The ACE_Based_Pointer can be used with almost all platforms and it works with the ACE_Fixed_Shared_Memory_Pool as well.

      The ACE_Fixed_Shared_Memory_Pool is used in a program by defining an ACE_Fixed_Shared_Memory_Pool_Option object with the address given in "First" and the size given in "Length". This object is then passed to the ACE_Malloc_T constructor, for example:

        // Create a shared memory pool on INTEGRITY
        const int shr_size = 4096;
        char *shr_pool = (char*) 0x7000000;
        ACE_Fixed_Shared_Memory_Pool_Options myOPT(shr_pool, shr_size);
        ACE_Malloc_T myPool(myFile, 0, &myOPT);

      Notes on example:

      1. The 4096 is the value of "Length"
      2. The 0x7000000 is the value of "First"
      3. myOPT is the option object unique to ACE_Fixed_Shared_Memory_Pool
      4. ACE_FIXED_SHARED_MEMORY_POOL is an ACE macro that relates to ACE_Fixed_Shared_Memory_Pool
      5. The first arg to the ACE_Malloc_T ctor is for compatibility and is mostly ignored. My suggestion would be to set it to the "Name" of the shared memory to help subsequent programmers to see how the code and integrate files are related.
      6. The 0 in the second arg to the ACE_Malloc_T ctor is the name of the lock and is generally ignored.
      7. The third argument to the ACE_Malloc_T ctor is the one that is used by ACE_Fixed_Shared_Memory_Pool and, if not supplied, defaults to addr=0 and length=1MB. The defaults are bad, so be sure to always supply this argument.

    • Enhanced a debug message printed when the connector encounters an error due to a mismatch between QoS policies and a lack of tagged components in the IOR. This message is printed whenever the debug level is greater than zero.
    • Added support for Windows Mobile 5.0 with VC8.
    • Enhanced support for CORBA::LongDouble on platforms that do not have a native 16 byte long double. The CORBA::LongDouble will store native long doubles in the 128-bit IEEE format and will convert to a long double on demand. There will be truncation of precision due to the limits of the native long double.
    • Fixed an issue where setting a policy override on a collocated object resulted in an invalid object reference being returned.
    • Fixed a memory leak where the TAO_Adapter would be leaked in the event that an exception occurred before the adapter was added to the adapter registry.
  15. Features added and bugs/fixes in TAO 1.4a_p12

    • Added support for 64-bit builds in Sun Studio 11 (Sun C++ 5.8), Sun Studio 10 (Sun C++ 5.7) and xlc_r version 6.0.
    • Fixed an issue in the TP_Reactor where a properly handled OS signal could randomly break the reactor event loop. In a TAO application, this resulted in the ORB event loop exiting with an error code.
    • The timed semaphore feature added in p9 is now disabled by default due to the negative performance impact. It must now be manually enabled by defining the ACE_HAS_POSIX_SEM_TIMEOUT_EMULATION macro in $ACE_ROOT/ace/config.h.
    • Corrected build errors that resulted when trying to build the RT Event Service's "Thread per Consumer" dispatching strategy, which was added long ago but got ignored for adding release notes. This strategy is similar to the MT dispatching strategy in that it separates the thread that receives the push() from a supplier from the thread that does the eventual push() to the consumer(s), but it differs from MT in that MT has a pool of threads pulling from a single queue and ultimately potentially servicing every consumer, whereas TPC has a queue for *each* consumer and, thus, a single thread is dedicated to pushing to that consumer. This insures that a badly-behaved consumer CANNOT have an adverse effect on the channel or supplier.
    • Added a means by which an application of the RT Event Service can specify what the RTEC should do if the TAO_EC_Queue fills up. This behavior is encapsulated in a derivation of an ACE_Service_Object, called TAO_EC_Queue_Full_Service_Object. The RTEC looks for a service object of a particular name (default in macro TAO_EC_DEFAULT_QUEUE_FULL_SERVICE_OBJECT_NAME).
    • Several minor issues related to use of IPv6 in IIOP endpoints are cleaned up. These include improvements to the discovery of interface endpoints and the processing of explicit wildcard addresses such as [::] or
    • Fixed a bug in IDL generated code where a union contains a complex data type that can have a default value. When the _default() method is called, it now calls _reset() before setting the value. Previously, if the union value was a complex data type, that memory would be leaked.
    • Fixed a deadlock in the TAO core. This occurred when a client passed back to the server a collocated reference (on the same server) to an object that was initially referenced via corbaloc semantics.
      This showed up in the Naming Service tests where a client initially resolves the root context via corbaloc. A later attempt to point a context back at the root resulted in the deadlock.
  16. Features added and bugs/fixes in TAO 1.4a_p11

    • Using the 'RW' wait strategy can result in leaked file descriptors, leaving sockets in a CLOSE_WAIT state (See bugzilla 2224 for more info). A new client strategy option "-ORBConnectionHandlerCleanup 0|1" has been added to actively detect and close out any connection in a half-closed state. This option requires the ORB to be run, which isn't a problem in servers and mixed clients. Pure clients can either spawn a dedicated ORB thread or occasionally run the orb via orb->run() or orb->perform_work().
    • Added preliminary support for Mac OS X on Intel hardware. Use config-macosx-tiger.h and platform_macosx_tiger.GNU.
    • Fixed bugzilla bug #2604, which is a problem with the Implementation Repository (ImR, ImplRepo) when using PER_CLIENT activation. The symptom of this bug is failed activation. See bugzilla 2604 for details.
    • Fixed an apparent memory corruption error in the Notification Service that was seen only in Visual Studio 2005 (Visual C++ 8.0) builds. The error caused clients to receive a CORBA::UNKNOWN system exception when they called either SupplierAdmin::obtain_notification_push_consumer() or ConsumerAdmin::obtain_notification_push_consumer(). The fix involved moving a call to an internal function within the scope of a guard.
  17. Features added and bugs/fixes in TAO 1.4a_p10

    • In some situations, using the SunCC compiler can cause strange results during static initialization of the ACE_Static_Object_Lock. A work-around for this has been added to ACE and can be enabled by defining the ACE_HAS_BROKEN_STATIC_CONSTRUCTION macro in your config.h.
    • Fixed a bug where collocated objects that were stored in the IOR Table would not be properly initialized.
    • Added a new option (-b) to tao_idl which controls the use of clonable in arguments on oneway calls. Clonable in arguments are only useful to applications using CSD and collocated oneway calls.
    • Added more support for IPv6. This includes TAO/IIOP and also fixing bugs on VxWorks.
    • Fixed a bug where Bidirectional GIOP would fail to function properly on AIX and MacOS X due to a difference in sockaddr_in.sin_len during a comparison done while setting up connections.
    • Fixed a bug where shutdown of an RTCORBA enabled application may have core dumped due to use of already deleted memory.
    • Added TAO optimizations including using array allocated octet sequences when constructing ObjectId's to avoid memory allocations, separating the ref count from the initialization lock on a CORBA::Object to be able to use an ACE_Atomic_Op for reference counting and using a stack allocated ACE_Data_Block during processing a GIOP request to avoid memory allocations.
    • TAO now correctly recognizes and responds to a GIOP CloseConnection message. A verification test, rt8390-GIOP-CloseConnection, accompanies.
    • Fixed a problem where, on Solaris 9 onwards, calling ACE_OS::thr_create(THR_NEW_LWP) more than 215 (65535) times in a process will fail. See changelog entry from "Wed Jun 7 16:13:59 UTC 2006 Chris Cleeland <>" for more information.
    • Fixed dynamic library loading on Mac OS X 10.4 (ace/config-macosx-tiger.h).
    • Made the Upcall_Wrapper::upcall() check if the number of "IN" parameters that client provided for a DII collocation request is the same as the IDL defined. A BAD_PARAM exception is raised when the condition is false. 
  18. Features added and bugs/fixes in TAO 1.4a_p9

    • Added new command line and service configurator option to the Notification Service, -UseSeparateDispatchingORB. Using this option employs a second ORB for dispatching events, thereby avoiding the potential for servicing new requests in the same thread that is dispatching events (sometimes known as "nested upcalls").
    • Added an inline default constructor on TAO_ServerRequest which allows the CSD::FW_Server_Request_Wrapper class to avoid the costly construction of dummy input and output cdr's when cloning the request.
    • Fixed a bug where the use of the -Sa option on tao_idl would cause compilation errors if an idl method contained a reference to an interface.
    • Added performance improvements including, but not limited to, an ACE_Atomic_Op specialization in SPARC assembler, an unrolled implementation of memset when ACE_HAS_SLOW_MEMSET is #defined, removal of a redundant memset() in the union constructor of idl generated code, replacement of thread mutexes in TAO used for reference counts with ACE_Atomic_Op.
    • Fixed bugs in the Service Configurator Lexer where line numbers were not counted correctly and strings were not allowed to contain nested quotes (as the original lexer did).
    • Added support for building ACE and TAO for VxWorks 6.2 in kernel mode.
    • Added emulated support for a timed semaphore acquire() on HP-UX.
    • Fixed a race condition triggered by SSLIOP in which two threads active on the same connection attempted to read from the same socket buffer. The MT_SSLIOP/ test case provokes the problem.
    • Added a new option, -ECDispatchingThreadFlags, to the Real Time Event Service's default factory so that flags used in the creation of dispatching threads can be specified in the service configurator file. Previously, the flags used hard-coded defaults. See TAO/docs/ec_options.html for more information on how to use this option.
    • Added two new options, -CECConsumerOperationTimeout and -CECSupplierOperationTimeout, to the CosEvent_Service's factory. These options extend the reactive control feature to allow the event channel to detect a client (consumer or supplier) that's hung in a remote operation such as push(). See TAO/docs/cec_options.html for more information on how to use these options.
    • Added a new command-line switch -b to the CosEvent_Service executable. This switch enables callbacks upon disconnections. Previously this feature was only available programmatically.
    • Adding IPv6 support to Endpoints, IOR parsers, IIOP and MCAST classes is in work. This feature currently is not fully tested.
    • Added ace/config-macosx-tiger.h and include/makeinclude/platform_macosx_tiger.GNU for (preliminary and untested) Mac OS X 10.4 "tiger".
  19. Features added and bugs/fixes in TAO 1.4a_p8

    • Fixed several memory leaks. Failing to open the default endpoint, shutdown of an ImR-ified server with an -ORBDebugLevel of 1 or higher and extracting multiple times from a CDR into the same CORBA::Any are all situations that would have caused a memory leak.

    • Fixed a bug where a pointer to a PICurrent_Impl was referenced after it had been deleted. This would manifest itself as an access violation during server exit on Windows.

    • Provide better support for builds with native c++ exceptions disabled. Support for non-native c++ exceptions is not complete, but most TAO tests will run successfully. Support for non-native exceptions in the DOC betas is deprecated and will be unsupported in the next release unless a sponsor steps forward.

    • TAO 1.4a now builds with the Borland 5.5.1 compiler.

    • Remove trailing whitespace for const wstring's within the tao_idl compiler, as is done for const string's.

    • The TAO_FixedSeq_Var_T and TAO_VarSeq_Var_T now provide a const [] operator.

    • The Trading Service can now be accessed through a corbaloc as a parameter to the -ORBInitRef option.

    • The -mlongcall option is now automatically added when building for VxWorks with a PPC CPU target.

    • Added support for setting the socket option, SO_KEEPALIVE on IIOP connections. This may be done either through the spec compliant mechanism of using an RT_ORB instance to create a protocol policy using RTCORBA::TCPProtocolProperties with the keep_alive attribute set true or using the TAO specific command line option -ORBKeepalive [0|1].

  20. Features added and bugs/fixes in TAO 1.4a_p7

    • Fixed an order-of-destruction/resource-ownership issue, which was causing a TRAP/SEGV on AIX and had to do with using a mutex that had already been destroyed.

    • This patch provides support for AIX 5.3 using the XL 7.0 compiler.

    • A memory leak dealing with DII string arguments was cleaned up, along with many memory leaks in the TAO_RTScheduling library.

    • The Fault_Notifier will now run properly when linked statically.

    • The TAO_PortableServer library will now compile when Minimum CORBA is enabled.

    • Issuing "gmake clean" will now correctly remove all object files regardless of whether the source file contains a relative path or not.

    • All ACE_SSL_SOCK_Stream objects now set the SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER on the underlying SSL handle. This may help in situations where a retry occurs on a send() where partial data has been sent in the underlying ssl implementation.

    • With this release, we no longer generate SSL related projects. If you need the SSL related projects, you can create a default.features file containing ssl=1 in ACE_wrappers/bin/MakeProjectCreator/config before you run MPC.

    • Previous to patch 7, debug and release builds existing in the same build tree on Windows could create indeterminate crashes when running debug application executables. The dynamically loaded TAO codeset library would always load 'release' regardless of the application's build style. All patch 7 library dynamic loads will now search for the version with the matching build style of the application.

    • The tao_imr tool will now default to the localhost activator on server add/update if an activator was not previously set for that server and a startup command is provided.

    • The Interface Repository will now correctly handle interface inheritance. Previously, sub-interface attributes would not be found in the interface description.

    • For FT applications, the ORB will not reset the profiles upon a communication failure exception when the FT service callback indicate a restart. This fixes bug #2248.

    • Modifications made to compile on HP-UX 11.00 with aCC 3.37. Changes are specific to not-ACE_HAS_STANDARD_CPP_LIBRARY, ACE_LACKS_IOSTREAM_TOTALLY and ACE_LACKS_ACE_IOSTREAM.

    • Added support for the ORBInitInfo_3_1 local interface, which allows Portable Interceptors to be registered along with a list of policies. Support was also added for the PortableInterceptor::ProcessingModePolicy, which can be used when registering server or client request portable interceptors using the ORBInitInfo_3_1 operations. The ProcessingModePolicy is used to identify the request context(s) under which the associated portable interceptor should become involved. There are three choices: LOCAL_AND_REMOTE, LOCAL_ONLY, and REMOTE_ONLY. The term "LOCAL" actually means "collocated". The ORBInitInfo_3_1 local interface and the ProcessingModePolicy are both defined in the CORBA 3.1 draft specification.

    • Fixed a bug in the server request portable interceptors logic that only occurred when dispatching a collocated (thru_poa) request. The operation arguments, accessible by the PI interception point methods, were bogus (never initialized) values. The test located under the TAO/tests/Portable_Interceptors/Collocated/Dynamic directory showed the bogus, uninitialized argument values displayed on the screen. With this fix in place, the test now displays the proper argument values.

    • Fixed a bug in CORBA::Request::send_oneway() for collocated requests. The problem is the server side uses incorrect argument list from client. Note the invoke() and send_deferred() have not been fixed for the collocated requests.

  21. Features added and bugs/fixes in TAO 1.4a_p6

    • Added a new endpoint selection strategy to the TAO_Strategies library. Called the Optimized Connection (OC) Endpoint Selector Strategy, this improves client performance when presented with an IOR containing multiple endpoints, some of which may be non-routable. The OC endpoint selector is loaded via a Service Object, the OC_Strategy_Factory. Dynamically linked applications should use:

        dynamic OC_Endpoint_Selector_Factory Service_Object * TAO_Strategies:_make_TAO_OC_Endpoint_Selector_Factory ()
      This directive takes an optional timeout parameter, -connect_timeout nnnn where nnnn is a number of milliseconds to wait before deciding an endpoint is non-routable.
    • Removed the dependency upon the TAO_Messaging library (and the libraries upon which it depends) for the TAO_CosNaming_Serv and TAO_CosEvent_Serv libraries when CORBA Messaging is disabled. The 'corba_messaging' feature must be disabled (in default.features) in order to take advantage of this footprint reduction modification.

    • A new codeset translator was added to TAO to convert from UTF16 to UCS2. This translator can be dynamically loaded using the service configurator.

      dynamic UTF16_UCS2_Factory Service_Object * UTF16_UCS2:_make_UTF16_UCS2_Factory () static Resource_Factory "-ORBWCharCodesetTranslator UTF16_UCS2_Factory"
    • Fixed the problem where a smart proxy's destructor would not be called. A reference counting mechanism is used to manage the smart proxy objects however the default implementation for _add_ref() and _remove_ref() are no-ops. Having the TAO_Smart_Proxy_Base inherit from TAO_Local_RefCounted_Object provides an implementation for these methods and therefore allows smart proxy objects to be deleted. This also fixes a crash resulting from an _non_existent() function call.

    • Added new IIOP and SSLIOP option reuse_addr to unset socket level option SO_REUSEADDR. On *some* platforms this has the side-effect of disallowing two servers from listening on different interfaces of the same port. This option *should NEVER be normally used* and when used the user should be careful of any platform specific side-effects.

    • Refactored the CSD feature support, supported dynamical loading of TP_Strategy by the Service Configurator and supported optionally turn on or off servant serialization for TP_Strategy.

    • Fixed bugs introduced by the changes of TAO_Tagged_Components::get_component() returns index+1 instead of always return 1 if there is a matched tag.

  22. Features added and bugs/fixes in TAO 1.4a_p5

    • Refactored ACE/TAO wide character support. TAO now requires ACE_HAS_WCHAR to be set.

    • Notification service no longer leaks or crashes events if consumers die.

    • Fixed the problem that different HP-UX 11i variants don't support both PTHREAD_SCOPE_PROCESS and PTHREAD_SCOPE_SYSTEM at the same time.

    • Disabled ACE_RCSID by default. If for some reason you need ACE_RCSID, #define ACE_USE_RCSID to 1 in your config.h.

    • Moved codeset negotiation support out of the core TAO library and placed it in a separate library, TAO_Codeset. This library is dynamically linked in if an application uses the resource factory to explicitly define a native codeset or define codeset translators, and does not supply -ORBNegotiateCodesets 0 to ORB_init. Statically linked must now explicitly link the codeset library and add #include "tao/Codeset/Codeset.h" to a source file in their application in order to use codeset negotiation. a new mpc feature, negotiate_codesets, may be defined in ACE_wrappers/bin/MakeProjectCreator/config/default.features to add TAO_Codeset to an application's link line.

    • Completed Typed Event Channel implementation. Now there is an example for the Typed EC in the DevGuideExamples/EventServices/OMG_TypedEC to show how to use it.

    • Added support for the new Custom Servant Dispatching (CSD) feature. The CSD feature provides user applications with the ability to implement and "plug-in" custom strategies to handle the dispatching of requests to servants.

      A concrete CSD Strategy implementation has also been added to serve as a "reference implementation".  This is being called the CSD Thread Pool Strategy (TP_Strategy).  The TP_Strategy provides a means to decouple the threads (ORB threads) that receive requests from the underlying transport from the thread that will ultimately dispatch the request to the target servant object.  The TP_Strategy implements a "request queue" as the integral part of the mechanism that allows an ORB thread to "hand-off" a request to one of the TP_Strategy object's worker threads.  The TP_Strategy reference implementation is provided as an example of how a concrete CSD Strategy could be implemented.

      Below is some example application code showing how a TP_Strategy object can be created and applied to a POA:

      PortableServer::POA_var poa = ...; // create the poa.
      // Create a new TP_Strategy object and save it into a "smart pointer" variable.
      TAO::CSD::TP_Strategy_Handle csd_strategy = new TAO::CSD::TP_Strategy();
      // Tell the strategy to apply itself to the poa.
      if (csd_strategy->apply_to( == false)
          ACE_ERROR((LM_ERROR, "Failed to apply CSD strategy to the poa.\n"));
          return -1;

      The CSD feature, as exists in p5, will be undergoing API changes soon.

    • Changed to disable TAO_USE_LOCAL_MEMORY_POOL by default to match the setting from 1.3a. This setting controls whether a cached allocator is used for CDR input and output streams. Most platforms work better with this disabled, which causes normal heap allocation to be used. To re-enable this feature, simply add #define TAO_USE_LOCAL_MEMORY_POOL 1 to config.h.

    • Added a new tao config setting TAO_RESET_OUTPUT_CDR_AFTER_SEND. TAO can appear to have a memory leak due to the default behavior of the output CDR streams, which grow to fit the largest buffer size needed. Add #define TAO_RESET_OUTPUT_CDR_AFTER_SEND 1 to config.h to cause TAO to release the output CDR buffer after each use. Unfortunately, there is currently a thread-safety issue, so this setting is disabled by default. Symptoms of enabling this setting are lockups or infinite loops within TAO with multi-threaded processes.

  23. Features added and bugs/fixes in TAO 1.4a_p4

    • Corrected a problem with the PortableServer not updating the TAO_RefCountServantBase reference count when using reference_to_servant().

  24. Features added and bugs/fixes in TAO 1.4a_p3

    • The size of the skeleton code generated by tao_idl has been decreased dramatically. The skeleton refactoring performed by the DOC Group has been merged into TAO 1.4a. Much of the repetitive code that was generated by the idl compiler has been factored back into the TAO and PortableServer libraries.

    • Strip a trailing carriage return read from an IOR file. This allows IOR files written by Windows to be read by Non-Windows operating systems.

    • The tao_idl compiler was modified to emit guards around template specializations such that they are unique only by the type and file name. This allows multiple idl generated cpp files to be combined into one for quicker compilation.

    • There is a known problem related to DLL export linking on VC7+. It occurs when an exported class is derived from a template. Newer versions of VC++ require you to export the template instantiation in this case, but this can be problematic with generated code. This leads to several commonly seen errors when trying to build DLLs that import symbols from other DLLs (such as TAO.dll). We're still trying to understand the problem, and hopefully a complete solution will be discovered for a future patch release.

  25. Features added and bugs/fixes in TAO 1.4a_p2

    • The IDL compiler now supports the -Gdcps option. This option generates serialization and key support code required for using IDL types with TAO's Data Distribution Service (DDS). TAO's DDS implementation is not included in this patch, but is available as a separate download.

    • Merged a change from the DOC Group repository to fix an interoperability issue with BiDirectional GIOP.

    • Better support for building for VxWorks on a Windows host without Cygwin.

    • Modified the Service Configurator to correctly support UTF-32, UTF-16, UTF-8 and ASCII character sets.

    • Added support for SunCC 5.6, and Visual C++ 8.

    • The 'borland' project type has been removed. Use the 'bmake' project type if you need to build ACE or TAO with the Borland compiler.

    • Fixed an issue preventing the use of bi-directional GIOP over SSLIOP.

    • Added a -x option to catior that works like -f except that it reads the IOR from standard input rather than from a file. This makes catior much more like the unix "cat" command, and enables it to be used in a pipeline.

    • Changed the precedence rules for the -ORBListenEndpoints (aka -ORBEndpoint) so that the host identifier (either hostname or IP address) that appears in IIOP profiles is determined thus:

      1. value from hostname_in_ior (if specified);

      2. setting of -ORBDottedDecimalAddresses option;

      3. value for hostname in -ORBListenEndpoints specification;

      4. whatever TAO magically comes up with based on system configuration

      A new test (TAO/tests/IOR_Endpoint_Hostnames) verifies the operation of this feature.

    • Changed the way that Bidirectional endpoint processing happens when -ORBDottedDecimalAddresses 1 is in effect. The previous behavior always used the setting of the receiver, but that caused problems when the sender and receiver were not using the same dotted decimal addresses setting. Bidirectional endpoint processing now uses whatever the sender provides as the hostname since that's also what will be in that sender's IORs. See ChangeLog entry from

      Wed May 25 12:10:40 2005 Chris Cleeland <>

      for more details.

    • Added support for bounded strings in IDL, e.g.,

      interface Test
        string<50> myStr;
    • The Notification Service has had extensive changes to eliminate leaks and enable features.

      1. Managed object/thread lifespan to eliminate event, servant, and thread leaks.

      2. Corrected deadlocks associated with mutex reuse.

      3. Enabled and repaired Discard, Ordering, and Blocking policies.

    • The Implementation Repository (ImR) has undergone several changes:

      1. Startup and shutdown options have been added.

      2. Enabled ImR shutdown via Ctrl-C (Windows support was enabled, which also enables Ctrl-C shutdown for the Naming Service on Windows).

      3. The user no longer needs to supply the -ORBUseIMR and -ORBInitRef ImplRepoService=... command line options for registered servers as the ImR_Activator automatically adds the corresponding environment variables to processes it launches.

      4. Added repository store clear option.

      5. The ImR now correctly escapes special characters in the XML persistence file. (e.g. > becomes &gt;)

    • Ported the -ORBPreferredInterfaces option from TAO 1.4 to allow specifying which local interface to use when connecting to a specified remote interface.

      -ORBPreferredInterfaces 192.168.*=127*,**

      The above command causes TAO to use the first interface starting with 127 (e.g. when connecting to any address starting with 192.168.*, and to use the first interface starting with "132." when connecting to any host that ends in T
      The argument specified on the left side of the equals sign must match the target host, which usually comes from an IOR. For example, if an IOR contains then this would not match either of the above directives, even if happens to be at

    • ACE_String_Base (ACE_CString, ACE_WString, etc) has been updated for efficiency especially with respect to string concatenation.

  26. Features added and bugs/fixes in TAO 1.4a_p1

    • Improved/additional platform support, including HPUX and some work with VxWorks and Lynx.

    • Many improvements to the ACE/TAO test suite have been made and this version has undergone much more extensive testing.

    • The portspan option is now supported in SSLIOP.

    • Fixed retry issues in SSLIOP when non-blocking IO is used by setting the SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER option.

    • Fixed a memory leak resulting from incorrect reference count management in the corbaloc parser.

    • Fixed a problem affecting the ability of SSL-based TAO servers, which require client authentication to work with JSSE-based Java clients (JacORB).

    • Added new service configuration options to the SSLIOP_Factory:

      1. -SSLCAFile FMT:file - allows explicit specification of the the Trusted Certificates location. The FMT is either "PEM" or "DER". Similar to verify(1) -CAfile option.

      2. -SSLCAPath directory - allows explicit specification of the directory, where the Trusted Certificates are located. The directory must be in a particular format - see openssl(1) fom more details on how to install additional CA certificates. Similar to verify(1) -CApath option.

      3. -SSLRand file1:file2:.. - allows specification of additional sources of randomness (entropy). The option mimics the -rand option on genrsa(1), for example.

    • A new ORB option was added, -ORBLingerTimeout, which only affects the IIOP transport. If a linger timeout is specified, it will be applied to each TCP socket prior to closing the connection.

    • Load Balancing support was added for MacOS X.

    • Enhanced SCTP and SCIOP usability in ACE and TAO respectively.

    • Many changes were made to the ImR for this release, and the resulting performance and features are better than ever.

      1. PER_CLIENT activation now works correctly.

      2. Fixed race conditions during activation for all activation modes.

      3. Switched to an AsyncStartupWaiter within the ImR, rather than waiting across the ImR/Activator processes.

      4. Simplified Activator to a single IDL operation, and removed unneeded AMH.

      5. Organized and clarified output messages.

      6. Fixed several memory leaks.

      7. Added support for using an IORTable in a server with multiple objects per POA.

      8. Enhanced testing.

      9. Changed the default startup timeout to 60 seconds, because the old default timeout of "disabled" is not safe.

      10. Changed the ping behavior. We used to ping a server once a second until a status could be determined, and now we ping with an increasing delay on a schedule, allowing the most common cases to finish much more quickly.

      11. A new method in TAO_POA was added to support creation of direct object references in a server that has specified -ORBUseIMR 1. This should be used when creating the object reference for the IORTable to avoid an extra level of indirection. If PER_CLIENT activation is used, then this is mandatory, or two servers will be started for each client invocation.

      12. You can now specify -n when starting the activator, allowing multiple activators to run on a single machine. (Primarily for testing purposes)

      13. You can now change the activator for a registered server.

      14. The startup timeout, and ping timeouts now work correctly.

      15. The ImR and Activator now use persistent POAs.

    • Fix a problem with RT Notification that was preventing the event forwarding from working because a virtual function was not being overridden.

    • Fixed a problem parsing strings that did not end with /<objkey> thus requiring the default object key.

    • Array optimization is disabled on aCC 3.57 and 3.60.

    • Fixed a deadlock condition in the ACE_Thread_Manager where two threads calling wait() will block forever waiting for each other.

    • Fixed an issue that arose within the static builds on Windows. The ACE_Thread_Mutex static data member of the TSS_Cleanup_Instance class was being used (in the TSS_Cleanup_Instance constructor) before it was statically initialized.

    • Fixed the HTBP where the remote peer is on a host that does not have a DNS entry for its published endpoint.

    • Support for multiple IIOP endpoints in a single profile.

  27. Pending bugs/fixes in TAO 1.4a

    • None at this time.

  28. Features added to TAO 1.4a since TAO 1.4.3

    • Improved thread-specific storage memory management.

    • Improved handling of wide character types in Anys.

    • SSLIOP connection caching improvements

    • Improved JDK ORB interoperability with wide character types

    • Improved processing of GIOP messages on slow networks (aka parse_magic_bytes)

  29. Features added since TAO 1.3a as part of TAO 1.4.3

    • Refactored and improved client-side code results in a drastic reduction to client-side IDL compiler generated code.

    • The C++ header files in TAO have been refactored to minimize the inclusion of code when compiling. These changes have the effect of decreasing build times and reducing dependencies, but may require the addition of #include directives to application code.

    • The most popular ORB services (Naming, Notification, Trading, Event, Logging) have had their libraries split into separate libraries for stub, skeleton, and implementation libraries. Applications that use these services need to link to the new libraries.

    • The Valuetype, IOR Interceptor, and Object Reference Template features have been split into separate libraries. Applications using these features need to link these libraries.

    • The IDL compiler now places inline functions in .inl files instead of .i files.

    • The OMG-defined SCIOP protocol support, which uses SCTP as its transport, is now supported by TAO.

    • A new HTIOP protocol was added to TAO.

    • The Component Integrated ACE ORB (CIAO), a CORBA Component Model implementation, was added. The CCM Deployment and Configuration specification has also largely been implemented.

    • RTCORBA 2.0's dynamic scheduling is now implemented.

    • TAO now supports CSIv2 (Common Secure Interoperability version 2).

    • Added support for FT CORBA specification features.

    • CORBA::Any implementation improvements fix some bugs, improve performance, and reduce footprint.

    • TAO's valuetype support is improved.

    • AMH support is improved.

  30. Important bug fixes since TAO 1.3a

    Many bugs have been fixed or work-arounds provided since TAO 1.3a. For more details, see the release announcements for the intervening DOC group beta kits (from 1.3.2 to 1.4.3), the ChangeLogs, and the DOC group Bugzilla bug database found at



All of the AIX builds used the recommended OCI build flags OCI build flags in addition to the platform_macros.GNU and config.h files already set up for the AIX platform and compiler.

When using GNU Make that is part of AIX toolbox for Linux applications, it may be necessary to modify the file access permissions of the make executable to ensure the LIBPATH environment variable is propagated to make system properly. This can be done as follows:

chmod 755 /opt/freeware/bin/make

See this message for further information. Use version 3.80, or newer.

Files Used for AIX Builds
AIX 5.2 with VA C++ 6.0 platform_aix_ibm.GNU config-aix-5.x.h



All of the HP-UX builds used the recommended OCI build flags in addition to the platform_macros.GNU and config.h files already set up for the HP-UX platform and compiler.

Files Used for HP-UX Builds

HP-UX 11.11 with aCC 3.60 platform_hpux_aCC.GNU config-hpux-11.00.h
HP-UX 11.20 with aCC 5.32 platform_hpux_aCC.GNU config-hpux-11.00.h



All of the Linux builds used the recommended OCI build flags in addition to the platform_macros.GNU and config.h files already set up for the Linux platform and compiler.

Files Used for Red Hat Builds
Fedora Core 3 with g++ 3.4.2 platform_linux.GNU config-linux.h
RedHat AS3 on Opteron with g++ 3.2 platform_linux.GNU config-linux.h
RedHat 2.1AW on Itanium with g++ 3.2 platform_linux.GNU config-linux.h


Mac OS X

All of the Mac OS X builds used the recommended OCI build flags in addition to revised platform_macros.GNU and config.h files developed for the Mac OS X platform and compiler.

Files Used for Mac OS X Builds
Build platform_macros.GNU config.h
Mac OS X 10.3.7 with g++ 3.3 platform_macosx_panther.GNU config-macosx-panther.h

In addition

The Apple Developer Kit Dec 2002 is required and two additional packages will have to be loaded from open source available on the net.

  • dlcompat is required for implementing dynamic library loading. It can be obtained directly from and built. Or a pre-built version may be loaded with fink ( If the fink version is used, you will need to add:

          #define ACE_NEEDS_DL_UNDERSCORE
    to your config.h file.
  • Certain parts of the TAO will not build with the version of gmake in the versions of Mac OS X 10.2 available as of this writing. You will need to download gmake version 3.80 (or better)


The major problem with getting TAO to run on Mac OS X was lack of full initialization of static objects. About half of the tests were failing. Apple is aware of the problem, but a fix does not appear to be imminent. This problem seems to be a somewhat difficult problem with some legacy implications. Thus, for ACE/TAO the Mac will not be supportable for any earlier versions than 1.4a of ACE/TAO and 10.2.x of Mac OS X.

There are three or four environment variables that are required to be defined in the user's environment.

  • DYLD_LIBRARY_PATH which operates as LD_LIBRARY_PATH on most other UNIX like systems.

  • DYLD_BIND_AT_LAUNCH=1 is required to make the dlcompat package work. This package is used to implement the dynamic loading used by the Service Configurator. When this is set, the dynamic linker binds all undefined symbols the program needs at launch time. This includes function symbols that can are normally lazily bound at the time of their first call. When Apple gets around to providing this capability natively, we may be able to eliminate this variable; that would be good since it adversely affects performance.

  • MACOSX_DEPLOYMENT_TARGET="10.2" is requires to get rid of a lot of annoying warning. It might also fix a couple of things that we have worked around.

    And, if you are building ACE/TAO and wish to run the tests,

  • ACE_RUNTEST_DELAY provides a multiplier to the times specified in a test. ACE_RUNTEST_DELAY=2 is needed to make more than 20 tests run in that the DYLD_BIND_AT_LAUNCH=1 slows process startup beyond the 5 seconds allowed for startup.



All of the Solaris builds used the recommended OCI build flags in addition to the platform_macros.GNU and config.h files already set up for the SunOS platform and compiler.

Files Used for SunOS Builds
Build platform_macros.GNU< config.h
SunOS 5.7 with g++ 3.3.2 platform_sunos5_g++.GNU config-sunos5.7.h
SunOS 5.8 with g++ 3.2.1 platform_sunos5_g++.GNU config-sunos5.8.h
SunOS 5.9 with Sun C++ 5.4 platform_sunos5_sunc++.GNU config-sunos5.9.h
SunOS 5.7 with Sun C++ 5.3 platform_sunos5_sunc++.GNU config-sunos5.7.h
SunOS 5.8 with Sun C++ 5.3 platform_sunos5_sunc++.GNU config-sunos5.8.h
SunOS 5.9 with g++ 3.3.2 platform_sunos5_g++.GNU config-sunos5.9.h
SunOS 5.10 with Sun C++ 5.5 platform_sunos5_sunc++.GNU config-sunos5.10.h

Sun C++ Notes

Use the fast=1 instead of optimize=1 for optimizing with Sun compilers because it selects a combination of compilation options for optimum execution speed. Other optimization levels may reduce the footprint, but do not have a corresponding flag in ACE/TAO.

When using a Sun compiler greater than SunCC 5.5, that is, Sun Studio 9 or greater, on Sun OS 5.8, then certain OS patches are required. The patches and levels used at OCI are 109147-37 (-21 is probably adequate), 108434-18 and 108435-18 (earlier versions are not adequate).



The Tru64 builds used the recommended OCI build flags in addition to the platform_macros.GNU and config.h files already set up for the Tru64 platform and compiler.

Files Used for Tru64 Builds




Tru64 5.1b with cxx V6.5-014



In addition

The default ulimits on these platform are not sufficient to build TAO. The problem is the virtual memory limits, vmemory and data must be increased to the maximum allowed. For us, this is vmemory=4194304 and data=1048576 .

In addition the operating system must be configured to have larger limits for semaphore operations.

  sem_mni = 250
  sem_msl = 125
  sem_opm = 100
  sem_ume = 100

CXX Notes

There is a problem with the Naming Service when built with Compaq C++ compilers and optimization. The source in question is Bindings_Iterator_T.cpp and the modules that use this are Persistent_Naming_Context.o and Transient_Naming_Context.o in library The problem exists on C++ V6.2 to V6.5 and on UNIX 5.1 and 4.0F. The problem occurs at all optimization levels from O1 through O4. It is unknown when a fix will be available



All of the Windows builds used the recommended OCI build flags in a config.h file as shown below.

Files Used for Windows Builds
Build config.h
Windows XP sp1 with Visual C++ 6 sp5 config-win32.h
Windows 2003 Enterprise VC++ 7.1 config-win32.h

The following config.h file is used for all Windows nightly builds.

// contents of config.h
#include "config-win32.h"

The first line disables the popup of error windows when running the automated tests. It is not normally needed for ordinary user programs. It would only be used if an automated build was being done.

The platform_macros.GNU file is not used for Windows platforms.

Compile Notes

  • There are some warnings when compiling using Visual C++ 7.1

  • If using MPC to generate build files, then by default qos and ssl, and any projects that depend on these libraries will not be generated. To enable these features, simply create a text file called ACE_wrappers\bin\MakeProjectCreator\config\default.features with the following contents.

    ssl = 1
    qos = 1
  • When building static libraries you may have to build twice. The first time will compile the IDL, and compile everything that didn't rely on IDL-generated files that don't exist. The second time will finish building files now that the IDL-generated files exist.



If you're doing your own build, you can have the following flags set which OCI uses in its own builds. For UNIX and UNIX-like platforms that use GNU Make, use platform_macros.GNU. For Windows/Visual C++ builds, use config.h. If an option is not listed below, let it default.

Turned on:






#define __ACE_INLINE__ (unless not supported by the compiler)


#define TAO_HAS_AMI 1


#define TAO_HAS_RT_CORBA 1










no equivalent (If you plan on using static libraries, use static_libs_only=1)

Turned off:




no equivalent


no equivalent



Variable--dependent on platform and other settings:


optimize=[0|1] (= !debug)

fast=1 ONLY FOR SUNOS C++, non-DEBUG builds instead of optimize=1