// -*- C++ -*- //========================================================================== /** * @file config-macros.h * * @author Doug Schmidt * @author Jesper S. M|ller * @author and a cast of thousands... * * This file contains the contents of the old config-lite.h header * without C++ code (except for C++ code in macros). Specifically, * only macros or C language constructs are found in this header. * Allows configuration values and macros to be used by some C * language sources. */ //========================================================================== #ifndef ACE_CONFIG_MACROS_H #define ACE_CONFIG_MACROS_H #include "ace/config.h" #include "ace/config-face-safety.h" #include "ace/Version.h" #include "ace/Versioned_Namespace.h" #if defined (ACE_HAS_ALLOC_HOOKS) # include #endif #if !defined (ACE_HAS_EXCEPTIONS) #define ACE_HAS_EXCEPTIONS #endif /* !ACE_HAS_EXCEPTIONS */ // ACE_HAS_TLI is used to decide whether to try any XTI/TLI functionality // so if it isn't set, set it. Capabilities and differences between // XTI and TLI favor XTI, but when deciding to do anything, as opposed to // ACE_NOTSUP_RETURN for example, ACE_HAS_TLI is the deciding factor. #if !defined (ACE_HAS_TLI) # if defined (ACE_HAS_XTI) # define ACE_HAS_TLI # endif /* ACE_HAS_XTI */ #endif /* ACE_HAS_TLI */ #define ACE_BITS_PER_ULONG (8 * sizeof (u_long)) #if !defined (ACE_OSTREAM_TYPE) # if defined (ACE_LACKS_IOSTREAM_TOTALLY) # define ACE_OSTREAM_TYPE FILE # else /* ! ACE_LACKS_IOSTREAM_TOTALLY */ # define ACE_OSTREAM_TYPE ostream # endif /* ! ACE_LACKS_IOSTREAM_TOTALLY */ #endif /* ! ACE_OSTREAM_TYPE */ #if !defined (ACE_DEFAULT_LOG_STREAM) # if defined (ACE_LACKS_IOSTREAM_TOTALLY) # define ACE_DEFAULT_LOG_STREAM 0 # else /* ! ACE_LACKS_IOSTREAM_TOTALLY */ # define ACE_DEFAULT_LOG_STREAM (&cerr) # endif /* ! ACE_LACKS_IOSTREAM_TOTALLY */ #endif /* ! ACE_DEFAULT_LOG_STREAM */ // For Win32 compatibility... # if !defined (ACE_WSOCK_VERSION) # define ACE_WSOCK_VERSION 0, 0 # endif /* ACE_WSOCK_VERSION */ # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) # define ACE_MT(X) X # else # define ACE_MT(X) # endif /* ACE_MT_SAFE */ # if defined (ACE_HAS_PURIFY) # define ACE_INITIALIZE_MEMORY_BEFORE_USE # endif /* ACE_HAS_PURIFY */ # if defined (ACE_HAS_VALGRIND) # define ACE_INITIALIZE_MEMORY_BEFORE_USE # endif /* ACE_HAS_VALGRIND */ // ========================================================================= // Perfect Multicast filtering refers to RFC 3376, where a socket is only // delivered dgrams for groups joined even if it didn't bind the group // address. We turn this option off by default, although most OS's // except for Windows probably lack perfect filtering. // ========================================================================= # if !defined (ACE_LACKS_PERFECT_MULTICAST_FILTERING) # define ACE_LACKS_PERFECT_MULTICAST_FILTERING 0 # endif /* ACE_LACKS_PERFECT_MULTICAST_FILTERING */ // ========================================================================= // Enable/Disable Features By Default // ========================================================================= # if !defined (ACE_HAS_POSITION_INDEPENDENT_POINTERS) # define ACE_HAS_POSITION_INDEPENDENT_POINTERS 1 # endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS */ # if !defined (ACE_HAS_PROCESS_SPAWN) # if !defined (ACE_LACKS_FORK) || \ (defined (ACE_WIN32)) # define ACE_HAS_PROCESS_SPAWN 1 # endif # endif /* ACE_HAS_PROCESS_SPAWN */ # if !defined (ACE_HAS_DYNAMIC_LINKING) # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING) || defined (ACE_WIN32) || defined (ACE_VXWORKS) # define ACE_HAS_DYNAMIC_LINKING 1 # endif # endif /* ACE_HAS_DYNAMIC_LINKING */ # if defined (ACE_HAS_DYNAMIC_LINKING) && ACE_HAS_DYNAMIC_LINKING == 0 && \ defined (ACE_HAS_SVR4_DYNAMIC_LINKING) # undef ACE_HAS_SVR4_DYNAMIC_LINKING # endif /* ACE_HAS_DYNAMIC_LINKING == 0 */ # if defined (ACE_USES_FIFO_SEM) # if defined (ACE_HAS_POSIX_SEM) || defined (ACE_LACKS_MKFIFO) || defined (ACE_LACKS_FCNTL) # undef ACE_USES_FIFO_SEM # endif # endif /* ACE_USES_FIFO_SEM */ # ifndef ACE_LACKS_POSIX_DEVCTL # define ACE_LACKS_POSIX_DEVCTL # endif // ========================================================================= // INLINE macros // // These macros handle all the inlining of code via the .i or .inl files // ========================================================================= #if defined (ACE_LACKS_INLINE_FUNCTIONS) && !defined (ACE_NO_INLINE) # define ACE_NO_INLINE #endif /* defined (ACE_LACKS_INLINE_FUNCTIONS) && !defined (ACE_NO_INLINE) */ // ACE inlining has been explicitly disabled. Implement // internally within ACE by undefining __ACE_INLINE__. #if defined (ACE_NO_INLINE) # undef __ACE_INLINE__ #endif /* ! ACE_NO_INLINE */ #if defined (__ACE_INLINE__) # define ACE_INLINE inline # if !defined (ACE_HAS_INLINED_OSCALLS) # define ACE_HAS_INLINED_OSCALLS # endif /* !ACE_HAS_INLINED_OSCALLS */ #else # define ACE_INLINE #endif /* __ACE_INLINE__ */ // ============================================================================ // EXPORT macros // // Since Win32 DLL's do not export all symbols by default, they must be // explicitly exported (which is done by *_Export macros). // ============================================================================ // Win32 should have already defined the macros in config-win32-common.h #if !defined (ACE_HAS_CUSTOM_EXPORT_MACROS) # define ACE_Proper_Export_Flag # define ACE_Proper_Import_Flag # define ACE_EXPORT_SINGLETON_DECLARATION(T) # define ACE_IMPORT_SINGLETON_DECLARATION(T) # define ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) # define ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) #else // An export macro should at the very least have been defined. # ifndef ACE_Proper_Import_Flag # define ACE_Proper_Import_Flag # endif /* !ACE_Proper_Import_Flag */ # ifndef ACE_EXPORT_SINGLETON_DECLARATION # define ACE_EXPORT_SINGLETON_DECLARATION(T) # endif /* !ACE_EXPORT_SINGLETON_DECLARATION */ # ifndef ACE_IMPORT_SINGLETON_DECLARATION # define ACE_IMPORT_SINGLETON_DECLARATION(T) # endif /* !ACE_IMPORT_SINGLETON_DECLARATION */ # ifndef ACE_EXPORT_SINGLETON_DECLARE # define ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) # endif /* !ACE_EXPORT_SINGLETON_DECLARE */ # ifndef ACE_IMPORT_SINGLETON_DECLARE # define ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) # endif /* !ACE_IMPORT_SINGLETON_DECLARE */ #endif /* !ACE_HAS_CUSTOM_EXPORT_MACROS */ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_CLASS_INSTANTIATION) # define ACE_SINGLETON_TEMPLATE_INSTANTIATION(T) \ template class T; # define ACE_SINGLETON_TEMPLATE_INSTANTIATE(SINGLETON_TYPE, CLASS, LOCK) \ template class SINGLETON_TYPE < CLASS, LOCK >; #elif defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION) # define ACE_SINGLETON_TEMPLATE_INSTANTIATION(T) \ template T * T::singleton_; # define ACE_SINGLETON_TEMPLATE_INSTANTIATE(SINGLETON_TYPE, CLASS, LOCK) \ template SINGLETON_TYPE < CLASS, LOCK > * SINGLETON_TYPE < CLASS, LOCK >::singleton_; #endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */ #if !defined(ACE_SINGLETON_TEMPLATE_INSTANTIATION) # define ACE_SINGLETON_TEMPLATE_INSTANTIATION(T) #endif #if !defined(ACE_SINGLETON_TEMPLATE_INSTANTIATE) # define ACE_SINGLETON_TEMPLATE_INSTANTIATE(SINGLETON_TYPE, CLASS, LOCK) #endif // This is a whim of mine -- that instead of annotating a class with // ACE_Export in its declaration, we make the declaration near the TOP // of the file with ACE_DECLARE_EXPORT. // TS = type specifier (e.g., class, struct, int, etc.) // ID = identifier // So, how do you use it? Most of the time, just use ... // ACE_DECLARE_EXPORT(class, someobject); // If there are global functions to be exported, then use ... // ACE_DECLARE_EXPORT(void, globalfunction) (int, ...); // Someday, when template libraries are supported, we made need ... // ACE_DECLARE_EXPORT(template class, sometemplate) ; # define ACE_DECLARE_EXPORT(TS,ID) TS ACE_Export ID // ============================================================================ // Cast macros // // These macros are used to choose between the old cast style and the new // *_cast<> operators // ============================================================================ # define ACE_sap_any_cast(TYPE) reinterpret_cast (const_cast (ACE_Addr::sap_any)) // ============================================================================ // Compiler Silencing macros // // Some compilers complain about parameters that are not used. This macro // should keep them quiet. // ============================================================================ #if !defined (ACE_UNUSED_ARG) # if defined (__GNUC__) || defined (__BORLANDC__) # define ACE_UNUSED_ARG(a) (void) (a) # elif defined (ghs) || defined (__rational__) || defined (__USLC__) || defined (__DCC__) || defined (__PGI) // Some compilers complain about "statement with no effect" with (a). // This eliminates the warnings, and no code is generated for the null // conditional statement. @note that may only be true if -O is enabled, // such as with GreenHills (ghs) 1.8.8. # define ACE_UNUSED_ARG(a) do {/* null */} while (&a == 0) # else /* ghs ..... */ # define ACE_UNUSED_ARG(a) (a) # endif /* ghs ..... */ #endif /* !ACE_UNUSED_ARG */ #if defined (_MSC_VER) || defined (ghs) || defined(__BORLANDC__) || defined (__USLC__) || defined (__DCC__) || defined (__PGI) || defined (__IAR_SYSTEMS_ICC__) # define ACE_NOTREACHED(a) #else /* ghs || ..... */ # define ACE_NOTREACHED(a) a #endif /* ghs || ..... */ // Compiler-specific configs can define ACE_FALLTHROUGH but if not, // and it's a C++17 or higher compiler, use the defined mechanism. #if !defined ACE_FALLTHROUGH # if defined ACE_HAS_CPP17 # define ACE_FALLTHROUGH [[fallthrough]] # else # define ACE_FALLTHROUGH # endif /* ACE_HAS_CPP17 */ #endif /* ACE_FALLTHROUGH */ // ============================================================================ // ACE_ALLOC_HOOK* macros // // Macros to declare and define class-specific allocation operators. // ============================================================================ # if defined (ACE_HAS_ALLOC_HOOKS) # define ACE_ALLOC_HOOK_DECLARE \ void *operator new (size_t bytes); \ void *operator new (size_t bytes, void *ptr); \ void *operator new (size_t bytes, const std::nothrow_t &) noexcept; \ void operator delete (void *ptr); \ void operator delete (void *ptr, const std::nothrow_t &); \ void *operator new[] (size_t size); \ void operator delete[] (void *ptr); \ void *operator new[] (size_t size, const std::nothrow_t &) noexcept; \ void operator delete[] (void *ptr, const std::nothrow_t &) # define ACE_GENERIC_ALLOCS(MAKE_PREFIX, CLASS) \ MAKE_PREFIX (void *, CLASS)::operator new (size_t bytes) \ { \ void *const ptr = ACE_Allocator::instance ()->malloc (bytes); \ if (ptr == 0) \ throw std::bad_alloc (); \ return ptr; \ } \ MAKE_PREFIX (void *, CLASS)::operator new (size_t, void *ptr) { return ptr; }\ MAKE_PREFIX (void *, CLASS)::operator new (size_t bytes, \ const std::nothrow_t &) noexcept \ { return ACE_Allocator::instance ()->malloc (bytes); } \ MAKE_PREFIX (void, CLASS)::operator delete (void *ptr) \ { if (ptr) ACE_Allocator::instance ()->free (ptr); } \ MAKE_PREFIX (void, CLASS)::operator delete (void *ptr, \ const std::nothrow_t &) \ { if (ptr) ACE_Allocator::instance ()->free (ptr); } \ MAKE_PREFIX (void *, CLASS)::operator new[] (size_t size) \ { \ void *const ptr = ACE_Allocator::instance ()->malloc (size); \ if (ptr == 0) \ throw std::bad_alloc (); \ return ptr; \ } \ MAKE_PREFIX (void, CLASS)::operator delete[] (void *ptr) \ { if (ptr) ACE_Allocator::instance ()->free (ptr); } \ MAKE_PREFIX (void *, CLASS)::operator new[] (size_t size, \ const std::nothrow_t &) noexcept\ { return ACE_Allocator::instance ()->malloc (size); } \ MAKE_PREFIX (void, CLASS)::operator delete[] (void *ptr, \ const std::nothrow_t &) \ { if (ptr) ACE_Allocator::instance ()->free (ptr); } # define ACE_ALLOC_HOOK_HELPER(RET, CLASS) RET CLASS # define ACE_ALLOC_HOOK_DEFINE(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tt(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tt(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tt, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tc(RET, CLASS) template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Ty(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Ty(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Ty, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tyc(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tyc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tyc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tycc(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tycc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tycc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tcy(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tcy(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tcy, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tcyc(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tcyc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tcyc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tca(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tca(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tca, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tco(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tco(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tco, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tcoccc(RET, CLASS) \ template RET \ CLASS # define ACE_ALLOC_HOOK_DEFINE_Tcoccc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tcoccc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tcc(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tcc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tcc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tccc(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tccc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tccc, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tccct(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tccct(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tccct, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tc4(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tc4(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tc4, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tc5(RET, CLASS) \ template RET \ CLASS # define ACE_ALLOC_HOOK_DEFINE_Tc5(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tc5, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tc6(RET, CLASS) \ template RET \ CLASS # define ACE_ALLOC_HOOK_DEFINE_Tc6(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tc6, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tc7(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tc7(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tc7, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tcs(RET, CLASS) \ template RET CLASS # define ACE_ALLOC_HOOK_DEFINE_Tcs(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tcs, CLASS) # define ACE_ALLOC_HOOK_HELPER_Tmcc(RET, CLASS) \ template RET \ CLASS # define ACE_ALLOC_HOOK_DEFINE_Tmcc(CLASS) \ ACE_GENERIC_ALLOCS (ACE_ALLOC_HOOK_HELPER_Tmcc, CLASS) # else # define ACE_ALLOC_HOOK_DECLARE struct Ace_ {} /* Just need a dummy... */ # define ACE_ALLOC_HOOK_DEFINE(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tt(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tcc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tccc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tccct(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tc4(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tc5(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tc6(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tc7(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Ty(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tyc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tycc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tcy(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tcyc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tca(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tco(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tcoccc(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tcs(CLASS) # define ACE_ALLOC_HOOK_DEFINE_Tmcc(CLASS) # endif /* ACE_HAS_ALLOC_HOOKS */ // ============================================================================ /** * ACE_OSCALL* macros * * @deprecated ACE_OSCALL_RETURN and ACE_OSCALL should not be used. * Please restart system calls in your application code. * See the @c sigaction(2) man page for documentation * regarding enabling restartable system calls across * signals via the @c SA_RESTART flag. * * The following two macros used ensure that system calls are properly * restarted (if necessary) when interrupts occur. However, that * capability was never enabled by any of our supported platforms. * In fact, some parts of ACE would not function properly when that * ability was enabled. Furthermore, they assumed that ability to * restart system calls was determined statically. That assumption * does not hold for modern platforms, where that ability is * determined dynamically at run-time. */ // ============================================================================ #define ACE_OSCALL_RETURN(X,TYPE) \ do \ return (TYPE) (X); \ while (0) #define ACE_OSCALL(X,TYPE,RESULT) \ do \ RESULT = (TYPE) (X); \ while (0) #if defined (ACE_WIN32) # define ACE_WIN32CALL_RETURN(X,TYPE,FAILVALUE) \ do { \ TYPE ace_result_; \ ace_result_ = (TYPE) X; \ if (ace_result_ == FAILVALUE) \ ACE_OS::set_errno_to_last_error (); \ return ace_result_; \ } while (0) # define ACE_WIN32CALL(X,TYPE,FAILVALUE,RESULT) \ do { \ RESULT = (TYPE) X; \ if (RESULT == FAILVALUE) \ ACE_OS::set_errno_to_last_error (); \ } while (0) #endif /* ACE_WIN32 */ // The C99 security-improved run-time returns an error value on failure; // 0 on success. #if defined (ACE_HAS_TR24731_2005_CRT) # define ACE_SECURECRTCALL(X,TYPE,FAILVALUE,RESULT) \ do { \ errno_t ___ = X; \ if (___ != 0) { errno = ___; RESULT = FAILVALUE; } \ } while (0) #endif /* ACE_HAS_TR24731_2005_CRT */ // ============================================================================ // Fundamental types // ============================================================================ #if defined (ACE_WIN32) typedef HANDLE ACE_HANDLE; typedef SOCKET ACE_SOCKET; # define ACE_INVALID_HANDLE INVALID_HANDLE_VALUE #else /* ! ACE_WIN32 */ typedef int ACE_HANDLE; typedef ACE_HANDLE ACE_SOCKET; # define ACE_INVALID_HANDLE -1 #endif /* ACE_WIN32 */ // Define the type that's returned from the platform's native thread // functions. ACE_THR_FUNC_RETURN is the type defined as the thread // function's return type, except when the thread function doesn't return // anything (pSoS). The ACE_THR_FUNC_NO_RETURN_VAL macro is used to // indicate that the actual thread function doesn't return anything. The // rest of ACE uses a real type so there's no a ton of conditional code // everywhere to deal with the possibility of no return type. # if defined (ACE_VXWORKS) && !defined (ACE_HAS_PTHREADS) # include /**/ typedef int ACE_THR_FUNC_RETURN; #define ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN # elif defined (ACE_WIN32) typedef DWORD ACE_THR_FUNC_RETURN; #define ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN # else typedef void* ACE_THR_FUNC_RETURN; # endif /* ACE_VXWORKS */ typedef ACE_THR_FUNC_RETURN (*ACE_THR_FUNC)(void *); #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ typedef void (*ACE_THR_C_DEST)(void *); #ifdef __cplusplus } #endif /* __cplusplus */ typedef void (*ACE_THR_DEST)(void *); // Now some platforms have special requirements... # if defined (ACE_VXWORKS) && !defined (ACE_HAS_PTHREADS) typedef FUNCPTR ACE_THR_FUNC_INTERNAL; // where typedef int (*FUNCPTR) (...) # else typedef ACE_THR_FUNC ACE_THR_FUNC_INTERNAL; # endif /* ACE_VXWORKS */ # ifdef __cplusplus extern "C" { # endif /* __cplusplus */ # if defined (ACE_VXWORKS) && !defined (ACE_HAS_PTHREADS) typedef FUNCPTR ACE_THR_C_FUNC; // where typedef int (*FUNCPTR) (...) # else typedef ACE_THR_FUNC_RETURN (*ACE_THR_C_FUNC)(void *); # endif /* ACE_VXWORKS */ # ifdef __cplusplus } # endif /* __cplusplus */ // ============================================================================ // Macros for controlling the lifetimes of dlls loaded by ACE_DLL--including // all dlls loaded via the ACE Service Config framework. // // Please don't change these values or add new ones wantonly, since we use // the ACE_BIT_ENABLED, etc..., macros to test them. // ============================================================================ // Per-process policy that unloads dlls eagerly. #define ACE_DLL_UNLOAD_POLICY_PER_PROCESS 0 // Apply policy on a per-dll basis. If the dll doesn't use one of the macros // below, the current per-process policy will be used. #define ACE_DLL_UNLOAD_POLICY_PER_DLL 1 // Don't unload dll when refcount reaches zero, i.e., wait for either an // explicit unload request or program exit. #define ACE_DLL_UNLOAD_POLICY_LAZY 2 // Default policy allows dlls to control their own destinies, but will // unload those that don't make a choice eagerly. #define ACE_DLL_UNLOAD_POLICY_DEFAULT ACE_DLL_UNLOAD_POLICY_PER_DLL // Add this macro you one of your cpp file in your dll. X should // be either ACE_DLL_UNLOAD_POLICY_DEFAULT or ACE_DLL_UNLOAD_POLICY_LAZY. #define ACE_DLL_UNLOAD_POLICY(CLS,X) \ extern "C" u_long CLS##_Export _get_dll_unload_policy () \ { return X;} // ============================================================================ // ACE_USES_CLASSIC_SVC_CONF macro // ============================================================================ // For now, default is to use the classic svc.conf format. #if !defined (ACE_USES_CLASSIC_SVC_CONF) # if defined (ACE_HAS_CLASSIC_SVC_CONF) && defined (ACE_HAS_XML_SVC_CONF) # error You can only use either CLASSIC or XML svc.conf, not both. # endif // Change the ACE_HAS_XML_SVC_CONF to ACE_HAS_CLASSIC_SVC_CONF when // we switch ACE to use XML svc.conf as default format. # if defined (ACE_HAS_XML_SVC_CONF) # define ACE_USES_CLASSIC_SVC_CONF 0 # else # define ACE_USES_CLASSIC_SVC_CONF 1 # endif /* ACE_HAS_XML_SVC_CONF */ #endif /* ACE_USES_CLASSIC_SVC_CONF */ // ============================================================================ // Default svc.conf file extension. // ============================================================================ #if defined (ACE_USES_CLASSIC_SVC_CONF) && (ACE_USES_CLASSIC_SVC_CONF == 1) # define ACE_DEFAULT_SVC_CONF_EXT ".conf" #else # define ACE_DEFAULT_SVC_CONF_EXT ".conf.xml" #endif /* ACE_USES_CLASSIC_SVC_CONF && ACE_USES_CLASSIC_SVC_CONF == 1 */ // ============================================================================ // Miscellaneous macros // ============================================================================ #if defined (ACE_USES_EXPLICIT_STD_NAMESPACE) # define ACE_STD_NAMESPACE std #else # define ACE_STD_NAMESPACE #endif #if !defined (ACE_OS_String) # define ACE_OS_String ACE_OS #endif /* ACE_OS_String */ #if !defined (ACE_OS_Memory) # define ACE_OS_Memory ACE_OS #endif /* ACE_OS_Memory */ #if !defined (ACE_OS_Dirent) # define ACE_OS_Dirent ACE_OS #endif /* ACE_OS_Dirent */ #if !defined (ACE_OS_TLI) # define ACE_OS_TLI ACE_OS #endif /* ACE_OS_TLI */ // ------------------------------------------------------------------- // Preprocessor symbols will not be expanded if they are // concatenated. Force the preprocessor to expand them during the // argument prescan by calling a macro that itself calls another that // performs the actual concatenation. #define ACE_PREPROC_CONCATENATE_IMPL(A,B) A ## B #define ACE_PREPROC_CONCATENATE(A,B) ACE_PREPROC_CONCATENATE_IMPL(A,B) // ------------------------------------------------------------------- /// If MPC is using a lib modifier this define will be set and this then /// is used by the service configurator framework #if defined MPC_LIB_MODIFIER && !defined (ACE_LD_DECORATOR_STR) #define ACE_LD_DECORATOR_STR ACE_TEXT( MPC_LIB_MODIFIER ) #endif /* MPC_LIB_MODIFIER */ #ifndef ACE_GCC_CONSTRUCTOR_ATTRIBUTE # define ACE_GCC_CONSTRUCTOR_ATTRIBUTE #endif #ifndef ACE_GCC_DESTRUCTOR_ATTRIBUTE # define ACE_GCC_DESTRUCTOR_ATTRIBUTE #endif #ifndef ACE_HAS_TEMPLATE_TYPEDEFS #define ACE_HAS_TEMPLATE_TYPEDEFS #endif #ifndef ACE_GCC_FORMAT_ATTRIBUTE # define ACE_GCC_FORMAT_ATTRIBUTE(TYPE, STR_INDEX, FIRST_INDEX) #endif #ifndef ACE_DEPRECATED # define ACE_DEPRECATED #endif #ifndef ACE_HAS_REACTOR_NOTIFICATION_QUEUE # define ACE_HAS_REACTOR_NOTIFICATION_QUEUE #endif // If config.h declared a lack of process-shared mutexes but was silent about // process-shared condition variables, ACE must not attempt to use a // process-shared condition variable (which always requires a mutex too). #if defined ACE_LACKS_MUTEXATTR_PSHARED && !defined ACE_LACKS_CONDATTR_PSHARED # define ACE_LACKS_CONDATTR_PSHARED #endif #ifdef ACE_LACKS_CONDATTR_SETCLOCK # ifdef ACE_HAS_CONDATTR_SETCLOCK # undef ACE_HAS_CONDATTR_SETCLOCK # endif # ifdef ACE_HAS_POSIX_MONOTONIC_CONDITIONS # undef ACE_HAS_POSIX_MONOTONIC_CONDITIONS # endif # ifdef ACE_HAS_MONOTONIC_CONDITIONS # undef ACE_HAS_MONOTONIC_CONDITIONS # endif #endif #if defined (ACE_HAS_CLOCK_GETTIME_MONOTONIC) && !defined (ACE_LACKS_CLOCK_MONOTONIC) # ifndef ACE_HAS_MONOTONIC_TIME_POLICY # define ACE_HAS_MONOTONIC_TIME_POLICY # endif #endif #ifndef ACE_GCC_NO_RETURN # define ACE_GCC_NO_RETURN #endif // ACE_OS::readdir_r was removed in ACE7 #ifndef ACE_LACKS_READDIR_R # define ACE_LACKS_READDIR_R #endif #endif /* ACE_CONFIG_MACROS_H */