// $Id: README 77626 2007-03-09 01:07:44Z shuston $

ACE Portability Macros
----------------------

The following describes the meaning of the C++ compiler macros that
can be set in the config*.h file.  When you port ACE to a new platform
and/or C++ compiler, make sure that you check to see which of these
need to be defined.  It's helpful to check the various config*.h files
in this directory to see what's already been defined.  If you need to
add new macros, please send them to me and I'll add them to this file.

Eventually, most of this information should be auto-discovered via GNU
autoconf, which is currently available in the ACE distribution.

Macro                                   Description
-----                                   -----------

ACE_HAS_DUMP                            Used to enable the dump()
                                        method bodies.  If not
                                        defined, the bodies are ifdef
                                        out in order to reduce
                                        footprint.  By default, it is
                                        not defined.
ACE_CAST_CONST                          Used to work around broken
                                        SunCC ANSI casts that require
                                        an extra const.
ACE_DEFINES_DEFAULT_WIN32_SECURITY_ATTRIBUTES
                                        Win32 only.  Users want to use
                                        a predefined security
                                        attributes defined in
                                        ACE_OS::default_win32_security_attributes
                                        as the default security
                                        object.
ACE_DISABLE_DEBUG_DLL_CHECK             Define this if you don't want
                                        debug version ACE search for
                                        debug version DLLs first
                                        before looking for the DLL
                                        names specified.
ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER
                                        Application will allocate its
                                        own object manager.  This
                                        implicitly defines
                                        ACE_HAS_NONSTATIC_OBJECT_MANAGER.
                                        Usually used with MFC
                                        applications.
ACE_GETNAME_RETURNS_RANDOM_SIN_ZERO     Platform does not initialize
                                        sockaddr_in::sin_zero field in
                                        calls to getpeername() and
                                        getsockname().  As a result,
                                        memcmp()-based equality
                                        comparison can fail despite
                                        the fact two sockaddr_in
                                        instances refer to the same
                                        addr characteristics.
ACE_MAIN                                Renames "main (int, char *[])",
                                        for platforms such as g++/VxWorks
                                        that don't allow "main".  Requires
                                        the use of
                                        ACE_HAS_NONSTATIC_OBJECT_MANAGER.
ACE_MKDIR_LACKS_MODE                    This platform has a mkdir function with
                                        a mode argument
ACE_MT_SAFE                             Compile using multi-thread libraries
ACE_NDEBUG                              Turns off debugging features
ACE_NEW_THROWS_EXCEPTIONS               Compiler's 'new' throws exception on
                                        failure (ANSI C++ behavior).
ACE_NLOGGING                            Turns off the LM_DEBUG and
                                        LM_ERROR logging macros...
ACE_NTRACE                              Turns off the tracing feature when = 1.
ACE_HAS_TRACE                           Defined when ACE_NTRACE=0 to
                                        help support tracing.  Can
                                        also be defined by users who
                                        implement their own tracing
                                        macros based on
                                        ACE_TRACE_IMPL.  Not defining
                                        it helps reduce footprint by
                                        not requiring applications to
                                        link in Trace.o.
ACE_PAGE_SIZE                           Defines the page size of the
                                        system (not used on Win32 or
                                        with ACE_HAS_GETPAGESIZE).
ACE_REDEFINES_XTI_FUNCTIONS             Platform redefines the t_... names (UnixWare)
ACE_SELECT_USES_INT                     Platform uses int for select()
                                        rather than fd_set
ACE_TEMPLATES_REQUIRE_PRAGMA            Compiler's template mechanism
                                        must use a pragma This is used
                                        for AIX's C++ compiler.
ACE_TEMPLATES_REQUIRE_SOURCE            Compiler's template mechanim
                                        must see source code (i.e.,
                                        .cpp files).  This is used for
                                        GNU G++.
ACE_TIMEPROBE_ASSERTS_FIXED_SIZE        If enabled then ACE_Timeprobe_Ex<>::timeprobe()
                                        will assert if the end of the
                                        buffer is reached.  If disabled, the 
                                        counter wraps around to start
                                        at the beginning of the buffer.  
ACE_TIMER_SKEW                          If a timed ::select () can return
                                        early, then ACE_TIMER_SKEW is the
                                        maximum adjustment, in microseconds,
                                        that ACE_Timer_Queue uses to
                                        compensate for the early return.
ACE_TLI_TCP_DEVICE                      Device the platform uses for TCP on
                                        TLI.  Only needed if not /dev/tcp.
ACE_USE_POLL                            The OS platform supports the
                                        poll() event demultiplexor
ACE_USES_ASM_SYMBOL_IN_DLSYM            Platform uses assembly symbols
                                        instead of C symbols in
                                        dlsym()
ACE_USES_STATIC_MFC                     When linking MFC as a static library is desired
ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB   Platform has its standard c++
                                        library in the namespace std.
ACE_USES_EXPLICIT_STD_NAMESPACE         Set this when ::fclose doesn't
                                        work and you have to
                                        explicitly specify the std
                                        namespace.   This is needed
                                        with the Borland 6 and earlier
                                        compilers.
ACE_USES_GPROF                          ACE calls getitimer before spawning
                                        a new thread and setitimer
                                        after spawning the thread in
                                        order to overcome the problems
                                        of gprof with multithreaded
                                        applications. It uses the idea from
                                        http://sam.zoy.org/writings/programming/gprof.html
ACE_USES_FIFO_SEM                       Directs ACE to use FIFO based semaphores on
                                        platforms that support this (not having full
                                        POSIX semaphore support, supporting mkfifo, select
                                        and fcntl).
ACE_WSOCK_VERSION                       A parameter list indicating
                                        the version of WinSock (e.g.,
                                        "1, 1" is version 1.1).
ACE_HAS_AIO_CALLS                       Platform supports POSIX aio* calls.
                                        Corresponds to _POSIX_ASYNCHRONOUS_IO
                                        constant in <unistd.h>.
ACE_HAS_ALT_CUSERID                     Use ACE's alternate cuserid()
                                        implementation since a system
                                        cuserid() may not exist, or it
                                        is not desirable to use it.
                                        The implementation requires
                                        ACE_LACKS_PWD_FUNCTIONS to be
                                        undefined and that the
                                        geteuid() system call exists.
ACE_HAS_DINKUM_STL                      Using the Dinkum STL library
ACE_DEFAULT_THREAD_KEYS                 Number of TSS keys, with
                                        ACE_HAS_TSS_EMULATION _only_.
                                        Defaults to 64.
ACE_DEFAULT_LD_SEARCH_PATH              Specify the platform default search
                                        paths.  This macro should only be
                                        defined on platforms that don't
                                        support environment variables at all
                                        (i.e., Windows CE.)
ACE_THREADS_DONT_INHERIT_LOG_MSG        Specify this if you don't want
                                        threads to inherit parent
                                        thread's ACE_Log_Msg
                                        properties.
ACE_THREAD_MANAGER_USES_SAFE_SPAWN      Disable the "check before lock" feature
                                        in ACE_Thread_Manager.  Defining this
                                        macro avoids a potential race condition
                                        on platforms with aggressive read/write
                                        reordering.
ACE_HAS_CPU_SET_T                       Platform delivers cpu_set_t.
ACE_HAS_PRIOCNTL                        OS has priocntl (2).
ACE_HAS_RECURSIVE_MUTEXES               Mutexes are inherently recursive
                                        (e.g., Win32)
ACE_HAS_NONRECURSIVE_MUTEXES            In addition to recursive mutexes,
                                        platform has non-recursive ones also.
ACE_HAS_RECV_TIMEDWAIT                  Platform has the MIT pthreads
                                        APIs for
ACE_HAS_RECVFROM_TIMEDWAIT              timed send/recv operations
ACE_HAS_RECVMSG_TIMEDWAIT
ACE_HAS_RLIMIT_RESOURCE_ENUM            Platform has enum instead of
                                        int for first argument to
                                        ::{get,set}rlimit ().  The
                                        value of this macro is the
                                        enum definition, e.g., enum
                                        __rlimit_resource, for Linux
                                        glibc 2.0.
ACE_HAS_RUSAGE_WHO_ENUM                 Platform has enum instead of
                                        int for first argument to
                                        ::getrusage ().  The value of
                                        this macro is the enum
                                        definition, e.g., enum
                                        __rusage_who, for Linux glibc
                                        2.0.
ACE_HAS_SCANDIR                         Platform has a native scandir()
                                        function. Without any other scandir-
                                        related settings, it's assumed that
                                        the selector and comparator functions
                                        accept const ACE_DIRENT pointers.
ACE_SCANDIR_CMP_USES_VOIDPTR            The OS's scandir() comparator function
                                        is int (*compare)(void*, void*).
ACE_SCANDIR_CMP_USES_CONST_VOIDPTR      The OS's scandir() comparator function
                                        is int (*compare)(const void*,
                                                          const void*).
ACE_SCANDIR_SEL_LACKS_CONST             The OS's scandir() selector function
                                        is int (*selector)(ACE_DIRENT*)
ACE_HAS_SEND_TIMEDWAIT
ACE_HAS_SENDTO_TIMEDWAIT
ACE_HAS_SENDMSG_TIMEDWAIT
ACE_HAS_STDARG_THR_DEST                 Platform has void (*)(...)
                                        prototype for
                                        pthread_key_create()
                                        destructor (e.g., LynxOS).
ACE_HAS_STL_MAP_CONFLICT                Used when users want to
                                        compile ACE with STL and STL
                                        map class conflicts with
                                        <net/if.h> map struct.
ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS     Platform/compiler supports
                                        Win32 structural exceptions
