The ADAPTIVE Communication Environment has been ported and tested extensively on a wide range of C++ compilers and uni-processor and multi-processor OS platforms including Win32, i.e., WinNT/i386, WinNT/Alpha, and Win95; most versions of UNIX, e.g., SunOS 4.x and 5.x, SGI IRIX, DG/UX, HP-UX, OSF/1 a.k.a. DEC UNIX, AIX 4.x, Linux, SCO, UnixWare, FreeBSD, MVS OpenEdition, and LynxOS; VxWorks; and PSoS. If you have a problem compiling the ACE wrappers on the platforms shown below please send email to either ACE Newsgroup or the ACE mailing list and we'll try to fix it for you.
The following table summarizes those platforms for which ACE is known to support well.
| Fully supported, i.e., continually tested and used daily | Solaris 2.5, Windows NT (MSVC++ 4.x and 5.0), DEC Alpha Windows NT (MSVC++ 5.0), Linux/Intel, Linux/Alpha, VxWorks, LynxOS, Digital UNIX 4.0, HP/UX, AIX |
| Nearly fully supported, i.e., periodically tested | Solaris 2.6, Windows 95, IRIX 6.x, MVS |
| Partially supported, i.e., infrequently tested | PSoS, Tandem, Chorus, SCO, UnixWare, SunOS 4.x, FreeBSD, NetBSD |
| Planned support, i.e., pending | Windows CE |
In general, any UNIX/POSIX variation is a potential target platform for ACE. Ideally, ACE will compile on any POSIX conforming OS.
All of ACE has been ported to the Win32 API (which includes Windows NT and Windows '95). The entire release now compiles using the Microsoft Visual C++ 4.x and 5.0 compilers (the 2.0 compiler may also work, but we haven't tested it recently). ACE can be built as both a static and dynamic library, using the Win32 installation process described below.
All the source code and tests should build and run without any problems on the Solaris and SunOS platforms using the Sun C++ compilers.
Note that shared libraries do not interact very well with Centerline C++ or Sun C++ on SunOS 4.1.x. This is due to odd behavior of the SunOS 4.1.x linker, which (1) does not properly call constructors of global objects within shared libraries and (2) does not call the init() and fini() functions in shared libraries, even though the manual claims that these functions are called! In particular, this means that the tests in the directory $(ACE_ROOT)/tests/Service_Configurator/IPC-tests/server/ will not work for statically linked services...
Some versions of SunOS 4.1.x do not contain the /usr/lib/libnsl.a library. This library seems to be optional since System V Transport Layer Interface (TLI) support is optional on SunOS 4.1.x (in contrast, it's the "preferred" transport interface on Solaris).
The best work-around for now is probably to either add a dummy libnsl.a in /lib (which may not be feasible) or simply comment out the line:
LIBS += -lnsl
in the $ACE_ROOT/include/makeinclude/wrapper_macros.GNU
file. Naturally, any programs, e.g., the TLI_SAP tests,
that use the TLI wrappers aren't going to work!
Note that on SunOS 4.x you may get warnings from the linker that "archive has no table of contents; add one using ranlib(1)" for certain libraries, e.g., libASX.a, libThreads.a, and libSPIPE.a. This occurs since SunOS 4.x does not support these features.
The ACE port to AIX assumes that the user has installed the AIX patch containing the dl*() APIs. To use these APIs, IBM has created a separate product (free to AIX licensees) called shared library hookable symbols (or slhs/6000). If you don't have this patch, the sv* commands for compiling and linking will not be present on the system.
If you are using AIX 4.2.1 or later, there is no patch needed; the dynamic library APIs are included in the base operating system.
BTW, here's a technique from Rob Jordan <jordan@hursley.ibm.com> that can reduce the size of the ACE libraries by about one third, and can also be applied to applications. It works by optimising the sharing of template functions, which are created in an ``unusual'' way under AIX. It also speeds up compilation.
Here's how to optimise the ACE library generation:
Look at the Makefile
in $ACE_ROOT/ace. Create a file called
ACE_All_Src.cpp, and add a line to #include
each of the source files
listed under FILES= in the Makefile. Create a
file called ACE_All_Tmp.h
and add a line to #include each of the .h files listed under
TEMPLATE_FILES= in the Makefile. Now update the Makefile so that
FILES=ACE_All_Src and TEMPLATE_FILES=ACE_All_Tmp.
ACE has been ported to Linux on both Intel and Alpha platforms. With glibc 2 distributions, such as RedHat 5.0, you'll need at least the following additions:
With some glibc-2.0.6 versions, you may need to apply some patches to get ACE working with LinuxThreads. Some of the patches are necessary with Alpha CPUs and with some older kernels.
Some of the ACE tests fail on older, pre-glibc-2 Linux platforms.
ACE has been ported to SCO UNIX using the GNU g++ 2.7.2 compiler. Arturo Montes <mitosys@colomsat.net.co> maintains this code. In addition, he also maintains a version of FSU pthreads.
ACE used to build fine using the SGI C++ and GNU GCC compilers for IRIX 5.x. It has been ported to IRIX 6.x using the SGI MipsPro 7.1 C++ compiler; be aware that in IRIX 6.2 there is a number of patches that have to be installed and exceptions appear to fail with the O32 ABI. Please check the config files for the details.
HP sells 2 C++ compilers for HP-UX 10.x. If you are using 9.x, there's only the first one.
The OSF/1 C++ 5.4 through 5.7 compilers have problems with ACE's templates. They compile the lib and most of the test programs, although they warn about template usage. Most tests run, some dump core.
CXX 6.0 and 6.1 are _much_ improved in this regard: they build all of
ACE cleanly. Please note that
include/makeinclude/platform_osf1_4.0.GNU has a
WARNING_FLAGS macro that is disabled by
default, to support users who don't have 6.0 yet. If you do, enable
that macro definition by either adding CXX_VER=POST_5X to your gmake
invocation, or editing your include/makeinclude/platform_macros.GNU
file. All of the tests in ACE_wrappers/tests run successfully with
CXX 6.0 and CXX 6.1.
GNU gcc 2.7.2.1 compiles without problems. All tests run (besides minor problems). Thanks to Thilo Kielmann < kielmann@informatik.uni-siegen.de> and David Trumble <trumble@cvg.enet.dec.com> for help with this port.
Steve Huston <shuston@riverace.com> has ported ACE to work with UnixWare 2.01 and g++.
Ganesh Pai <gpai@voicetek.com> subsequently did the port for version 2.1.2, also with g++.
Wei Chiang <chiang@tele.nokia.fi> has ported ACE to Chorus 3.1 using GNU g++ 2.7.2.
Dave Mayerhoefer <davem@lynx.com> has ported ACE to LynxOS 2.5 using GNU g++ 2.7.2. However, you may need to apply some patches to LynxOS to get ACE working.
David Levine <levine@cs.wustl.edu> has ported ACE to VxWorks 5.2/5.3/5.3.1 with the GreenHills 1.8.8 and g++ 2.7.2 compilers.
In addition to all of the other benefits of ACE, it helps work around some deficiencies with VxWorks 5.3/5.3.1. Some of these apply only with g++, at least thru version 2.7.2. That is the version that is shipped with Tornado 1.0.1/ VxWorks 5.3.1. The problems are:
Please note that ACE uses one of the spare fields in the Wind River task control block, spare4, for thread- specific storage. This field is specified in only one place, in ace/OS.i, so it can easily be changed to one of the other spare fields, if necessary.
Versions of ACE from 4.3.3 and beyond destroy dynamically
allocated singletons in the ACE library. But, they may not
properly destroy some static objects. If you have trouble
running a program multiple times, it may be necessary to
unload the module, using unld, and reload it between runs.
Alternatively, you could try calling cplusDtors
and then cplusCtors between runs.
All of ACE has been ported to OpenEdition by Chuck Gehr <gehr@sweng.stortek.com>. The ACE library, all the tests and most of the examples and apps build clean. There are still some problems that need to be ironed out:
MVS does not support the dynamic linking dl...() calls that the Service Configurator uses to dynamically link services at run time. As a result, all the examples and apps that use a svc.conf file (for dynamically configuring service objects) do not work, however, most of these apps can be built/run statically. Also, the Svc_Conf_l.cpp and Svc_Conf_y.cpp files are generated using flex and yacc on a ascii (not ebcdic) machine and as a result they don't work very well with ebcdic svc.conf files. We should be able to regenerate these files on MVS but MVS doesn't have flex. This is something that needs to be done.
Some of the tests do not execute properly. This is a minority and over time the goal is to get to 100%.
The make scheme for some of the apps still doesn't work perfectly on MVS. This is mainly due to the way shared libraries are handled on MVS. See additional build tips for MVS for more on this.
-fno-exceptions to egcs (and g++ starting with version
2.8.0) invocations. This disables exception handling support. On
Solaris/sparc and Linux/alpha, it results in a 25 percent reduction
in the size of libACE.so. To enable exception handling, add
exceptions=1 to your make command line
invocation, or to your
$ACE_ROOT/include/makeinclude/platform_macros.GNU.
% make optimize=0OCFLAGS line.
config.status
file. This file is produced when installing gcc; it specifies
where to install the binary files that gcc uses. For example,
it specifies whether to use Solaris's
/usr/ccs/bin binary utils or GNU binary
utils. The config.status file is an output of
the gcc configure script; it is preferable to use
the --prefix option to configure instead
of hacking its output.
collect2.
% setenv ACE_ROOT /home/cs/faculty/schmidt/ACE_wrappers
However, if you're building a number of versions of ACE, e.g., for different OS platforms or for different releases of ACE, you might use the following approach:
% setenv ACE_ROOT $cwd
There are config files for most versions of UNIX. If there isn't a version of this file that matches your platform/compiler, you'll need to make one. Please send me email if you get it working so I can add it to the master ACE release.
% setenv LD_LIBRARY_PATH $ACE_ROOT/ace:$LD_LIBRARY_PATH
% make
at the root of the ACE source tree. This will build the ACE library,
tests, the examples, and the sample applications. Building the entire
ACE release can take a long time, however. Therefore, you might
consider cd'ing into the $ACE_ROOT/ace/ directory and running
make there to build just the ACE library. As a sanity
check, you might also want to build and run the automated ``one-button'' tests in
$ACE_ROOT/tests/.
#include "config-win32.h"#define ACE_HAS_WINNT4 0#define ACE_HAS_STANDARD_CPP_LIBRARY 1#define ACE_HAS_DLL 0#define __ACE_INLINE__ 0The tests are located in ACE_ROOT\tests. There are two corresponding project files in that directory also (tests.mdp and tests.dsp).
Once you build all the tests (Batch Build works well for this) you can run the batch file run_tests.bat in that directory to try all the tests.
BUILDING ACE ON A WIN32 MACHINE THAT LACKS A NETWORK CARD
You may want to run ACE on a non-networked machine. To do so, you must install TCP/IP and configure it to ignore the absence of a network card. This is one method:
A few notes on VxWorks builds (thanks to Paul von Behren for these notes):
ace_ld which is called from the Makefiles, replacing
the traditional ld step. You must have Perl installed
to use ace_ld.
The VxWorks platform_vxworks*.GNU files are set up so that shared libraries are not built on VxWorks. Only static libraries, with .a extension, are built. Therefore, it's not necessary to set the LD_LIBRARY_PATH environment variable on your host system when building for VxWorks targets. Please note, however, if you use TAO on VxWorks that you will need to set your LD_LIBRARY_PATH to find the TAO IDL compiler libraries (installed in the ace directory) on the host.
With g++, bin/ace_ld is used to munch object files and libraries to set up calls to static constructors and destructors. bin/ace_ld requires perl on the host platform.
These non-default VxWorks kernel configuration #defines
are required with ACE:
#define INCLUDE_CPLUS /* include C++ support */ #define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */ #define INCLUDE_POSIX_ALL /* include all available POSIX functions */For completeness, here are the non-default
#defines that
we used for VxWorks 5.3.1/g++ 2.7.2:
#define INCLUDE_CPLUS /* include C++ support */ #define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */ #define INCLUDE_CONFIGURATION_5_2 /* pre-tornado tools */ #define INCLUDE_DEBUG /* pre-tornado debugging */ #define INCLUDE_LOADER /* object module loading */ #define INCLUDE_NET_SYM_TBL /* load symbol table from network */ #define INCLUDE_SYM_TBL_SYNC /* synchronize host and target symbol tables */ #define INCLUDE_NFS /* nfs package */ #define INCLUDE_PING /* ping() utility */ #define INCLUDE_POSIX_ALL /* include all available POSIX functions */ #define INCLUDE_RDB /* remote debugging package */ #define INCLUDE_RLOGIN /* remote login */ #define INCLUDE_RPC /* rpc package */ #define INCLUDE_SECURITY /* shell security for network access */ #define INCLUDE_SHELL /* interactive c-expression interpreter */ #define INCLUDE_SHOW_ROUTINES /* show routines for system facilities*/ #define INCLUDE_SPY /* spyLib for task monitoring */ #define INCLUDE_STARTUP_SCRIPT /* execute start-up script */ #define INCLUDE_STAT_SYM_TBL /* create user-readable error status */ #define INCLUDE_SYM_TBL /* symbol table package */ #define INCLUDE_UNLOADER /* object module unloading */ #define INCLUDE_WINDVIEW /* WindView command server */It probably wouldn't take much effort to modify the ACE library to not require
INCLUDE_CPLUS_IOSTREAMS,
if necessary.
If you're first getting started with ACE and/or VxWorks, I recommend
just building the ACE library and tests first. (Some of the ACE
examples, in System_V_IPC, don't build on VxWorks yet.) Then try
running the tests. Please see $ACE_ROOT/tests/README for the latest
status of the ACE tests on VxWorks.
Please note that the main entry point is renamed to
ace_main (configurable via ACE_MAIN) on VxWorks with g++,
to comply with its restriction against using main.
In addition, ACE_HAS_NONSTATIC_OBJECT_MANAGER is enabled by default
to cleanly support construction and destruction of static objects.
This requires that main be declared with its arguments
even if they're not used, and with int return type:
int
main (int, char *[])
ACE on VxWorks assumes that your main function is named
main when using ACE_HAS_NONSTATIC_OBJECT_MANAGER. Any
violation of this assumption is at your peril. If you really need to
call your entry point something other than main, you'll
need to construct an ACE_Object_Manager. Please see the
#define of main (int, char *[]) in
ace/OS.h to see how ACE does that for entry points named
main.
ACE threads (VxWorks tasks) can be named, for example, by supplying a
non-null argument to the Thread_Manager spawn routines. However,
names beginning with "==ace_t==" are forbidden because
that prefix is used internally by ACE.
You can spawn a new task to run ace_main, using either
VxWorks sp, or ACE'S spa.
spa can be used from the VxWorks shell to pass arguments
to ace_main. Its usage is:
spa ace_main, "arg1" [, ...]
By default, the ACE Makefiles link the ACE library into every
executable. If you want to run multiple ACE executables but just use
a single ACE library, it should be possible, though I haven't tried
it. Just link the first executable to be loaded onto the target with
the ACE library, as usual. All other executables can be linked
without the ACE library by added ACELIB= to the make
invocation when building them. When they are loaded onto the target,
the should load against the symbols from the ACE library from the
first executable that was loaded.
A few additional Windows Notes, from Paul von Behren:
Tornado\host\x86-win32\bin\TorVars.bat. This is done
implicitly within the Tornado IDE.
ace_ld, you still need perl installed -
see
http://www.activestate.com/software/default.htm for Windows
perl.
ACE_ROOT\include\makeinclude\rules.nested.GNU
(the error message says something about "dir unexpected").
ACE_ROOT\ace directory
creating the library libACE.a. If perl is available, make also works
in the ACE_ROOT\tests directory (ignore the final error
attempting to run /bin/true).
ACE_ROOT defined
before starting Tornado, you can specify an ACE Makefile as a Tornado
target and Tornado will then call make from the menu.
cdk.exe and installed that on my NT box.
I downloaded perl5.0 from where I can't remember. There may have been
bits and pieces from other places for things like vi and
less.
/ace/ACE_wrappers.NT and
/ace/ACE_wrappers.vxworks. The NT tree is for building
aced.dll and tao_idl.exe as currently
documented for ACE/TAO on NT/VC++5.0. The VxWorks tree is the
cross compilation tree.
/tornado/host/x86-win32/bin: /tornado/host/x86-win32/lib/gcc-lib/i386-wrs-vxworks/cygnus-2.7.2-960126: /tornado/host/x86-win32/i386-wrs-vxworks/bin: /ace/ace_wrappers/bin: /gnuwin32/b18/H-i386-cygwin32/bin: /gnuwin32/b18/tcl/bin: /WINNT/system32: /WINNT: /WINNT/system32/nls/ENGLISH: /binOther environment variables:
WIND_BASE=/tornado SHELL=/bin/sh.exe TERM=pcbios TAO_ROOT=/ace/ACE_wrappers.vxworks/TAO CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.EXE GCC_EXEC_PREFIX=/tornado/host/x86-win32/lib/gcc-lib/ WIND_HOST_TYPE=x86-win32 ACE_ROOT=/ace/ACE_wrappers.vxworks
/tornado is the root of the Tornado install
($WIND_BASE).
/gnuwin32 is the root of a Cygnus GNU download and install.
/bin content is:
aced.dll cygwin.dll perl.exe rm.exe sh.exe true
aced.dll is produced in an ACE NT source tree according to
documented procedure for NT VC++5.0 ACE build.
cygwin.dll is from the Cygnus GNU software download and install.
$ACE_ROOT/ace/config.h that looks like:
#define __ACE_INLINE__ 0 #define ACE_HAS_DLL 0 #include "config-vxworks5.x.h"And create a
$ACE_ROOT/include/makeinclude/platform_macros.GNU
that looks like:
WIND_BASE = /tornado WIND_HOST_TYPE = x86-win32 PATH += :$(WIND_BASE)/host/$(WIND_HOST_TYPE)/bin CPU = I80486 include $(ACE_ROOT)/include/makeinclude/platform_NTvxworks5.x_g++.GNU(But, I guess the PATH+= line is superfluous based on the PATH as shown previously). Finally, create a
$ACE_ROOT/include/makeinclude/platform_NTvxworks5.x_g++.GNU
with diff output from 'diff platform_vxworks5.x_g++.GNU
platform_NTvxworks5.x_g++.GNU' that looks like:
58c58
< HOST_DIR = $(WIND_BASE)/host/sun4-solaris2
---
> HOST_DIR = $(WIND_BASE)/host/x86-win32
62,63c62,63
< CXX = g++$(TOOLENV)
< CFLAGS += -DVXWORKS -D_REENTRANT -ansi -fno-builtin
-fno-defer-pop -fvolatile -nostdinc -nostdlib -pipe -Wall
---
> CXX = $(CC)
> CFLAGS += -DVXWORKS -D_REENTRANT -ansi -fno-builtin -fno-defer-pop \
-fvolatile -nostdinc -nostdlib -Wall #-pipe
cd $ACE_ROOT/ace; make
make.exe in the
/gnuwin32/b18/H-i386-cygwin32/bin directory as I couldn't get
make shipped with Tornado to run ace_ld and I couldn't figure out any
other work around.
cd $ACE_ROOT/tests; /gnuwin32/b18/H-i386-cygwin32/bin/make
Also, running the tests works as already documented.
aced.dll in /bin.
CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
cd $TAO_ROOT/orbsvcs/orbsvcs
/gnuwin32/b18/H-i386-cygwin32/bin/make
CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
cd $TAO_ROOT/tao
/gnuwin32/b18/H-i386-cygwin32/bin/make
main) contained in
$ACE_ROOT/netsvcs/servers/main.cpp should also be compiled and ready to run.
% setenv LD_LIBRARY_PATH $ACE_ROOT/ace:$LD_LIBRARY_PATH
main driver program dynamically.
To specify which services should be linked in and executed, edit the
$ACE_ROOT/netsvcs/servers/svc.conf file. During your editing,
you should update information (such as the default service port
numbers) that affects the initialization of services in this
file. Refer to the Service Configurator
documentation to learn how the configuration file is parsed and
how the services are dynamically linked and executed. In
addition, refer to the Network
Services documentation to learn more about how to configure
each network service.
If you are using MSVC 4.x, you will need to add another directory to your global include and library paths, ACE_ROOT/netsvcs/lib. When you use the dynamic libraries, make sure to also include ACE_ROOT/netsvcs/lib in your PATH.
% cd $ACE_ROOT/bin % make % mv clone ~/bin % rehash
Then create a ./build subdirectory someplace, e.g., under $ACE_ROOT, and then invoke the top-level Makefile with the ``clone'' target, e.g.:
% cd $ACE_ROOT % mkdir build-SunOS5 % cd build-SunOS5 % make -f ../Makefile clone % (cd ace; ln -s config-sunos5.5-g++.h config.h) % (cd include/makeincludes; ln -s platform_sunos5-g++.h platform_macros.GNU) % setenv ACE_ROOT $cwd % make
This will establish a complete tree of links. Note that you must to build a config.h and platform_macros.GNU in cloned directory. In addition, make sure you set your LD_LIBRARY_PATH to $ACE_ROOT/ace:$LD_LIBRARY_PATH on SVR4 UNIX platforms.
When you do a make in the $ACE_ROOT directory you will be producing object code that is not stored in the same place as the original source tree. This way, you can easily build another platform in a parallel tree structure.
VERY IMPORTANT!
If you use the ``clone trick'' discussed above, make sure that the symbolic links are correctly in place before starting the build. In particular, if you plan to clone the tree, it is preferable to do so before you start a build procedure on the original tree. This is because the build procedure create object directories (.obj and .shobj) and the cloning procedure will clone these directories also. You would end up with links pointing to object files of another platform. If you clone the tree after you've done a build on the original tree, make sure to remove all ".obj", ".shobj" and (any other files or directories) in all subdirectories before starting the build on your cloned tree.
Alternatively, the perl script
ACE_wrappers/bin/create_ace_build can be used to create
build trees. It creates them below ACE_wrappers/build.
It filters out all but the necessary files, so the warning above does
not apply. See the comments at the top of the script itself for usage
information.
You can get a copy of GNU make that has been ported to MVS OpenEdition from the IBM OpenEdition web site. ACE's make scheme generates compile commands that have options and operands interspersed. By default, the c89/cc/c++ compiler expects all options to precede all operands. To get around this, you must set a special compiler environment variable (_CXX_CCMODE) to 1 which tells the compiler to allow options and operands to be interspersed.
Note that the environment variable LD_LIBRARY_PATH is called LIBPATH on MVS.
Shared objects are built a little different on MVS than on other UNIX implementations. This has been accounted for in the makefiles that come with ACE When the linker (via the cxx command) builds the libACE.so file it will also create a file called libACE.x. This is a side-deck file and it must be included in subsequent link edits with application code. For more information on this see the C/C++ MVS Programming Guide. If you want to build your application statically, i.e., using libACE.a instead of libACE.so, you can set ACELIB to ACELIB_STATIC in platform_mvs.GNU.
When the libACE.so file is built (via the MVS pre-linker and binder), you will get a rc=4 from the pre-linker. This is ok. This is due to some warnings about unresolved references which should get resolved during the link step. Note, however, there shouldn't be any unresolved references from the binder (linkage editor). You can get pre-link and link maps by uncommenting the PMAP and LMAP lines in the platform_mvs.GNU file.
Please note that the effects of a flag may be platform specific. Also, combinations of certain flags may or may not be allowed on specific platforms, e.g., debug=1 opt=1 is supported by g++ but not all other C++ compilers.
Flag Description
---- -----------
debug Enable debugging; see DCFLAGS and DCCFLAGS.
exceptions Enable exception handling (not supported by all platforms).
fast Enable -fast option, e.g., with Sun C++.
inline Enable ACE inlining. Some platforms enable inlining by
default, others do not.
optimize Enable optimization; see OCFLAGS and OCCFLAGS.
orbix Enable use of Orbix.
profile Enable profiling; see PCFLAGS and PCCFLAGS.
purify Purify all executables.
quantify Quantify all executables.
shared_libs Build shared libraries. Ignored if static_libs_only is set.
static_libs Build shared libraries. Ignored if shared_libs_only is set.
shared_libs_only Only build shared libraries. Ignored if no SHLIBs are
specified by the Makefile, as in performance-tests/Misc.
static_libs_only Only build static libraries.
Usually, users do not need to be concerned with make targets.
Just enter ``make'' on the command line to build. A few notable
targets are listed below.
Target Description
------ -----------
show_statics Lists all static objects in object files built for
current directory. Only supported for g++.
show_uninit Lists all uninitialized in object files built for
current directory. Only supported for g++.
Back to the ACE home page.