### Porting ACE and TAO to a New OS Platform

The ACE framework and the TAO ORB have been ported to many OS platforms. Porting ACE and TAO to new platforms is fairly easy. The following document describes the step-by-step process to use when porting the various components and layers in ACE to a new OS platform. Once ACE is ported, it is straightforward to port TAO, as well.

#### Create a `config.h` Header File for the Target OS Platform

A `config-*.h` header file exists in $ACE_ROOT/ace for each platform to which ACE has been ported. This file contains the portability macros for each particular configuration of ACE. A complete description of the existent macros can be found in the $ACE_ROOT/ace/README file.

Currently, you must edit this file by hand to port it to new OS platforms. It's a good idea to use the `config-*.h` files for platforms with similar characteristics as examples. Ultimately, we plan to auto configure these files.

#### Port the `ACE_OS` Class

The `ACE_OS` class encapsulates most of variation between the different OS implementations, e.g., UNIX, Win32, and various real-time operating systems. It is the core class of the ACE OS abstraction layer. Most work required to port ACE to a new OS platform resides in this class. There are many examples of how ACE has been ported to other operating systems in the `ACE_OS` class in the `$ACE_ROOT/ace/OS.{h,i,cpp}` files.

Optional features in pthreads are covered by `ACE_HAS_*` and/or `ACE_LACKS_*` macros, which are described in the $ACE_ROOT/ace/README file. Particular platform features, such as DCE pthreads calls that end in `_np`, should be bracketed by platform defines rather than by inventing more `ACE_HAS_*` or `ACE_LACKS_*` definitions.

An important part of porting ACE to a new platform is to map the threading API correctly. Currently, ACE has support for the following thread APIs:

- UNIX International (UI) Threads (`ACE_HAS_STHREADS`) - Solaris 2, UnixWare.

- POSIX Pthreads (`ACE_HAS_PTHREADS`) - drafts 4 [DCE], 6 [FSU], 7 [AIX], as well as the final standard (also called draft 10) [MIT, Linux, and Solaris].

- Win32 Threads (`ACE_HAS_WTHREADS`) - Windows NT, Windows '95/98, and Windows CE

- VxWorks Tasks (`VXWORKS`) - VxWorks

If your OS platform does not support any of these threading packages, you must port the `ACE_OS::thr_*` functions.

#### Port the C++ Wrapper Components

After porting the `ACE_OS` class, the next step is to port all of the ACE C++ wrapper components, such as sockets, threads, synchronization mechanisms. A full list of the categories and classes can be found in the $ACE_ROOT/ACE-categories file. It is easiest to concentrate on porting one category at the time. The ACE release contain a one-button test suite in the $ACE_ROOT/tests/ directory. These tests can be used to validate the correctness of the various ACE C++ wrappers as they are ported.

#### Port the Higher-level Framework Components of ACE

Having ported (and tested) all the components of the ACE OS adaptation layer and C++ wrappers, you can proceed to port the higher level components of ACE, such as the Reactor, Service Configurator, Connector, Acceptor, and Streams frameworks. At this point, it should be relatively easy to port the rest of ACE because most of the platform-dependent code is localized in the lower layers of ACE.

#### Port TAO

After porting and successfully testing all the ACE framework components, it also should be relatively easy to port and install TAO because all of its platform-dependent code is localized in ACE. Typically, the only problems that arise when porting TAO is bugs with C++ compilers.

### C++ Features Required to Port ACE and TAO

ACE and TAO have been ported to most C++ compilers. The following is a list of which C++ features a compiler must support in order to compile ACE and TAO:

- Templates -- The C++ compiler must support templates. However, it need not support template member functions nor must it support template traits.

- Multiple inheritance and dynamic binding -- The C++ compiler must support multiple inheritance and dynamic binding.

The following is a list of which C++ features that ACE and TAO can take advantage of if a compiler supports them:

- Exceptions -- The ACE library itself is ``exception neutral,'' i.e., it does not catch or throw C++ exceptions. However, you can use exceptions in code that uses ACE including throwing exceptions inside call back methods, as long as you provide the code to handle it. TAO can be configured to use C++ exceptions if ACE supports them, i.e., if `ACE_HAS_EXCEPTIONS` is defined.

- RTTI and ANSI casts -- If the OS platform supports RTTI and the new ANSI C++ casts, i.e., `ACE_HAS_ANSI_CASTS` is enabled, then the various `ACE_*_cast` macros will utilize these casts. Otherwise, the macros will default to "C-style" casts.

- Namespaces -- ACE does not utilize namespaces. However, TAO will automatically take advantage of namespaces if the C++ compiler supports them, i.e., if `ACE_HAS_BROKEN_NAMESPACES` is not enabled.

- STL -- Unfortunately many of the platforms that ACE supports don't have an STL library. Moreover, different versions of STL behave differently. Therefore, ACE does not depends on STL and does not use it internally. If your target platform(s) support STL you should be able to use it with ACE and TAO without problems, though your C++ compiler may have problems with it (this is beyond the scope of ACE, however).

  If you are considering STL, you might consider STLport, which is a port of the SGI STL to numerous platforms that ACE and TAO also support.

Back to the ACE documentation page.