ACE_HAS_READ_TIMEDWAIT
ACE_HAS_READV_TIMEDWAIT
ACE_HAS_WRITE_TIMEDWAIT
ACE_HAS_WRITEV_TIMEDWAIT
ACE_HAS_4_4BSD_SENDMSG_RECVMSG          Platform has BSD 4.4
                                        sendmsg()/recvmsg() APIs.
ACE_HAS_P_READ_WRITE                    Platform has pread() and
                                        pwrite() support
ACE_HAS_AIX_BROKEN_SOCKET_HEADER        Platform, such as AIX4, needs
                                        to wrap #include of
                                        sys/socket.h with
                                        #undef/#define of
                                        __cplusplus.
ACE_HAS_AIX_HI_RES_TIMER                Platform has AIX4
                                        ::read_real_time ()
ACE_HAS_ALLOCA                          Compiler/platform supports
                                        alloca()
ACE_HAS_ALLOCA_H                        Compiler/platform has
                                        <alloca.h>
ACE_HAS_ALPHA_TIMER                     CPU is an Alpha, with the rpcc
                                        instruction to read the tick timer.
                                        Limited to 32 bits, so not recommended.
ACE_HAS_AUTOMATIC_INIT_FINI             Compiler/platform correctly
                                        calls init()/fini() for shared
                                        libraries
ACE_HAS_BIG_FD_SET                      Compiler/platform has typedef
                                        u_long fdmask (e.g., Linux and
                                        SCO).
ACE_HAS_WORKING_EXPLICIT_TEMPLATE_DESTRUCTOR
                                        Compiler handles explicit calling of
                                        template destructor correctly. See
                                        "ace/OS.h" for details.
ACE_HAS_BROKEN_ACCEPT_ADDR              Platform can't correctly deal
                                        with a NULL addr to accept()
                                        (e.g, VxWorks).
ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS Compiler can't handle const char *
                                        as rvalue in conditional operator.
ACE_HAS_BROKEN_CONVERSIONS              Compiler can't handle calls
                                        like foo->operator T *()
ACE_HAS_BROKEN_CTIME                    Compiler/platform uses macro
                                        for ctime (e.g., MVS)
ACE_HAS_BROKEN_DGRAM_SENDV              Platform sendv() does not work
                                        properly with datagrams,
                                        i.e. it fails when the iovec
                                        size is IOV_MAX.
ACE_HAS_BROKEN_HPUX_TEMPLATES           Earlier versions of HP/UX C++
                                        are damned...
ACE_HAS_BROKEN_MAP_FAILED               Platform doesn't cast MAP_FAILED
                                        to a void *.
ACE_HAS_BROKEN_MSG_H                    Platform headers don't support
                                        <msg.h> prototypes
ACE_HAS_BROKEN_MMAP_H                   HP/UX does not wrap the
                                        mmap(2) header files with
                                        extern "C".
ACE_HAS_BROKEN_NESTED_TEMPLATES         MSVC has trouble with defining
                                        STL containers for nested
                                        structs and classes
ACE_HAS_BROKEN_POSIX_TIME               Platform defines struct
                                        timespec in <sys/timers.h>
ACE_HAS_BROKEN_RANDR                    OS/compiler's header files are
                                        inconsistent with libC
                                        definition of rand_r().
ACE_HAS_BROKEN_T_ERROR                  Compiler/platform has the wrong
                                        prototype for t_error(), i.e.,
                                        t_error(char *) rather than
                                        t_error(const char *).
ACE_HAS_BSTRING                         Platform has <bstring.h>
                                        (which contains bzero()
                                        prototype)
ACE_HAS_BYTESEX_H                       Platform has <bytesex.h>.
ACE_HAS_CANCEL_IO                       Platform supports the Win32
                                        CancelIO() function (WinNT 4.0
                                        and beyond).
ACE_HAS_CHARPTR_DL                      OS/platform uses char * for
                                        dlopen/dlsym args, rather than
                                        const char *.
ACE_HAS_CHARPTR_SOCKOPT                 OS/platform uses char * for
                                        sockopt, rather than const
                                        char *
ACE_HAS_CLOCK_GETTIME                   Platform supports POSIX.1b
                                        clock_gettime () at least for clock-id CLOCK_REALTIME
ACE_HAS_CLOCK_GETTIME_MONOTONIC         Platform supports POSIX.1b
                                        clock_gettime () with the clock-id CLOCK_MONOTONIC
ACE_HAS_CLOCK_SETTIME                   Platform supports POSIX.1b
                                        clock_settime ()
ACE_HAS_CONFLICTING_XTI_MACROS          OS's XTI header file defines some
                                        TCP-related macros that netinet/tcp.h
                                        also defines, but they conflict
                                        (only seen on HP-UX 11).
ACE_HAS_CONSISTENT_SIGNAL_PROTOTYPES    Prototypes for both signal()
                                        and struct sigaction are
                                        consistent.
ACE_HAS_CPLUSPLUS_HEADERS               Compiler/platform has
                                        correctly prototyped header
                                        files
ACE_HAS_DIRENT                          Compiler/platform has Dirent
                                        iterator functions
ACE_HAS_DLFCN_H_BROKEN_EXTERN_C         For platforms, e.g., RedHat
                                        4.2/Linux 2.0.30/Alpha, that
                                        don't declare dl* functions as
                                        extern "C" in dlfcn.h.
ACE_HAS_DLL                             Build ACE using the frigging
                                        PC DLL nonsense...
ACE_HAS_EBCDIC                          Compile in the ACE code set classes
                                        that support EBCDIC.
ACE_HAS_EXCEPTIONS                      Compiler supports C++
                                        exception handling
ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS    Compiler does not call
                                        unexpected exception handler
                                        if exception not listed in
                                        exception specification is
                                        thrown.  In particular, the
                                        exception specification is not
                                        respected.
ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION Compiler's template
                                        instantiation mechanism
                                        supports the use of explicit
                                        C++ specializations for all
                                        used templates. This is also
                                        used for GNU G++ if you don't
                                        use the "repo" patches.
ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT  When a base-class is a
                                        specialization of a class template
                                        then this class template must be
                                        explicitly exported
ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION  For the GCC compiler
                                        on AIX, HPUX and VxWorks we have to
                                        explicitly instantiate static template
                                        members else we get multiple instances
                                        of the same static.
ACE_HAS_GETPAGESIZE                     Platform supports
                                        getpagesize() call (otherwise,
                                        ACE_PAGE_SIZE must be defined,
                                        except on Win32)
ACE_HAS_GETRUSAGE                       Platform supports the
                                        getrusage() system call.
ACE_HAS_GETRUSAGE_PROTOTYPE             Platform has a getrusage ()
                                        prototype in sys/resource.h
                                        that differs from the one in
                                        ace/OS.i.
ACE_HAS_GNU_CSTRING_H                   Denotes that GNU has cstring.h
                                        as standard which redefines
                                        memchr()
ACE_HAS_GPERF                           The GPERF utility is compiled
                                        for this platform
ACE_HAS_GETIFADDRS                      This platform has ifaddrs.h and
                                        the getifaddrs() function.  This
                                        is used in preference to
                                        the SIOCGIFCONF ioctl call, since
                                        it is much simpler and supports
                                        IPv6 and non-IP interfaces better.
ACE_HAS_HANDLE_SET_OPTIMIZED_FOR_SELECT Optimize
                                        ACE_Handle_Set::count_bits for
                                        select() operations (common
                                        case)
ACE_HAS_LLSEEK                          Platform supports llseek.
ACE_HAS_HI_RES_TIMER                    Compiler/platform supports
                                        SunOS high resolution timers
ACE_HAS_IDTYPE_T                        Compiler/platform supports
                                        idtype_t.
ACE_HAS_INLINED_OSCALLS                 Inline all the static class OS
                                        methods to remove call
                                        overhead
ACE_HAS_IP_MULTICAST                    Platform supports IP multicast
ACE_HAS_IPV6                            Platform supports IPv6.
ACE_USES_IPV4_IPV6_MIGRATION            Enable IPv6 support in ACE on
                                        platforms that don't have IPv6
                                        turned on by default.
ACE_HAS_IPV6_V6ONLY                     Platform supports the IPPROTO_IPV6
                                        level IPV6_V6ONLY socket option.
ACE_HAS_IRIX62_THREADS                  Platform supports the very odd
                                        IRIX 6.2 threads...
ACE_HAS_NONSTATIC_OBJECT_MANAGER        Causes the ACE_Object_Manager
                                        instance to be created in main
                                        (int, char *[]), instead of as
                                        a static (global) instance.
ACE_HAS_THR_KEYDELETE                   Platform supports
                                        thr_keydelete (e.g,. UNIXWARE)
ACE_HAS_THR_MINSTACK                    Platform calls thr_minstack()
                                        rather than thr_min_stack()
                                        (e.g., Tandem).
ACE_HAS_LIMITED_RUSAGE_T                The rusage_t structure has
                                        only two fields.
ACE_HAS_LIMITED_SELECT                  The select is unable to deal with
                                        large file descriptors.
ACE_HAS_LINUX_NPTL                      Linux platform (with kernel >= 2.6.x)
                                        with GLibc including new NPTL (Native
                                        POSIX Thread Library).
                                        This triggers extended POSIX checks
                                        since the NPTL library is (almost) fully
                                        POSIX compliant.
ACE_HAS_LOG_MSG_NT_EVENT_LOG            Platform supports Windows NT event
                                        log so we can create an
                                        ACE_Log_Msg_Backend to log to it.
ACE_HAS_LONG_MAP_FAILED                 Platform defines MAP_FAILED as
                                        a long constant.
ACE_HAS_MALLOC_STATS                    Enabled malloc statistics
                                        collection.
ACE_HAS_MEMCHR                          Use native implementation of memchr.
ACE_HAS_MINIMAL_ACE_OS                  Disables some #includes in ace/OS.*.
ACE_HAS_MFC                             Platform supports Microsoft
                                        Foundation Classes
ACE_HAS_MSG                             Platform supports recvmsg and
                                        sendmsg
ACE_HAS_MT_SAFE_MKTIME                  Platform supports MT safe
                                        mktime() call (do any of
                                        them?)
ACE_HAS_MUTEX_TIMEOUTS                  Compiler supports timed mutex
                                        acquisitions
                                        (e.g. pthread_mutex_timedlock()).
ACE_HAS_NEW_NOTHROW                     Compiler offers new (nothrow).
ACE_HAS_NONCONST_CHDIR                  Platform uses non-const char *
                                        in call to chdir
ACE_HAS_NONCONST_CLOCK_SETTIME          Platform uses non-const
                                        struct timespec * in call to
                                        clock_settime
ACE_HAS_NONCONST_OPENDIR                Platform uses non-const char *
                                        in call to opendir
ACE_HAS_NONCONST_UNLINK                 Platform uses non-const char *
                                        in call to unlink
ACE_HAS_NONCONST_GETBY                  Platform uses non-const char *
                                        in calls to gethostbyaddr,
                                        gethostbyname, getservbyname
ACE_HAS_NONCONST_MSGSND                 Platform has a non-const
                                        parameter to msgsend() (e.g.,
                                        SCO).
ACE_HAS_NONCONST_READV                  Platform omits const qualifier from
                                        iovec parameter in readv() prototype.
ACE_HAS_NONCONST_SELECT_TIMEVAL         Platform's select() uses
                                        non-const timeval* (only found
                                        on Linux right now)
ACE_HAS_NONCONST_SENDMSG                Platform omits const qualifier
                                        from msghdr parameter in sendmsg()
                                        prototype.
ACE_HAS_NONCONST_SETRLIMIT              Platform omits const qualifier
                                        from rlimit parameter in setrlimit()
                                        prototype.
ACE_HAS_NONCONST_STAT                   Platform's stat function has non const
                                        name argument
ACE_HAS_NONCONST_SWAB                   Platform's swab function has non
                                        const src argument
ACE_HAS_NONCONST_WRITEV                 Platform omits const qualifier from
                                        iovec parameter in writev() prototype.
ACE_HAS_OLD_MALLOC                      Compiler/platform uses old
                                        malloc()/free() prototypes
                                        (ugh)
ACE_HAS_ONLY_SCHED_FIFO                 Platform, e.g., HP NonStop OSS,
                                        only supports SCHED_FIFO
                                        POSIX scheduling policy.
ACE_HAS_ONLY_SCHED_OTHER                Platform, e.g., Solaris 2.5,
                                        only supports SCHED_OTHER
                                        POSIX scheduling policy.
ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R   Uses ctime_r & asctime_r with
                                        only two parameters
                                        vs. three.
ACE_HAS_OSF_TIMOD_H                     Platform supports the OSF TLI
                                        timod STREAMS module
ACE_HAS_3_PARAM_WCSTOK                  Platform has 3-parameter version
                                        of wcstok(), which was added in
                                        1994 in the ISO C standard Normative
                                        Addendum 1.  Other standards like XPG4
                                        define a 2 parameter wcstok().
ACE_HAS_PENTIUM                         Platform is an Intel Pentium
                                        microprocessor.
ACE_HAS_POLL                            Platform contains <poll.h>
ACE_HAS_POSITION_INDEPENDENT_POINTERS   Platform supports
                                        "position-independent" features
                                        provided by ACE_Based_Pointer<>.
ACE_HAS_POSIX_MESSAGE_PASSING           Platform supports POSIX message queues.
                                        Corresponds to _POSIX_MESSAGE_PASSING
                                        constant in <unistd.h>.
ACE_HAS_POSIX_NONBLOCK                  Platform supports POSIX
                                        O_NONBLOCK semantics
ACE_HAS_POSIX_REALTIME_SIGNALS          Platform supports POSIX RT signals.
                                        Corresponds to _POSIX_REALTIME_SIGNALS
                                        constant in <unistd.h>.
ACE_HAS_POSIX_SEM                       Platform supports POSIX
                                        real-time semaphores (e.g.,
                                        VxWorks and Solaris).  Corresponds
                                        to _POSIX_SEMAPHORES constant
                                        in <unistd.h>
ACE_HAS_POSIX_SEM_TIMEOUT               Platform supports timed wait operation
                                        on POSIX realtime semaphores.
ACE_HAS_POSIX_TIME                      Platform supports the POSIX
                                        struct timespec type
ACE_HAS_PROC_FS                         Platform supports the /proc
                                        file system and defines tid_t
                                        in <sys/procfs.h>
ACE_HAS_POWERPC_TIMER                   Platform supports PowerPC
                                        time-base register.
ACE_HAS_PRUSAGE_T                       Platform supports the
                                        prusage_t struct
ACE_HAS_PTHREADS                        Platform supports POSIX
                                        Pthreads, of one form or
                                        another.  This macro says the
                                        platform has a pthreads
                                        variety - should also define
                                        one of the below to say which
                                        one.  Also may need some
                                        ACE_HAS_... thing for
                                        extensions.
ACE_HAS_PTHREADS_DRAFT4                 Platform's 'Pthreads' is .4a draft 4
ACE_HAS_PTHREADS_DRAFT6                 Platform's 'Pthreads' is .4a draft 6
ACE_HAS_PTHREADS_DRAFT7                 Platform's 'Pthreads' is .1c draft 7
ACE_HAS_PTHREADS_STD                    Platform supports POSIX.1c-1995 threads
                                        (This is the final standard
                                        Pthreads).
ACE_HAS_PTHREADS_UNIX98_EXT             Platform has the UNIX98 extensions to
                                        Pthreads (rwlocks)
ACE_HAS_PTHREAD_ATTR_SETCREATESUSPEND_NP  Platform has
					pthread_attr_setcreatesuspend_np().
ACE_HAS_PTHREAD_CONDATTR_SETKIND_NP     Platform has pthread_condattr_setkind_np().
ACE_HAS_PTHREAD_MUTEXATTR_SETKIND_NP    Platform has
                                        pthread_mutexattr_setkind_np().
ACE_HAS_PTHREAD_GETCONCURRENCY          Platform has pthread_getconcurrency().
ACE_HAS_PTHREAD_SETCONCURRENCY          Platform has pthread_setconcurrency().
ACE_HAS_PTHREAD_PROCESS_ENUM            pthread.h declares an enum with
                                        PTHREAD_PROCESS_PRIVATE and
                                        PTHREAD_PROCESS_SHARED values.
ACE_HAS_PTHREAD_SETSTACK                Platform has pthread_attr_setstack().
ACE_HAS_PTHREAD_NP_H                    Platform has <pthread_np.h>  FreeBSD
                                        declares non-portable (*_np) pthread
                                        functions in this header.
ACE_HAS_PURIFY                          Purify'ing.  Set by wrapper_macros.GNU.
ACE_HAS_QUANTIFY                        Quantify'ing.  Set by wrapper_macros.GNU.
ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS    Platform will recurse
                                        infinitely on thread exits
                                        from TSS cleanup routines
                                        (e.g., AIX).
ACE_HAS_REENTRANT_FUNCTIONS             Platform supports reentrant
                                        functions (i.e., all the POSIX
                                        *_r functions).
ACE_HAS_XPG4_MULTIBYTE_CHAR             Platform has support for
                                        multi-byte character support
                                        compliant with the XPG4
                                        Worldwide Portability
                                        Interface wide-character
                                        classification.
ACE_HAS_REGEX                           Platform supports the POSIX
                                        regular expression library
ACE_HAS_DLSYM_SEGFAULT_ON_INVALID_HANDLE For OpenBSD: The dlsym call
                                        segfaults when passed an invalid
                                        handle.  Other platforms handle
                                        this more gracefully.
ACE_HAS_SELECT_H                        Platform has special header for select().
ACE_USE_SELECT_REACTOR_FOR_REACTOR_IMPL For Win32: Use Select_Reactor
                                        as default implementation of
                                        Reactor instead of
                                        WFMO_Reactor.
ACE_HAS_SEMUN                           Compiler/platform defines a
                                        union semun for SysV shared
                                        memory
ACE_HAS_SET_T_ERRNO                     Platform has a function to set
                                        t_errno (e.g., Tandem).
ACE_HAS_SIGACTION_CONSTP2               Platform's sigaction() function takes
                                        const sigaction* as 2nd parameter.
ACE_HAS_SIGINFO_T                       Platform supports SVR4
                                        extended signals
ACE_HAS_SIGSUSPEND                      Platform supports sigsuspend()
ACE_HAS_SIGISMEMBER_BUG                 Platform has bug with
                                        sigismember() (HP/UX 11).
ACE_HAS_SIG_MACROS                      Platform/compiler has macros
                                        for sig{empty,fill,add,del}set
                                        (e.g., SCO and FreeBSD)
ACE_HAS_SIGNAL_OBJECT_AND_WAIT          Platform supports the Win32
                                        SignalObjectAndWait() function
                                        (WinNT 4.0 and beyond).
ACE_HAS_SIGWAIT                         Platform/compiler has the
                                        sigwait(2) prototype
ACE_HAS_SIG_ATOMIC_T                    Compiler/platform defines the
                                        sig_atomic_t typedef
ACE_HAS_SIG_C_FUNC                      Compiler requires extern "C"
                                        functions for signals.
ACE_HAS_SIZET_SOCKET_LEN                OS/compiler uses size_t *
                                        rather than int * for socket
                                        lengths
ACE_HAS_SOCKADDR_IN_SIN_LEN		Platform has sin_len member in struct
					sockaddr_in.
ACE_HAS_SOCKADDR_IN6_SIN_LEN		Platform has sin6_len member in struct
					sockaddr_in6.
ACE_HAS_SOCKADDR_MSG_NAME               Platform requires (struct
                                        sockaddr *) for msg_name field
                                        of struct msghdr.
ACE_HAS_SOCKLEN_T                       Platform provides socklen_t
                                        type, such as Linux with
                                        glibc2.
ACE_HAS_SOCK_BUF_SIZE_MAX               Platform limits the maximum socket
                                        message size.
ACE_HAS_SPARCWORKS_401_SIGNALS          Compiler has brain-damaged
                                        SPARCwork SunOS 4.x signal
                                        prototype...
ACE_HAS_SSIZE_T                         Compiler supports the ssize_t
                                        typedef
ACE_HAS_STHREADS                        Platform supports Solaris
                                        threads
ACE_HAS_STANDARD_CPP_LIBRARY            Platform/compiler supports
                                        Standard C++ Library
ACE_HAS_STRBUF_T                        Compiler/platform supports
                                        struct strbuf
ACE_HAS_STRDUP_EMULATION                Use ACE's strdup() emulation (even
					if platform has a native strdup()).
				        This is useful if you need control
					over what memory allocator is used.
ACE_HAS_WCSDUP_EMULATION                Use ACE's wcsdup() emulation (even
					if platform has a native wcsdup()).
				        This is useful if you need control
					over what memory allocator is used.
ACE_HAS_STRNLEN                         Platform supports strnlen(3).
ACE_HAS_STREAMS                         Platform supports STREAMS
ACE_HAS_STREAM_PIPES                    Platform supports STREAM pipes
ACE_HAS_STRERROR                        Compiler/platform supports strerror ()
ACE_HAS_STRICT                          Use the STRICT compilation mode on Win32.
ACE_HAS_STRING_CLASS                    Platform/Compiler supports a
                                        String class (e.g., GNU or
                                        Win32).
ACE_HAS_STRUCT_NETDB_DATA               Compiler/platform has strange
                                        hostent API for socket *_r()
                                        calls
ACE_HAS_SUNOS4_SIGNAL_T                 Compiler has horrible SunOS
                                        4.x signal handlers...
ACE_HAS_SVR4_DYNAMIC_LINKING            Compiler/platform supports
                                        SVR4 dynamic linking semantics
ACE_HAS_SVR4_GETTIMEOFDAY               Compiler/platform supports
                                        SVR4 gettimeofday() prototype
ACE_HAS_SVR4_SIGNAL_T                   Compiler/platform supports
                                        SVR4 signal typedef
ACE_HAS_SVR4_TLI                        Compiler/platform supports
                                        SVR4 TLI; that is, TLI with extensions
                                        like t_getname(). This is sometimes
                                        used as a pseudonym for TLI on SunOS4.
                                        This is a modifier to ACE_HAS_TLI and
                                        isn't used if ACE_HAS_XTI is set.
ACE_HAS_SYSCALL_GETRUSAGE               HP/UX has an undefined syscall
                                        for GETRUSAGE...
ACE_HAS_SYSENT_H                        Platform provides <sysent.h>
                                        header
ACE_HAS_SYSINFO                         Platform supports system
                                        configuration information
ACE_HAS_SYSV_IPC                        Platform supports System V IPC
                                        (most versions of UNIX, but
                                        not Win32)
ACE_HAS_SYS_ERRLIST                     Platform/compiler supports
                                        _sys_errlist symbol
ACE_HAS_SYS_FILIO_H                     Platform provides
                                        <sys/filio.h> header
ACE_HAS_SYS_LOADAVG_H                   Compiler/platform contains the
                                        <sys/loadavg.h> file.
ACE_HAS_SYS_PSTAT_H                     Compiler/platform contains the
                                        <sys/pstat.h> file.
ACE_HAS_SYS_SIGLIST                     Compiler/platform supports
                                        _sys_siglist array
ACE_HAS_SYS_SOCKIO_H                    Compiler/platform provides the
                                        sockio.h file
ACE_HAS_SYS_SYSCALL_H                   Compiler/platform contains the
                                        <sys/syscall.h> file.
ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA   Compiler's template
                                        instantiation mechanism
                                        supports the use of "#pragma
                                        instantiate".  Edison Design
                                        Group compilers, e.g., SGI C++
                                        and Green Hills 1.8.8 and
                                        later, support this.
ACE_HAS_TEMPLATE_SPECIALIZATION         Compiler implements template
                                        specialization
ACE_HAS_TEMPLATE_TYPEDEFS               Compiler implements templates
                                        that support typedefs inside
                                        of classes used as formal
                                        arguments to a template
                                        class.
ACE_HAS_TERMIO                          Platform has terminal ioctl
                                        flags like TCGETS and TCSETS and
                                        termio struct.
ACE_HAS_TERMIOS                         Platform has POSIX terminal
                                        interface and termios struct.
ACE_HAS_LAZY_MAP_MANAGER                ACE supports lazy Map Managers
                                        that allow deletion of entries
                                        during active iteration.
ACE_HAS_THREADS                         Platform supports threads
ACE_HAS_THREAD_SAFE_ACCEPT              Platform allows multiple
                                        threads to call accept() on
                                        the same port (e.g., WinNT).
ACE_HAS_THREAD_SELF                     Platform has thread_self()
                                        rather than pthread_self()
                                        (e.g., DCETHREADS and AIX)
ACE_HAS_THREAD_SPECIFIC_STORAGE         Compiler/platform has
                                        thread-specific storage
ACE_HAS_THR_C_DEST                      The pthread_keycreate()
                                        routine *must* take extern C
                                        functions.
ACE_HAS_THR_C_FUNC                      The pthread_create() routine
                                        *must* take extern C
                                        functions.
ACE_HAS_TIMEZONE                        Platform/compiler supports
                                        global "timezone" variable.
ACE_HAS_TIMEZONE_GETTIMEOFDAY           Platform/compiler supports
                                        timezone * as second parameter
                                        to gettimeofday()
ACE_HAS_TIMOD_H                         Platform supports TLI timod
                                        STREAMS module
ACE_HAS_TIUSER_H                        Platform provides TLI tiuser.h
                                        header file.
ACE_HAS_TLI                             Platform supports TLI.  Also
                                        see ACE_TLI_TCP_DEVICE. If the
                                        platform supports XTI, set ACE_HAS_XTI
                                        instead of this.
ACE_HAS_TLI_PROTOTYPES                  Platform provides TLI function
                                        prototypes
ACE_HAS_TR24731_2005_CRT                The platform provides an implementation
                                        of C99 draft TR24731 (October 2005),
                                        C run-time with more secure parameters.
ACE_HAS_TSS_EMULATION                   ACE provides TSS emulation.
                                        See also
                                        ACE_DEFAULT_THREAD_KEYS.
ACE_HAS_UALARM                          Platform supports ualarm()
ACE_HAS_UCONTEXT_T                      Platform supports ucontext_t
                                        (which is used in the extended
                                        signal API).
ACE_HAS_UNION_WAIT                      The wait() system call takes a
                                        (union wait *) rather than int
                                        *
ACE_HAS_UNIXWARE_SVR4_SIGNAL_T          Has inconsistent SVR4 signal
                                        stuff, but not the same as the
                                        other platforms
ACE_HAS_VALGRIND                        Running with valgrind
ACE_HAS_VERBOSE_NOTSUP                  Prints out console message in
                                        ACE_NOTSUP.  Useful for
                                        tracking down origin of
                                        ACE_NOTSUP.
ACE_HAS_VERSIONED_NAMESPACE             Wrap all library code within a
                                        "versioned namespace" to
                                        prevent symbol conflicts with
                                        other versions of ACE shared
                                        libraries in third party
                                        libraries.  Default namespace
                                        name may be overridden by
                                        defining preprocessor symbol
                                        ACE_VERSIONED_NAMESPACE_NAME
                                        to desired name.
ACE_LACKS_INTMAX_T                      Platform lacks the intmax_t type
ACE_LACKS_UINTMAX_T			Platform lacks the uintmax_t type.
ACE_LACKS_INTPTR_T                      Platform lacks the intptr_t type
ACE_LACKS_UINTPTR_T			Platform lacks the uintptr_t type.

ACE_HAS_INT8_T                          Platform provides the int8_t type.
ACE_HAS_INT16_T                         Platform provides the int16_t type.
ACE_HAS_INT32_T                         Platform provides the int32_t type.
ACE_HAS_INT64_T                         Platform provides the int64_t type.
ACE_HAS_UINT8_T                         Platform provides the uint8_t type.
ACE_HAS_UINT16_T                        Platform provides the uint16_t type.
ACE_HAS_UINT32_T                        Platform provides the uint32_t type.
ACE_HAS_UINT64_T                        Platform provides the uint64_t type.

ACE_INT8_TYPE                           Specific type to use for ACE_INT8.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_INT16_TYPE                          Specific type to use for ACE_INT16.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_INT32_TYPE                          Specific type to use for ACE_INT32.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_INT64_TYPE                          Specific type to use for ACE_INT64.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_UINT8_TYPE                          Specific type to use for ACE_UINT8.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_UINT16_TYPE                         Specific type to use for ACE_UINT16.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_UINT32_TYPE                         Specific type to use for ACE_UINT32.
                                        If not defined, ACE will attempt to
                                        determine the correct type.
ACE_UINT64_TYPE                         Specific type to use for ACE_UINT64.
                                        If not defined, ACE will attempt to
                                        determine the correct type.

ACE_INT8_FORMAT_SPECIFIER               String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_INT8 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_INT16_FORMAT_SPECIFIER              String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_INT16 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_INT32_FORMAT_SPECIFIER              String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_INT32 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_INT64_FORMAT_SPECIFIER              String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_INT64 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_UINT8_FORMAT_SPECIFIER              String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_UINT8 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_UINT16_FORMAT_SPECIFIER             String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_UINT16 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_UINT32_FORMAT_SPECIFIER             String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_UINT32 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.
ACE_UINT64_FORMAT_SPECIFIER             String literal containing *printf
                                        format specifier (including the '%')
                                        to be used for ACE_UINT64 values.  If
                                        not defined, ACE will attempt to
                                        determine the correct setting.

ACE_HAS_VOIDPTR_GETTIMEOFDAY            Platform/compiler supports
                                        void * as second parameter
                                        to gettimeofday
ACE_HAS_VOIDPTR_MMAP                    Platform requires void * for
                                        mmap().
ACE_HAS_VOIDPTR_SOCKOPT                 OS/compiler uses void * arg 4
                                        setsockopt() rather than const
                                        char *
ACE_HAS_WCSNLEN                         Platform supports wcsnlen(3).
ACE_HAS_WIN32_OVERLAPPED_IO             Platform has Windows overlapped I/O;
                                        requires I/O completion ports.
ACE_HAS_WIN32_TRYLOCK                   The Win32 platform support
                                        TryEnterCriticalSection()
                                        (WinNT 4.0 and beyond)
ACE_HAS_WINSOCK2                        The Win32 platform supports
                                        WinSock 2.0
ACE_HAS_XLI                             Platform has the XLI version
                                        of TLI
ACE_HAS_XTI                             Platform has XTI
                                        (X/Open-standardized superset
                                        of TLI).  Implies ACE_HAS_TLI
                                        but uses a different header
                                        file.
ACE_INITIALIZE_MEMORY_BEFORE_USE        Memory is explicitly initialized before
                                        use. Useful when using a profiler like
                                        purify or valgrind
ACE_HRTIME_T_IS_BASIC_TYPE              ACE_hrtime_t is a basic type that
                                        doesn't require ACE_U64_TO_U32
                                        conversion
ACE_LACKS_ACCESS                        Platform lacks access() (e.g.,
                                        VxWorks and Chorus)
ACE_LACKS_ACE_IOSTREAM                  Platform can not build
                                        ace/IOStream{,_T}.cpp.  This
                                        does not necessarily mean that
                                        the platform does not support
                                        iostreams.
ACE_LACKS_AUTO_MMAP_REPLACEMENT         No system support for replacing any
                                        previous mappings.
ACE_LACKS_BSEARCH                       Compiler/platform lacks the
                                        standard C library bsearch()
                                        function
ACE_LACKS_CLEARERR                      Platform lacks the clearerr system
                                        call.
ACE_LACKS_CLOSEDIR                      Platform lacks closedir and the closedir
                                        emulation must be used
ACE_LACKS_OPENDIR                       Platform lacks opendir and the opendir
                                        emulation must be used
ACE_LACKS_READDIR                       Platform lacks readdir and the readdir
                                        emulation must be used
ACE_LACKS_CMSG_DATA_MACRO               Platform has
                                        ACE_HAS_4_4BSD_SENDMSG_RECVMSG but does
                                        not define CMSG_DATA (cmsg) macro.
ACE_LACKS_CMSG_DATA_MEMBER              Platform has
                                        ACE_HAS_4_4BSD_SENDMSG_RECVMSG but its
                                        cmsghdr structure does not contain
                                        an 'unsigned char cmsg_data[0]'
                                        member.  (This may be
                                        'unsigned char __cmsg_data[0]' on some
                                        platforms, in which case we need
                                        another macro.)
ACE_LACKS_COND_TIMEDWAIT_RESET          pthread_cond_timedwait does
                                        *not* reset the time argument
                                        when the lock is acquired.
ACE_LACKS_CONST_STRBUF_PTR              Platform uses struct strbuf *
                                        rather than const struct
                                        strbuf * (e.g., HP/UX 10.x)
ACE_LACKS_CONST_TIMESPEC_PTR            Platform forgot const in
                                        cond_timewait (e.g., HP/UX).
ACE_LACKS_COND_T                        Platform lacks condition
                                        variables (e.g., Win32 and
                                        VxWorks)
ACE_LACKS_CONDATTR_PSHARED              Platform has no implementation
                                        of
                                        pthread_condattr_setpshared(),
                                        even though it supports
                                        pthreads!
ACE_LACKS_DIFFTIME                      Platform lacks difftime() implementation
ACE_LACKS_DUP2                          Platform lacks dup2().
ACE_LACKS_FCNTL                         Platform lacks POSIX-style fcntl ().
ACE_LACKS_FSYNC                         Platform lacks fsync().
ACE_LACKS_INLINE_FUNCTIONS              Platform can't handle "inline"
                                        keyword correctly.
ACE_LACKS_EXEC                          Platform lacks the exec()
                                        family of system calls (e.g.,
                                        Win32, VxWorks, Chorus)
ACE_LACKS_FILELOCKS                     Platform lacks file locking
                                        mechanism
ACE_LACKS_FLOATING_POINT                Platform does not support
                                        floating point operations
                                        (e.g., certain Chorus hardware
                                        platforms)
ACE_LACKS_FORK                          Platform lacks the fork()
                                        system call (e.g., Win32,
                                        VxWorks, Chorus)
ACE_LACKS_GETOPT_PROTOTYPE              Platform lacks the getopt()
                                        prototype (e.g., LynxOS)
ACE_LACKS_GETPGID                       Platform lacks getpgid() call
                                        (e.g., Win32, Chorus, and
                                        FreeBSD).
ACE_LACKS_GETSERVBYNAME                 Platforms lacks
                                        getservbyname() (e.g., VxWorks
                                        and Chorus).
ACE_LACKS_GETIPNODEBYADDR               Platform lacks getipnodebyaddr().
ACE_LACKS_GETIPNODEBYNAME               Platform lacks getipnodebyname().
ACE_LACKS_INET_ATON                     Platform lacks the inet_aton()
                                        function.
ACE_LACKS_INET_ATON_PROTOTYPE           Platform/compiler lacks the
                                        inet_aton() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_IOSTREAMS_TOTALLY             Iostreams are not supported
                                        adequately on the given platform.
ACE_LACKS_IOSTREAM_FX                   iostream header does not
                                        declare ipfx (), opfx (),
                                        etc.
ACE_LACKS_KEY_T                         Platform lacks key_t (e.g.,
                                        Chorus, VxWorks, Win32)
ACE_LACKS_LINEBUFFERED_STREAMBUF        Platform lacks streambuf
                                        "linebuffered ()".
ACE_LACKS_LONGLONG_T                    Compiler/platform does not
                                        support the signed or unsigned long
                                        long datatype.
ACE_LACKS_LSTAT                         Platform lacks the lstat() function.
ACE_LACKS_MADVISE                       Platform lacks madvise()
                                        (e.g., Linux)
ACE_LACKS_MALLOC_H                      Platform lacks malloc.h
ACE_LACKS_MEMORY_H                      Platform lacks memory.h (e.g.,
                                        VxWorks and Chorus)
ACE_LACKS_MKFIFO                        Platform lacks mkfifo() e.g.,
                                        VxWorks, Chorus, pSoS, and WinNT.
ACE_LACKS_MKTEMP                        Platform lacks the mktemp() function.
ACE_LACKS_MKTEMP_PROTOTYPE              Platform/compiler lacks the
                                        mktemp() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_MKSTEMP			Platform lacks the mkstemp() function.
ACE_LACKS_MKSTEMP_PROTOTYPE             Platform/compiler lacks the
                                        mkstemp() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_MMAP                          The platform doesn't have
                                        mmap(2) (e.g., SCO UNIX).
ACE_LACKS_MODE_MASKS                    Platform/compiler doesn't have
                                        open() mode masks.
ACE_LACKS_MPROTECT                      The platform doesn't have
                                        mprotect(2) (e.g., EPLX real
                                        time OS from CDC (based on
                                        LYNX))
ACE_LACKS_MSG_ACCRIGHTS                 Platform defines ACE_HAS_MSG,
                                        but lacks msg_accrights{,len}.
ACE_LACKS_MSG_WFMO                      Platform lacks
                                        MsgWaitForMultipleObjects
                                        (only needs to be defined when
                                        ACE_WIN32 is also defined).
ACE_LACKS_MSYNC                         Platform lacks msync() (e.g.,
                                        Linux)
ACE_LACKS_MUTEXATTR_PSHARED             Platform lacks
                                        pthread_mutexattr_setpshared().
ACE_LACKS_NAMED_POSIX_SEM               Platform lacks named POSIX
                                        semaphores (e.g., Chorus)
ACE_LACKS_NETDB_REENTRANT_FUNCTIONS     Platform does not support
                                        reentrant netdb functions
                                        (getprotobyname_r,
                                        getprotobynumber_r,
                                        gethostbyaddr_r,
                                        gethostbyname_r,
                                        getservbyname_r).
ACE_LACKS_NEW_H                         OS doesn't have, or we don't want to
                                        use, new.h.
ACE_LACKS_NULL_PTHREAD_STATUS           OS requires non-null status pointer
                                        for ::pthread_join ().
ACE_LACKS_NUMERIC_LIMITS		Platform lacks std::numeric_limits<>.
ACE_LACKS_PERFECT_MULTICAST_FILTERING   Platform lacks IGMPv3 "perfect" filtering
                                        of multicast dgrams at the socket level.
                                        If == 1, ACE_SOCK_Dgram_Mcast will bind
                                        the first joined multicast group to the
                                        socket, and all future joins on that
                                        socket will fail with an error.
ACE_LACKS_PRAGMA_ONCE                   Compiler complains about #pragma once
ACE_LACKS_PRI_T                         Platform lacks pri_t (e.g.,
                                        Tandem NonStop UNIX).
ACE_LACKS_PTHREAD_CANCEL                Platform lacks
                                        pthread_cancel().
ACE_LACKS_PTHREAD_SIGMASK               Platform lacks pthread_sigmask ().
ACE_LACKS_PTHREAD_THR_SIGSETMASK        Platform lacks
                                        pthread_thr_sigsetmask (e.g.,
                                        MVS, HP/UX, and OSF/1 3.2)
ACE_LACKS_PUTENV_PROTOTYPE              Platform/compiler lacks the
                                        putenv() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_PWD_REENTRANT_FUNCTIONS       Platform lacks getpwnam_r()
                                        methods (e.g., SGI 6.2).
ACE_LACKS_SID                           Platform lacks setsid()
ACE_LACKS_QSORT                         Compiler/platform lacks the
                                        standard C library qsort()
                                        function
ACE_LACKS_RAND_REENTRANT_FUNCTIONS      Platform lacks rand_r()
ACE_LACKS_READLINK                      Platform lacks the readlink() function.
ACE_LACKS_READV                         Platform doesn't define readv,
                                        so use our own
ACE_LACKS_RENAME                        Platform lacks rename().
ACE_LACKS_RLIMIT                        Platform/compiler lacks
                                        {get,set}rlimit() function
                                        (e.g., VxWorks, Chorus, and
                                        SCO UNIX)
ACE_LACKS_RLIMIT_PROTOTYPE              Platform/compiler lacks
                                        {get,set}rlimit() prototypes
                                        (e.g., Tandem)
ACE_LACKS_READDIR_R                     Platform uses ACE_HAS_DIRENT
                                        but does not have readdir_r
                                        ().
ACE_LACKS_REALPATH                      Platform/compiler lacks
                                        realpath () function (e.g.,
                                        LynxOS)
ACE_LACKS_RECVMSG                       Platform lacks recvmsg()
                                        (e.g., Linux)
ACE_LACKS_RWLOCK_T                      Platform lacks readers/writer
                                        locks.
ACE_LACKS_RWLOCKATTR_PSHARED            Platform lacks
                                        pthread_rwlockattr_setpshared().
ACE_LACKS_SBRK                          Platform lacks a working
                                        sbrk() (e.g., Win32 and
                                        VxWorks)
ACE_LACKS_SCANDIR_PROTOTYPE             Platform/compiler lacks
                                        scandir() prototype
                                        (e.g., LynxOS)
ACE_LACKS_SEEKDIR                       Platform uses ACE_HAS_DIRENT
                                        but does not have seekdir ().
ACE_LACKS_SEMBUF_T                      Platform lacks struct sembuf
                                        (e.g., Win32 and VxWorks)
ACE_LACKS_SETDETACH                     Platform lacks
                                        pthread_attr_setdetachstate()
                                        (e.g., HP/UX 10.x)
ACE_LACKS_SETSCHED                      Platform lacks
                                        pthread_attr_setsched()
                                        (e.g. MVS)
ACE_LACKS_SIGACTION                     Platform lacks struct
                                        sigaction (e.g., Win32 and
                                        Chorus)
ACE_LACKS_SIGNED_CHAR                   Platform lacks "signed char"
                                        type (broken!)
ACE_LACKS_SIGSET                        Platform lacks signal sets
                                        (e.g., Chorus and Win32)
ACE_LACKS_STRPTIME                      Platform/compiler lacks the strptime()
                                        function.
ACE_LACKS_STRCHR			Platform/compiler lacks strchr()
ACE_LACKS_WCSCHR			Platform/compiler lacks wcschr()
ACE_LACKS_STRDUP			Platform/compiler lacks strdup()
ACE_LACKS_WCSDUP			Platform/compiler lacks wcsdup()
ACE_LACKS_STRRCHR                       Platform/compiler lacks strrchr()
ACE_LACKS_WCSRCHR                       Platform/compiler lacks wcsrchr()
ACE_LACKS_SWAB                          Platform/compiler lacks
                                        swab () function.
ACE_LACKS_SYS_MSG_H                     Platform lacks sys/msg.h
                                        (e.g., Chorus and VxWorks)
ACE_LACKS_SYS_PARAM_H                   Platform lacks <sys/param.h>
                                        (e.g., MVS)
ACE_LACKS_SENDMSG                       Platform lacks sendmsg()
                                        (e.g., Linux)
ACE_LACKS_SI_ADDR                       Platform lacks the si_addr
                                        field of siginfo_t (e.g.,
                                        VxWorks and HP/UX 10.x)
ACE_LACKS_SYMLINKS                      Platform lacks symbolic links
ACE_LACKS_SYSV_SHMEM                    Platform lacks System V shared
                                        memory (e.g., Win32 and
                                        VxWorks)
ACE_LACKS_SIGINFO_H                     Platform lacks the siginfo.h
                                        include file (e.g., MVS)
ACE_LACKS_SOCKET_BUFSIZ                 Platform doesn't support
                                        SO_SNDBUF/SO_RCVBUF
ACE_LACKS_SOCKETPAIR                    Platform lacks the
                                        socketpair() call (e.g., SCO
                                        UNIX)
ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES  Compiler doesn't support
                                        static data member templates
ACE_LACKS_STRCASECMP                    Compiler/platform lacks
                                        strcasecmp() (e.g., DG/UX,
                                        UNIXWARE, VXWORKS)
ACE_LACKS_STRCASECMP_PROTOTYPE          Platform/compiler lacks the
                                        strcasecmp() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_STRNCASECMP_PROTOTYPE         Platform/compiler lacks the
                                        strncasecmp() prototype (e.g.,
                                        LynxOS)
ACE_LACKS_STRRECVFD                     Platform doesn't define struct
                                        strrecvfd.
ACE_LACKS_SYSCALL                       Platform doesn't have
                                        syscall() prototype
ACE_LACKS_T_ERRNO                       Header files lack t_errno for
                                        TLI
ACE_LACKS_TCP_NODELAY                   OS does not support TCP_NODELAY.
ACE_LACKS_TELLDIR                       Platform uses ACE_HAS_DIRENT
                                        but does not have telldir ().
ACE_LACKS_THREAD_STACK_SIZE             Platform lacks
                                        pthread_attr_setstacksize()
                                        (e.g., Linux pthreads)
ACE_LACKS_THR_CONCURRENCY_FUNCS		(ONLY APPLIES TO SOLARIS)
					Platform does not support
					thr_getconcurrency/thr_setconcurrency
					functions, or their implementation
					is effectively a "no-op".  This
					notably applies for Solaris >= 5.9.
					Note that if you build on Solaris 8
					and run on Solaris 9+, you can
					encounter thread creation errors
					unless you rebuild on the target
					platform.
ACE_LACKS_TIMEDWAIT_PROTOTYPES          MIT pthreads platform lacks
                                        the timedwait prototypes
ACE_LACKS_TIMESPEC_T                    Platform does not define
                                        timepec_t as a typedef for
                                        struct timespec.
ACE_LACKS_TRUNCATE                      Platform doesn't have truncate()
                                        (e.g., vxworks)
ACE_LACKS_U_LONGLONG_T                  Platform does not have
                                        u_longlong_t typedef, and
                                        "sun" is defined.
ACE_LACKS_UALARM_PROTOTYPE              Platform/compiler lacks the
                                        ualarm() prototype (e.g.,
                                        Solaris)
ACE_LACKS_CHAR_RIGHT_SHIFTS             Compiler does not have any istream
                                        operator>> for chars, u_chars, or
                                        signed chars.
ACE_LACKS_CHAR_STAR_RIGHT_SHIFTS        Compiler does not have
                                        operator>> (istream &, u_char *) or
                                        operator>> (istream &, signed char *)
ACE_LACKS_UCONTEXT_H                    Platform lacks the ucontext.h
                                        file
ACE_LACKS_UMASK                         Platform lacks umask function
ACE_LACKS_UNBUFFERED_STREAMBUF          Platform lacks streambuf
                                        "unbuffered ()".
ACE_LACKS_UNISTD_H                      Platform lacks the unistd.h
                                        file (e.g., VxWorks and Win32)
ACE_LACKS_UNIX_DOMAIN_SOCKETS           ACE platform has no UNIX
                                        domain sockets
ACE_LACKS_UNIX_SIGNALS                  Platform lacks full signal
                                        support (e.g., Win32 and
                                        Chorus).
ACE_LACKS_UNSIGNEDLONGLONG_T            Compiler/platform does not
                                        support the unsigned long
                                        long datatype.
ACE_LACKS_UTSNAME_T                     Platform lacks struct utsname
                                        (e.g., Win32 and VxWorks)
ACE_LACKS_UNAME                         Platform lacks uname calls
ACE_LACKS_WAIT                          The platform lacks wait
ACE_LACKS_WILDCARD_BIND                 The bind() call will not
                                        select the port if it's 0.
ACE_LACKS_WIN32_GETPROCESSTIMES         The Windows platform doesn't have
                                        GetProcessTimes().
ACE_LACKS_WIN32_MOVEFILEEX              The Windows platform doesn't have
                                        MoveFileEx().
ACE_LACKS_WIN32_SECURITY_DESCRIPTORS    The Windows platform doesn't have
                                        security descriptor support.
ACE_LACKS_WRITEV                        Platform doesn't define
                                        writev, so use our own

ACE_LEGACY_MODE                         When defined, it will enable
                                        some code that is used to
                                        provide some support for
                                        backwards compatibility.

ACE_NEEDS_DEV_IO_CONVERSION             Necessary with some compilers
                                        to pass ACE_TTY_IO as
                                        parameter to DEV_Connector.
ACE_NEEDS_FUNC_DEFINITIONS              Compiler requires a definition
                                        for a "hidden" function, e.g.,
                                        a private, unimplemented copy
                                        constructor or assignment
                                        operator.  The SGI C++
                                        compiler needs this, in
                                        template classes, with
                                        ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA.
ACE_NEEDS_HUGE_THREAD_STACKSIZE         Required by platforms with
                                        small default stacks.
ACE_NEEDS_LWP_PRIO_SET                  OS has LWPs, and when the
                                        priority of a bound thread is
                                        set, then the LWP priority
                                        must be set also.
ACE_NEEDS_SCHED_H                       Platform needs to #include
                                        <sched.h>
                                        to get thread scheduling
                                        defs.

ACE_NO_WIN32_LEAN_AND_MEAN              If this is set, then ACE does not
                                        define WIN32_LEAN_AND_MEAN before
                                        including <windows.h>. Needed for
                                        code that uses non-lean Win32
                                        facilities such as COM.

ACE_ONLY_LATEST_AND_GREATEST            A macro that indicates that
                                        the "latest and greatest"
                                        features of ACE/TAO should be
                                        turned on.  It has been
                                        replaced by ACE_LEGACY_MODE,
                                        which has the opposite meaning
                                        but serves the same purpose.

ACE_SHM_OPEN_REQUIRES_ONE_SLASH         The path specified on shm_open() must
                                        have a leading, single slash and not
                                        have any other slashes.

ACE_WSTRING_HAS_USHORT_SUPPORT          If a platform has wchar_t as a
                                        separate type, then
                                        ACE_WString doesn't have a
                                        constructor that understands
                                        an ACE_USHORT16 string.  So
                                        this macro enables
                                        one. (mostly used my ACE Name
                                        Space).

ACE_HAS_BROKEN_PREALLOCATED_OBJECTS_AFTER_FORK
                                        Under QNX/RTP the objects preallocated
                                        in ACE_OS_Object_Manager cannot be
                                        destroyed after a fork() call.
                                        Since these objects are only destroyed
                                        at application shutdown we take the
                                        simpler approach of not destroying
                                        them at all.
                                        Both QNX/RTP and LynxOS suffer from
                                        this problem.

ACE_LACKS_MEMBER_TEMPLATES              Compiler does not support
                                        member template feature.

ACE_LACKS_DEPRECATED_MACROS             When this define is set, macros which
                                        are deprecated are not defined. Usefull
                                        to check whether deprecated macros are
                                        not used anymore.

ACE_DONT_INIT_WINSOCK                   This definition defines whether or not
                                        to explicitly initialize Winsock during
                                        ACE::init() (i.e., whether WSAStartup()
                                        is called). Some Win32 platforms have
                                        dependent characteristics between
                                        ACE initialization and
                                        network initialization.

----------------------------------------

The following macros determine the svc.conf file format ACE uses.

Macro                                   Description
-----                                   -----------
ACE_HAS_CLASSIC_SVC_CONF                This macro forces ACE to use
                                        the classic svc.conf format.

ACE_HAS_XML_SVC_CONF                    This macro forces ACE to use the XML
                                        svc.conf format.

ACE_USES_CLASSIC_SVC_CONF               This macro should be defined
                                        as 0 or 1, depending on the
                                        preferred svc.conf file
                                        format.  Defining this macro
                                        to 0 means ACE will use XML
                                        svc.conf file format.
                                        Defining it to 1 will force
                                        ACE to use the classic
                                        svc.conf format.
                                        ** This macro takes precedence
                                        ** over previous two macros.

----------------------------------------
The following is a partial list of where some of these macros are used
in the code.  This list was originally compiled by Jam Hamidi
(jh1@core01.osi.com).  It is now hopelessly out of date.  Hopefully,
someone will come along and update it....

ACE_HAS_ALLOCA:
---------------

  Used in:
     libsrc/IPC_SAP/SOCK_SAP/SOCK_Connect.C
        for allocation of iovp
A
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE_Msg.C
        for alocation of iovp

  In solaris:
     alloca() allocates size bytes of space in the stack frame of
     the  caller,  and  returns a pointer to the allocated block.
     This temporary space is automatically freed when the  caller
     returns.  Note: if the allocated block is beyond the current
     stack limit, the resulting behavior is undefined.

  In HPUX:
     no equivalent.

  Notes:
     in HPUX it has to do new and delete. Affects performance.


ACE_HAS_AUTOMATIC_INIT_FINI:
----------------------------

  Used in:
     libsrc/Service_Configurator/Service_Repository.i
     libsrc/Service_Configurator/Parse_Node.i
     include/Parse_Node.i
     include/Service_Repository.i

  In solaris:
     _init() initializes a loadable module. It is  called  before
     any other routine in a loadable module.
     _info()  returns  information  about  a   loadable   module.
     _fini() should return the return value from mod_remove(9F).
     This flag if set, doesn't do anything.  If not set, forces
     _init() and _fini() to be executed as is:
       dlsym ((char *) handle, "_fini").

  In HPUX:
     don't set.
     Maybe have to look into shl_load( ), shl_definesym( ),
     shl_findsym( ), shl_gethandle( ), shl_getsymbols( ),
     shl_unload( ), shl_get( )(3X) - explicit load of shared libraries
     Means Service Configurator won't be available.
     TBA.


ACE_HAS_CPLUSPLUS_HEADERS:
--------------------------

  Used In:
     ace/OS.h

  HPUX:
     set it.

  Notes:
     If this is not defined, libc.h and osfcn.h get included.
     Only needed for older compiler/OS platforms that don't
     provide standard C++ header files in /usr/include.

ACE_HAS_HI_RES_TIMER:
---------------------

  Used In:
     libsrc/Misc/High_Res_Timer.h
     libsrc/Misc/High_Res_Timer.C
     include/High_Res_Timer.h

  In Solaris,
     C++ wrapper around gethrtime(), which returns a long long.
         gethrtime() returns the current high-resolution  real  time.
     Time  is  expressed as nanoseconds since some arbitrary time
     in the past; it is not correlated in any way to the time  of
     day,  and  thus  is not subject to resetting, drifting, etc.

  In HPUX
     look into: getclock(), reltimer(), getitimer()
     maybe even vtimes structure vm_utime, vm_stime ?

  Notes:
     TBA


ACE_LACKS_T_ERRNO:
-------------------

  Used In:
     ace/OS.h

  HPUX:
     set it.

  Notes:
     if set, adds:
     extern int t_errno;


ACE_HAS_POSIX_NONBLOCK:
-----------------------

  Used in:
     ace/OS.h

  HPUX:
     set it.

  Notes:
     if defined, sets ACE_NONBLOCK and O_NONBLOCK
     O_NONBLOCK is used in libsrc/Misc/misc.C to do a
       fcntl (fd, F_SETFL, opt)
     ACE_NONBLOCK is used in libsrc/IPC_SAP/FIFO_SAP/FIFO_Recv.C in the
       disable member function and options passed to the open function
       in libsrc/IPC_SAP/FIFO_SAP/FIFO.C


ACE_HAS_PROC_FS:
----------------

  Used in:
     ace/OS.h
     libsrc/Misc/Profile_Timer.i

  Notes:
     if set, includes <sys/procfs.h>
     the PIOCUSAGE define is used in Profile_Timer.

  Solaris:
     procfs.h defines things for the prpsinfo structure (basically to
     do a "ps" from inside a program).

  HPUX:
     don't set: obviously a different mechanism.
     Look into /usr/include/sys/proc.h.  The structure is proc.  The
     pointer to the kernel's proc table may be obtained by
     extern  struct  proc *proc, *procNPROC;
     extern  int nproc;


ACE_HAS_PRUSAGE_T:
------------------

  Used in:
     libsrc/Misc/Profile_Timer.h
     libsrc/Misc/Profile_Timer.C

  Notes:
     If defined, declares the Profile_Timer class that does start(),
     stop() and basically gets real_time, user_time, system_time for
     an interval.
     This stuff is highly non-portable.

  HPUX:
     don't set


ACE_HAS_SEMUN:
--------------

  Used in:
     libsrc/Semaphores/Semaphore_Simple.h

  Notes:
     if not defined, defines semun as:
     union semun {
           int          val;    /* value for SETVAL */
           struct semid_ds      *buf;   /* buffer for IPC_STAT & IPC_SET */
           ushort               *array; /* array for GETALL & SETALL */
     };

  HPUX:
     don't set.
     in /usr/include/sem.h:
     /* The fourth argument to semctl() varies depending on the value of
       its first argument.  If desired, "union semun" can be declared
       by the user, but this is not necessary since the individual
       member can just be passed as the argument. */


ACE_HAS_SIG_ATOMIC_T:
---------------------

  Used in:
     ace/OS.h

  Notes:
     if not defined, does a:
     typedef int sig_atomic_t;
     This is used in the Reactor and service configurator.

  HPUX:
     set it.
     in /usr/include/sys/signal.h:
     typedef unsigned int sig_atomic_t;


ACE_HAS_SSIZE_T:
----------------

  Used in:
     ace/OS.h

  Notes:
     if not defined, does a
     typedef int ssize_t;
     used mostly in IPC_SAP.  (don't confuse with size_t).

  HPUX:
     set it.
     in /usr/include/sys/types.h


ACE_HAS_STRBUF_T:
-----------------

  Used in:
     include/Str_Buf.h

  Notes:
     if not defined, declares the strbuf structure as:
     struct strbuf
     {
       int      maxlen;                 /* no. of bytes in buffer */
       int      len;                    /* no. of bytes returned */
       void     *buf;                   /* pointer to data */
     };

  Solaris:
     defined in /usr/include/sys/stropts.h
     Sys V.4 Streams.
     uses strbuf as parameter to putmsg, putpmsg:
     int putmsg(int fildes, const struct strbuf *ctlptr,
          const struct strbuf *dataptr, int flags);

  HPUX:
     don't set.
     no SYS V.4 streams.


ACE_HAS_STREAMS:
----------------

  Used In:
     ace/OS.h
     libsrc/IPC_SAP/SOCK_SAP/LSOCK.C

  Notes:
     if defined, includes <stropts.h>

  HPUX:
     don't set.
     no SYS V.4 streams.


ACE_HAS_STREAM_PIPES:
---------------------

  Used in:
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE_Msg.h
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE_Msg.C
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE_Listener.h
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE_Listener.C
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE.h
     libsrc/IPC_SAP/SPIPE_SAP/SPIPE.C
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Send_Msg.h
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Send_Msg.C
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Send_Msg.i
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Recv_Msg.h
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Recv_Msg.C
     libsrc/IPC_SAP/FIFO_SAP/FIFO_Recv_Msg.i

  Notes:
     if not set, won't be able to use the SPIPE class (IPC_SAP) with
     rendezvous handles.

  HPUX:
     don't set.
     No sysV.4 streams.


ACE_HAS_STRERROR:
-----------------

  Used in:
     ace/OS.h

  Notes:
     if not defined, does a:
     #define strerror(err) sys_errlist[err]

  Solaris:
     /usr/include/string.h

  HPUX:
     set it.
     in /usr/include/sys/errno.h and string.h
     extern char *strerror (int);


ACE_HAS_SVR4_DYNAMIC_LINKING:
-----------------------------

  Used in:
     ace/OS.h
     tests/Service_Configurator/CCM_App.C

  Notes:
     if defined, includes <dlfcn.h>
     with dlopen(), dlsym(), etc..

  HPUX:
     don't set.
     has its own:
     shl_findsym( ), shl_gethandle( ), shl_getsymbols( ),
     shl_unload( ), shl_get( )(3X) - explicit load of shared libraries


ACE_HAS_SVR4_GETTIMEOFDAY:
--------------------------

  Used in:
     ace/OS.h
     libsrc/Reactor/Timer_Queue.i

  Notes:
     has to do with gettimeofday ().

  Solaris:
     gettimeofday (struct timeval *tp)

  HPUX:
     don't set.
     it has gettimeofday (struct timeval *tp, struct timezone *tzp);
     most calls do a:
     #if defined (ACE_HAS_SVR4_GETTIMEOFDAY)
      ::gettimeofday (&cur_time);
     #else
      ::gettimeofday (&cur_time, 0);
     #endif /* ACE_HAS_SVR4_GETTIMEOFDAY */


ACE_HAS_POLL:
------------
  Used in:
     ace/OS.h

  Notes:
     #if defined (ACE_HAS_POLL)
     #include /**/ <poll.h>
     #endif /* ACE_HAS_POLL */

ACE_USE_POLL_IMPLEMENTATION:
------------------

  Used in:
     ace/OS.h

  Notes:
    Use the poll() event demultiplexor rather than select().

  HPUX:
     set it.


ACE_HAS_SVR4_SIGNAL_T:
----------------------

  Used in:
     ace/OS.h

  Notes:
     #if defined (ACE_HAS_SVR4_SIGNAL_T)
     typedef void (*SignalHandler)(int);
     typedef void (*SignalHandlerV)(void);
     #elif defined (ACE_HAS_SIGNALHANDLERV_INT_ARG)
     typedef void (*SignalHandler)(int);
     typedef void (*SignalHandlerV)(int);
     #else
     #define SignalHandler SIG_PF
     typedef void (*SignalHandlerV)(...);
     #endif /* ACE_HAS_SVR4_SIGNAL_T */

  HPUX:
     set it.


ACE_HAS_SVR4_TLI:
-----------------

  Used in:
     libsrc/IPC_SAP/TLI_SAP/TLI.C
     libsrc/IPC_SAP/TLI_SAP/TLI.h
     libsrc/IPC_SAP/TLI_SAP/TLI_Stream.C

  Notes:
     TLI is the transport layer calls as in: t_bind(), t_open(), t_unbind(),
     t_optmgmt(), ... in SunOS and Solaris.

  HPUX:
     don't set.
     Not supported.


ACE_HAS_SYS_FILIO_H:
--------------------

  Used in:
     ace/OS.h

  Notes:
     if not defined, includes <sys/filio.h>.
     didn't find any reference to anything in this file in the ACE code.

  Solaris:
     filio.h defines FIOCLEX, FIOASYNC, ... as _IO('f', 1), ..
     for FIOLFS,.. solaris has this to say:
     /*
      * ioctl's for Online: DiskSuite.
      * WARNING - the support for these ioctls may be withdrawn
      * in the future OS releases.
      */

  HPUX:
     <sys/ioctl.h> defines FIOASYNC and some other ones,
     <sgtty.h> defines some like FIOCLEX.
     some are never defined.
     use #ifdef HP-UX to modify sysincludes.h


ACE_HAS_SYS_SIGLIST:
--------------------

  Used in:
     ace/OS.h
     libsrc/Log_Msg/Log_Msg.C

  Notes:
     if not defined, does a:
     extern const char **_sys_siglist;

  Solaris:
     This is an array holding signal descriptions.

  HPUX:
     don't set.
     Some additional work is required.  In libsrc/Log_Msg/Log_Msg.C,
     sys_siglist is used regardless of ACE_HAS_SYS_SIGLIST.
     have to add #ifdefs to remove them.


ACE_HAS_TEMPLATE_TYPEDEFS:
--------------------------

  Used in:
     libsrc/ASX/*.[Chi]

  Notes:
     cfront-based C++ compilers don't implement templates that support
     classes with typedefs of other types as formal arguments.  This
     typedef uses the C++ preprocessor to work around this problem.

ACE_HAS_THREADS:
----------------

  Used in:
     libsrc/Service_Configurator/Svc_Conf.y.C
     libsrc/Service_Configurator/Thread_Spawn.i
     libsrc/Threads/Synch.C
     libsrc/Threads/Synch.i
     libsrc/Threads/Thr_Manager.i
     libsrc/ASX/STREAM.C
     libsrc/ASX/Queue.C
     libsrc/ASX/Module.C
     libsrc/ASX/Stream_Modules.C
     libsrc/ASX/Multiplexor.C
     libsrc/ASX/Message_List.C
     include/Message_List.h
     include/Module.h
     include/Multiplexor.h
     include/Queue.h
     include/STREAM.h
     include/Stream_Modules.h
     include/Service_Types.h
     include/Thread_Spawn.h
     include/Synch.h
     include/Thr_Manager.h

  Notes:
     We use Message_List.h even in a non-threaded environment.
     our XOMessageList.h does this by #ifdefs around Threaded things.

  HPUX:
     not until 10.0.


ACE_HAS_TIMOD_H:
----------------

  Used in:
     ace/OS.h

  Notes:
     if defined, include <sys/timod.h>

  Solaris:
     timod is a STREAMS module for use with the Transport  Inter-
     face  (TI)  functions  of the Network Services library.  The
     timod module converts a set of ioctl(2) calls  into  STREAMS
     messages  that  may be consumed by a transport protocol pro-
     vider that supports the Transport Interface.  This allows  a
     user to initiate certain TI functions as atomic operations.

  HPUX:
     don't set.


ACE_HAS_TIUSER_H:
-----------------

  Used in:
     ace/OS.h

  Notes:
     if set, includes <tiuser.h>

  Solaris:
     in conjunction with t_bind, t_accept, etc.. transport layer.

  HPUX:
     don't set.


ACE_USE_POLL_IMPLEMENTATION:
----------------------------

  Used in:
     libsrc/Reactor/Reactor.i
     include/Event_Handler.h
     ace/OS.h
     include/Reactor.h

  Notes:
     in the reactor, use poll instead of select.  In general,
     good thing to have set.

ACE_USES_GPROF:
----------------------------
  Used in:
    ace/Base_Thread_Adapter.h
    ace/Base_Thread_Adapter.inl
    ace/Base_Thread_Adapter.cpp

  Notes:
    When using gprof mainly on Linux, #define ACE_USES_GPROF
    will add calls to getitimer/setitimer in order to initialize profile
    timer and overcome the problem of gprof with multithreaded applications.

ACE_QTREACTOR_CLEAR_PENDING_EVENTS:
----------------------------
  Used in:
    ace/QtReactor.cpp:
    QtReactor by default does not clear qt events pending for
    activated socket. Clearing costs much, at least 2 hash accesses
    in ACE, and 2 another in Qt. It is also better to not clear
    pending events as some side effects are unknown. However,
    when events are not clear, then some user applications may be
    confused by handle_input/output/exception called without any
    data eg. in ACE_Acceptor::make_svc_handler. This swithc is
    intended to quickly fix user application which does not
    follow some reactor rules.
 Linux:
   It seems linux::qt does not queue pending events. Do not define
   this switch.
 Windows:
   Windows::qt queues pending events. If user application has handle_*
   methods which cannot be called without data, then turn on this switch
   to quickly fix the bug. However, one should seriously fix the
   application then.
