diff options
Diffstat (limited to 'configure.in')
| -rw-r--r-- | configure.in | 6121 |
1 files changed, 6121 insertions, 0 deletions
diff --git a/configure.in b/configure.in new file mode 100644 index 00000000000..6b58261789e --- /dev/null +++ b/configure.in @@ -0,0 +1,6121 @@ +dnl +dnl $Id$ + +AC_REVISION($Revision 0.53 $)dnl + +dnl +dnl An autoconf script to automatically configure ACE. +dnl Process this file with autoconf to produce a configure script. +dnl + +dnl +dnl The autoconf documentation states that this is the recommended +dnl sequence for this file: +dnl +dnl `AC_INIT(FILE)' +dnl checks for programs +dnl checks for libraries +dnl checks for header files +dnl checks for typedefs +dnl checks for structures +dnl checks for variables +dnl checks for compiler characteristics +dnl checks for library functions +dnl checks for system services +dnl `AC_OUTPUT([FILE...])' +dnl +dnl I followed this convention, and added a few sections. +dnl -- Gonzo + + +dnl +dnl SECTION 1: `AC_INIT(FILE)' +dnl +dnl This macro must be the very first invoked. +dnl Its argument names a file that must exist in the directory where +dnl autoconf will run, just to check things. +dnl AC_INIT(ace_unique.m4) +dnl +AC_INIT(ace/ACE.cpp) + +dnl Require GNU Autoconf 2.13 or better. +AC_PREREQ(2.13) + +dnl Check what platform we are running on. +AC_CANONICAL_SYSTEM + +dnl Allow the standard program name transformations. +dnl We probably don't need AC_ARG_PROGRAM any longer since AM_INIT_AUTOMAKE +dnl handles this functionality. -- Ossama +dnl AC_ARG_PROGRAM + +dnl Cause GNU Automake to initialize the state of things and run +dnl some sanity checks +PACKAGE=ace +changequote(, )dnl +ACE_VERSION=`head -1 ${srcdir}/VERSION | sed 's/.*version \([0-9.]*\).*/\1/'` +changequote([, ])dnl + +AM_INIT_AUTOMAKE("$PACKAGE", "$ACE_VERSION", ) + +dnl Generate a header file with all settings. +AM_CONFIG_HEADER(ace/config.h) + +dnl Move before the AC_ARG_ENABLE stuff to prevent autoconf complaints. +dnl This is a bit messy but it makes life easier for me. +dnl -Ossama +dnl +dnl SECTION: checks for programs +dnl + +dnl Check if system supports "#! /bin/sh" line in scripts +AC_SYS_INTERPRETER + +dnl Check the C compiler and preprocessor. +AC_PROG_CC +AC_PROG_CPP +AC_PROG_CC_C_O + +dnl Check the C++ compiler and preprocessor. +AC_PROG_CXX +AC_PROG_CXXCPP + +if test -n "$GXX"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if g++ --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + acenothinghere="" + else + AC_DEFINE(ACE_HAS_GNUG_PRE_2_8) dnl + AC_DEFINE(ACE_HAS_GNUC_BROKEN_TEMPLATE_INLINE_FUNCTIONS) dnl + fi +fi + +dnl If we are cross compiling disable certain things in the Makefiles. +AM_CONDITIONAL(ACE_CROSS_COMPILED, test X$cross_compiling = Xyes) + + +dnl This checks for a binary called gm4, gnum4 or m4, and assigns +dnl whatever was found (or "gonzo") to the M4 macro. +dnl AC_CHECK_PROGS(M4, gm4 gnum4 m4, gonzo) + +dnl Look for the best awk-style program available. +AC_PROG_AWK + +dnl Set some version information +ACE_CURRENT=0 +ACE_AGE=0 +ACE_REVISION=0 + +if test -n "$AWK"; then + ACE_MAJOR=`echo "$ACE_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]1 }'` + ACE_MINOR=`echo "$ACE_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]2 }'` + ACE_BETA=`echo "$ACE_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]3 }'` + +dnl This is a terrible kludge to fool libtool into making it produce a shared +dnl library with the "right" version information. +dnl We really should switch to a version scheme that is compatible with +dnl libtool. +dnl -Ossama +ACE_CURRENT=`expr $ACE_MAJOR + $ACE_MINOR` +ACE_AGE=$ACE_MINOR +ACE_REVISION=$ACE_BETA + +fi + +AC_SUBST(ACE_CURRENT) +AC_SUBST(ACE_AGE) +AC_SUBST(ACE_REVISION) + +dnl Do the usual install settings; don't forget to include a +dnl install-sh script, in case the is no BDS compatible install +dnl installed (no pun intended) in your machine. +dnl +dnl We don't need this anymore since AM_INIT_AUTOMAKE calls AM_PROG_INSTALL +dnl yes "AM_PROG_INSTALL," not "AC_PROG_INSTALL." -- Ossama +dnl AC_PROG_INSTALL + +dnl Special handling for some UNIX variants and Cygwin32 +AC_AIX +AC_ISC_POSIX +AC_MINIX +AC_CYGWIN + +dnl The user's/default C++ flags are stored in "CXXFLAGS." We use +dnl the variable "ACE_CXXFLAGS" to set the C++ flags we want. At the end +dnl of the configuration process we combine ACE_CXXFLAGS and CXXFLAGS +dnl into CXXFLAGS (e.g., CXXFLAGS="$ACE_CXXFLAGS $CXXFLAGS"). CXXFLAGS +dnl goes after ACE_CXXFLAGS so that the user's C++ flag command line +dnl choices always override the configure script's choices. +ACE_CXXFLAGS="" +ACE_CFLAGS="" + +dnl Set the test language as C++ +AC_LANG_CPLUSPLUS + +dnl Check if we support symlinks +AC_PROG_LN_S + +dnl Check if a lexical analyzer exists (lex, flex, etc.) +AM_PROG_LEX + +dnl Check if some implementation of YACC exists (yacc, byacc, bison, etc.) +AC_PROG_YACC +dnl if test -z "$YACC"; then +dnl ./missing yacc +dnl fi + +dnl Check for perfect hash function generator +AC_CHECK_PROG(GPERF, gperf, gperf) dnl + +dnl Check for profiling progam +AC_CHECK_PROGS(PROF, gprof prof,) dnl + +dnl Call ACE_SET_COMPILER_FLAGS before AM_PROG_LIBTOOL +ACE_SET_COMPILER_FLAGS + +dnl Since we are linking ACE with the C++ compiler, and since +dnl libtool checks linker characteristics using the C compiler, +dnl temporarily state that the C compiler is the C++ compiler. +save_CC="$CC" +CC="$CXX" + +dnl Disable building of static libraries by default +AM_DISABLE_STATIC + +dnl Check for libtool and turn on Automake processing for Libtool +AM_PROG_LIBTOOL + + +dnl Restore the C compiler variable +CC="$save_CC" + +dnl +dnl SECTION 2: Configure script command line options +dnl + + +AC_ARG_ENABLE(debug, + [ --enable-debug enable debugging [default=yes]], + [ + case "${enableval}" in + yes) + ACE_CXXFLAGS="$ACE_CXXFLAGS $DCXXFLAGS" + ;; + no) + AC_DEFINE(ACE_NDEBUG) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-debug) + ;; + esac + ],) + +AC_ARG_ENABLE(exceptions, + [ --enable-exceptions enable C++ exception handling [default=yes]], + [ + case "${enableval}" in + yes) + ace_user_enable_exceptions=yes + ;; + no) + ace_user_enable_exceptions=no + if test -n "$GXX"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if g++ --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + ACE_CXXFLAGS="$ACE_CXXFLAGS -fno-exceptions" + fi + fi + if test -n "$GCC"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if gcc --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + ACE_CFLAGS="$ACE_CFLAGS -fno-exceptions" + fi + fi + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-exceptions) + ;; + esac + ], + [ + ace_user_enable_exceptions=yes + ]) + + +AC_ARG_ENABLE(fast, + [ --enable-fast enable -fast flag, e.g. Sun C++ [default=no]], + [ + case "${enableval}" in + yes) + ACE_CXXFLAGS="$ACE_CXXFLAGS -fast" + ACE_CFLAGS="$ACE_CFLAGS -fast" + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-fast) + ;; + esac + ],) + +AC_ARG_ENABLE(inline, + [ --enable-inline enable code inlining [default=yes]], + [ + case "${enableval}" in + yes) + AC_DEFINE(__ACE_INLINE__) + ;; + no) + AC_DEFINE(ACE_NO_INLINE) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-inline) + ;; + esac + ], + [ + AC_DEFINE(__ACE_INLINE__) + ]) + +AC_ARG_ENABLE(log-msg-prop, + [ --enable-log-msg-prop enable threads inheriting + ACE_Log_Msg properties from parent + thread [default=yes]], + [ + case "${enableval}" in + yes) + dnl nothing to do + ;; + no) + AC_DEFINE(ACE_THREADS_DONT_INHERIT_LOG_MSG) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-log-msg-prop) + ;; + esac + ],) + +AC_ARG_ENABLE(logging, + [ --enable-logging enable ACE logging macros [default=yes]], + [ + case "${enableval}" in + yes) + dnl nothing to do + ;; + no) + AC_DEFINE(ACE_NLOGGING) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-logging) + ;; + esac + ],) + +AC_ARG_ENABLE(malloc-stats, + [ --enable-malloc-stats enable malloc statistics + collection [default=no]], + [ + case "${enableval}" in + yes) + AC_DEFINE(ACE_HAS_MALLOC_STATS) + ;; + no) + dnl nothing to do + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-malloc-stats) + ;; + esac + ],) + +AC_ARG_ENABLE(optimize, + [ --enable-optimize enable additional optimizations [default=yes]], + [ + case "${enableval}" in + yes) + ace_user_enable_optimize=yes + ;; + no) + AC_MSG_WARN(Optimization configure support not implemented yet.) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-optimize) + ;; + esac + ], + [ + ace_user_enable_optimize=yes + ]) + +AC_ARG_ENABLE(probe, + [ --enable-probe enable ACE_Timeprobes [default=no]], + [ + case "${enableval}" in + yes) + AC_DEFINE(ACE_COMPILE_TIMEPROBES) + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-probe) + ;; + esac + ],) + +AC_ARG_ENABLE(profile, + [ --enable-profile enable profiling [default=no]], + [ + case "${enableval}" in + yes) + if test -z "$PROF"; then + AC_MSG_WARN(No profiling program found. Assuming 'prof' exists) + ACE_CXXFLAGS="$ACE_CXXFLAGS -p" + ACE_CFLAGS="$ACE_CFLAGS -p" + else + case "$PROF" in + gprof) + echo "Building with 'gprof' support" + ACE_CXXFLAGS="$ACE_CXXFLAGS -pg" + ACE_CFLAGS="$ACE_CFLAGS -pg" + ;; + prof) + echo "Building with 'prof' support" + ACE_CXXFLAGS="$ACE_CXXFLAGS -p" + ACE_CFLAGS="$ACE_CFLAGS -p" + ;; + *) + dnl We shouldn't get here. + AC_MSG_WARN(Assuming 'prof' exists) + ACE_CXXFLAGS="$ACE_CXXFLAGS -p" + ACE_CFLAGS="$ACE_CFLAGS -p" + ;; + esac + fi + ;; + no) + dnl Do nothing + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-profile) + ;; + esac + ],) + +AC_ARG_ENABLE(purify, + [ --enable-purify Purify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(PURIFY, purify, purify,) + if test -n "$PURIFY"; then + PURE_CACHE_BASE_DIR=/tmp/purifycache + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PURELINK="$PURIFY -best-effort -chain-length=20 \ + -cache-dir=$PURE_CACHE_DIR \ + -fds-inuse-at-exit=no -ignore-signals=SIGINT -inuse-at-exit \ + -max_threads=100" + ACE_CXXFLAGS="$ACE_CXXFLAGS -DACE_HAS_PURIFY" + ACE_CFLAGS="$ACE_CFLAGS -DACE_HAS_PURIFY" + else + AC_MSG_WARN(Purify program was not found.) + AC_MSG_WARN(Disabling purify support.) + fi + ;; + no) + PURELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-purify) + ;; + esac + ], PURELINK="") + +AC_ARG_ENABLE(quantify, + [ --enable-quantify Quantify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(QUANTIFY, quantify, quantify,) + if test -n "$QUANTIFY"; then + PURE_CACHE_BASE_DIR=/tmp/purifycache + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PRELINK="$QUANTIFY -best-effort -max_threads=100 \ + -cache-dir=$PURE_CACHE_DIR" + ACE_CXXFLAGS="$ACE_CXXFLAGS -DACE_HAS_QUANTIFY" + ACE_CFLAGS="$ACE_CFLAGS -DACE_HAS_QUANTIFY" + else + AC_MSG_WARN(Quantify program was not found.) + AC_MSG_WARN(Disabling quantify support.) + fi + ;; + no) + PRELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-quantify) + ;; + esac + ], PRELINK="") + +AC_ARG_ENABLE(reentrant, + [ --enable-reentrant enable reentrant functions [default=yes]], + [ + case "${enableval}" in + yes) + ace_user_enable_reentrant_funcs=yes + ;; + no) + ace_user_enable_reentrant_funcs=no + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-reentrant) + ;; + esac + ], + [ + ace_user_enable_reentrant_funcs=yes + ]) + + +AC_ARG_ENABLE(repo, + [ --enable-repo use GNU template repository + GNU C++ with repo patches and + EGCS only [default=no]], + [ + case "${enableval}" in + yes) + if test -n "$GXX"; then + ace_user_enable_repo=yes + ACE_CXXFLAGS="$ACE_CXXFLAGS -frepo" + AC_DEFINE(ACE_HAS_GNU_REPO) + else + ace_user_enable_repo=no + AC_MSG_WARN(Not using GNU C++! GNU template respository disabled) + fi + ;; + no) + ace_user_enable_repo=no + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-repo) + ;; + esac + ], + [ + ace_user_enable_repo=no + ]) + +AC_ARG_ENABLE(rtti, + [ --enable-rtti enable run-time type + identification + *Currently only for Sun C++ [default=no]], + [ + case "${enableval}" in + yes) + if test -z "$GXX"; then + case "$target" in + *solaris*) + ACE_CXXFLAGS="$ACE_CXXFLAGS -features=rtti" + ;; + *) + ;; + esac + else + AC_MSG_WARN(Not using Sun C++. RTTI will not be enabled.) + fi + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-rtti) + ;; + esac + ],) + +AC_ARG_ENABLE(static-obj-mgr, + [ --enable-static-obj-mgr enable static Object_Manager [default=yes]], + [ + case "${enableval}" in + yes) + dnl nothing to do + ;; + no) + AC_DEFINE(ACE_HAS_NONSTATIC_OBJECT_MANAGER) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-static-obj-mgr) + ;; + esac + ],) + +AC_ARG_ENABLE(threads, + [ --enable-threads enable thread support [default=yes]], + [ + case "${enableval}" in + yes) + ace_user_enable_threads=yes + ;; + no) + ace_user_enable_threads=no + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-threads) + ;; + esac + ], + [ + ace_user_enable_threads=yes + ]) + + +AC_ARG_ENABLE(verb-not-sup, + [ --enable-verb-not-sup enable verbose ENOTSUP reports [default=no]], + [ + case "${enableval}" in + yes) + AC_DEFINE(ACE_HAS_VERBOSE_NOTSUP) + ;; + no) + dnl Do nothing + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-verb-not-sup) + ;; + esac + ],) + +AC_ARG_ENABLE(trace, + [ --enable-trace enable ACE tracing [default=no]], + [ + case "${enableval}" in + yes) + ;; + no) + AC_DEFINE(ACE_NTRACE) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-trace) + ;; + esac + ], + [ + AC_DEFINE(ACE_NTRACE) + ]) + +AC_ARG_ENABLE(xt-reactor, + [ --enable-xt-reactor build support for the XtReactor [default=no]], + [ + case "${enableval}" in + yes) + AC_PATH_XTRA +dnl Here, if X isn't found or the user sets "--without-x" on the command +dnl line, then "no_x" is set to "yes." + if test "$no_x" != yes; then + ACE_XLIBS="-lX11 -lXt" + AC_DEFINE(ACE_HAS_XT) + ace_user_enable_xt_reactor=yes + else + ACE_XLIBS="" + ace_user_enable_xt_reactor=no + AC_MSG_WARN(X was not found or it was disabled.) + AC_MSG_WARN(ACE_XtReactor will not be enabled.) + fi + ;; + no) + ACE_XLIBS="" + ace_user_enable_xt_reactor=no + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-xt-reactor) + ;; + esac + ],) + +AC_ARG_WITH(gperf, + [ --with-gperf compile the gperf program [default=yes]], + [ + case "${withval}" in + yes) + ace_user_with_gperf=yes + AC_DEFINE(ACE_HAS_GPERF) + if test -n "$GPERF"; then + AC_MSG_WARN(gperf program already exists) + AC_MSG_WARN(existing gperf may be overwritten during installation) + fi + ;; + no) + ace_user_with_gperf=no + ;; + *) + AC_MSG_ERROR(bad value ${withval} for --with-gperf) + ;; + esac + ], + [ + ace_user_with_gperf=yes + AC_DEFINE(ACE_HAS_GPERF) + if test -n "$GPERF"; then + AC_MSG_WARN(gperf program already exists) + AC_MSG_WARN(existing gperf may be overwritten during installation) + fi + ]) +AM_CONDITIONAL(COMPILE_GPERF, + test X$ace_user_with_gperf = Xyes) + +AC_ARG_WITH(orbix, + [ --with-orbix[=DIR] compile ACE with Orbix [default=no]], + [ + case "${withval}" in + yes) + AC_MSG_WARN(Orbix configure support not implemented yet.) + ;; + no) + ;; + *) + AC_MSG_WARN(Orbix configure support not implemented yet.) + ;; + esac + ],) + +AC_ARG_WITH(tli-device, + [ --with-tli-device[=DEV] device for TCP on TLI [default=/dev/tcp]], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(Specify the TLI/TCP device if you use this option.) + ;; + no) + ;; + *) + if test -e "${withval}"; then + AC_DEFINE_UNQUOTED(ACE_TLI_TCP_DEVICE, "${withval}") + else + AC_MSG_ERROR(TLI/TCP device ${withval} does not exist.) + fi + ;; + esac + ],) + +dnl +dnl SECTION 3: check for programs <--- moved before section 2 (Ossama) +dnl + +dnl Platform specific defines and libraries needed for ACE's autoconf tests +dnl that currently do not have tests themselves. +dnl Platform specific flags +case "$target" in + *aix3*) + ;; + *aix4.1*) + AC_DEFINE(_BSD, 44) + ;; + *aix4.2*) + AC_DEFINE(_BSD, 44) + AC_DEFINE(_BSD_INCLUDES) + ;; + t3e-cray-unicosmk*) + AC_DEFINE(_CRAYMPP) + AC_DEFINE(_CRAYT3E) + AC_DEFINE(_UNICOS,) + ;; + t3e-cray*) + AC_DEFINE(_CRAYT3E) + AC_DEFINE(_UNICOS,) + ;; + *cray-unicos*) + AC_DEFINE(_UNICOS,) + ;; + *dgux4.11*) + LIBS="$LIBS -lc" + AC_DEFINE(_POSIX_SOURCE) + AC_DEFINE(_DGUX_SOURCE) + ;; + *dgux4*) + LIBS="$LIBS -lc" + AC_DEFINE(_POSIX4A_DRAFT10_SOURCE) + AC_DEFINE(_POSIX4_DRAFT_SOURCE) + ;; + *freebsd*) + LIBS="$LIBS -lcompat" + ;; + *hpux9*) + LIBS="$LIBS -lcma -lrt" + AC_DEFINE(HPUX) + ;; + *hpux10*) + LIBS="$LIBS -lcma -lrt" + AC_DEFINE(_HPUX_SOURCE) + ;; + *hpux11*) + LIBS="$LIBS -lcma -lrt" + ;; + *irix5.2*) + ;; + *irix5.3*) + if test -z "$GXX"; then + AC_DEFINE(_BSD_TYPES) + fi + ;; + *irix6*) + AC_DEFINE(_SGI_MP_SOURCE) + AC_DEFINE(_MODERN_C_) + ;; + *linux*) + ;; + *lynxos*) + AC_DEFINE(_POSIX_THREADS_CALLS) + AC_DEFINE(__NO_INCLUDE_WARN__) + ;; + *m88k*) + ;; + *mvs*) + AC_DEFINE(_ALL_SOURCE) + ;; + *netbsd*) + ;; + *osf3.2*) + LIBS="$LIBS -lmach -lsys5 -lcxx -lc -lrt" + ;; + *osf4.0*) + LIBS="$LIBS -lmach -lrt" + ;; + *psos*) + LIBS="$LIBS -lm" + ;; + *sco4.2*) + ;; + *sco5*) + AC_DEFINE(_SVID3) + ;; + *sunos4*) + ;; + *solaris2.4*) + ;; + *solaris2.5*) + ;; + *solaris2.6*) + ;; + *86*solaris*) + ;; + *tandem*) + ;; + *unixware2.0*) + ;; + *unixware2.1*) + ;; + *vxworks*) + ;; + *cygwin32*) + ;; + *win32*) + ;; + *) + ;; +esac + +dnl +dnl SECTION 4: checks for libraries +dnl + +dnl Additional X library checks +dnl We only check for these libraries if the user has +dnl enabled XtReactor support. + +if test "$ace_user_enable_xt_reactor" = yes; then +XTREACTOR_TEST_XLIBS="" +dnl Check for Motif if we have X + T_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $X_LIBS" + +dnl Note that ACE currently only needs -lX11 and -lXt for the XtReactor +dnl so we define another library variable that contains additional +dnl libraries for the XtReactor test since it needs either Motif or the +dnl Athena widget set. + + xt_reactor_go=no + AC_CHECK_LIB(Xm, XmCreateRowColumn, dnl + [ + XTREACTOR_TEST_XLIBS="-lXm" + xt_reactor_go=yes + ], + [ + AC_DEFINE(ACE_LACKS_MOTIF) + AC_CHECK_LIB(Xaw, XawInitializeWidgetSet, + [ + XTREACTOR_TEST_XLIBS="-lXaw -lXmu" + xt_reactor_go=yes + ], + [ + xt_reactor_go=no + AC_MSG_WARN(No usable X widget libraries were found.) + AC_MSG_WARN(XtReactor test compilation will be disabled.) + ], -lXmu) + ],-lXt) + + AC_SUBST(XTREACTOR_TEST_XLIBS) + + AM_CONDITIONAL(COMPILE_XTREACTOR_TEST, test X$xt_reactor_go = Xyes) + +dnl Restore pre-test linker flags + LDFLAGS="$T_LDFLAGS" + +fi dnl test "$ace_user_enable_xt_reactor"= yes + +dnl End additional X library checks + +dnl Some platforms do not have a dynamic linking library, however the +dnl dlopen, dlclose, etc., functions may exist in the C library. +dnl (e.g. Digital UNIX) +dnl Check for dynamic linking library +AC_CHECK_FUNC(dlopen, ace_has_svr4_dynamic_linking=yes, dnl + AC_CHECK_LIB(dl, dlopen, + [ + ace_has_svr4_dynamic_linking=yes + LIBS="$LIBS -ldl" + ], + AC_CHECK_LIB(svld, dlopen, + [ + ace_has_svr4_dynamic_linking=yes + LIBS="$LIBS -lsvld" + ], + AC_CHECK_LIB(dld, shl_get,,)))) + +dnl Check if the socket library is available +AC_CHECK_FUNC(socket, , dnl + AC_CHECK_LIB(socket, socket,,)) + +dnl Check for gethostbyname in -lnsl since some platforms (e.g. Solaris) +dnl put it there. +AC_CHECK_FUNC(gethostbyname, , dnl + AC_CHECK_LIB(nsl, gethostbyname,,)) + +dnl Check for getservbyname in -lxnet since some platforms (e.g. Solaris) +dnl may put it there. Define ACE_LACKS_GETSERVBYNAME in case the getservbyname +dnl AC_CHECK_FUNC gets skipped due to caching. +AC_CHECK_FUNC(getservbyname, , dnl + AC_CHECK_LIB(xnet, getservbyname,, + AC_DEFINE(ACE_LACKS_GETSERVBYNAME))) + +dnl Check for compile() regex function in -lgen. Solaris, for example, +dnl may put it there. +AC_CHECK_FUNC(compile, , dnl + AC_CHECK_LIB(gen, compile, ,)) + +dnl Check for exception handling library (e.g. for Digital UNIX) +AC_CHECK_FUNC(exc_continue, , dnl + AC_CHECK_LIB(exc, exc_continue, ,)) + +dnl Check for ctime_r in -lc_r. Some platforms, such as Digital UNIX, +dnl put reentrant functions such as asctime_r, ctime_r, gmtime_r, and +dnl localtime_r in -lc_r. +AC_CHECK_FUNC(ctime_r, , dnl + AC_CHECK_LIB(c_r, ctime_r, ,)) + +dnl TLI library check +ace_has_tli_funcs=yes +AC_CHECK_FUNC(t_accept, , dnl + AC_CHECK_LIB(xti, t_accept, , + AC_CHECK_LIB(tli_r, t_accept, , + AC_CHECK_LIB(tli, t_accept, , + AC_CHECK_LIB(nsl, t_accept, ,ace_has_tli_funcs=no))))) + +dnl Asynchronous IO library check +dnl Some platforms, such as Solaris puts aio_read in -lposix4, for example. +ace_has_aio_funcs=yes +AC_CHECK_FUNC(aio_read, , dnl + AC_CHECK_LIB(aio, aio_read, , + AC_CHECK_LIB(posix4, aio_read, , ace_has_aio_funcs=no))) + +dnl Check for all of the things we need to compile and link threads +dnl properly. +if test "$ace_user_enable_threads" = yes; then + ACE_CHECK_THREADS +fi dnl test "$ace_user_enable_threads" = yes + +dnl Check for sched_yield() in posix4 library. +dnl Some platforms, such as Solaris, may define sched_yield() there. +dnl Later we run AC_CHECK_FUNC(sched_yield), which is redundant i this case +dnl but is needed if sched_yield() is defined in one of the other libraries +dnl we check for. +AC_CHECK_FUNC(sched_yield, ace_has_sched_yield=yes, dnl + AC_CHECK_LIB(posix4, sched_yield, ace_has_sched_yield=yes,)) + + +dnl +dnl SECTION 5: checks for header files +dnl + +dnl Check for dirent headers +AC_HEADER_DIRENT + +if test "$ac_cv_header_dirent_dirent_h" = yes || + test "$ac_cv_header_dirent_sys_ndir_h" = yes || + test "$ac_cv_header_dirent_sys_dir_h" = yes || + test "$ac_cv_header_dirent_ndir_h" = yes; then + AC_DEFINE(ACE_HAS_DIRENT) +fi + +dnl Check for sys/wait.h Posix.1 compliance +AC_HEADER_SYS_WAIT + +if test "$am_cv_cygwin32" = yes; then + AC_CHECK_HEADER(cygwin32/socket.h, dnl + AC_DEFINE(ACE_HAS_CYGWIN32_SOCKET_H),) +fi + +AC_CHECK_HEADER(dlfcn.h, dnl + [ + dnl We already checked for dlopen in the previous library checks however, + dnl it is possible that ac_cv_func_dlopen=yes if dlopen wasn't found before + dnl the library test. Hence we cannot use AC_CHECK_FUNC(dlopen) here + dnl the previously cached value may prevent ACE_HAS_SVR4_DYNAMIC_LINKING + dnl from being defined. + dnl -Ossama + if test "$ace_has_svr4_dynamic_linking" = yes; then + AC_DEFINE(ACE_HAS_SVR4_DYNAMIC_LINKING) + fi + ],) + +AC_CHECK_HEADER(malloc.h, dnl + , + AC_DEFINE(ACE_LACKS_MALLOC_H)) + +AC_CHECK_HEADER(memory.h, dnl + , + AC_DEFINE(ACE_LACKS_MEMORY_H)) + +AC_CHECK_HEADER(bytesex.h, dnl + AC_DEFINE(ACE_HAS_BYTESEX_H)) + +dnl We don't need to explicitly include this on linux. +dnl AC_CHECK_HEADER(features.h, dnl +dnl AC_DEFINE(ACE_HAS_FEATURES_H)) + +AC_CHECK_HEADER(sys/msg.h, dnl + [ + ACE_CACHE_CHECK(if _KERNEL is needed for msg prototypes, + ace_cv_lib_broken_msg_h, + [ + AC_TRY_COMPILE( + [ +#include <sys/msg.h> + ], + [ + struct msg ace_msg; + ], + [ + ace_cv_lib_broken_msg_h=no + ], + [ + AC_TRY_COMPILE( + [ +#ifndef _KERNEL +# define _KERNEL +#endif +#include <sys/msg.h> + ], + [ + struct msg ace_msg; + ], + [ + ace_cv_lib_broken_msg_h=yes + ], + [ + dnl If we get here, then we have no idea if it is broken or not. + ace_cv_lib_broken_msg_h=no + ]) + ]) + ], + [ + AC_DEFINE(ACE_HAS_BROKEN_MSG_H) + ],) + ], + AC_DEFINE(ACE_LACKS_SYSV_MSG_H)) + +AC_CHECK_HEADER(sys/param.h, dnl + , + AC_DEFINE(ACE_LACKS_PARAM_H)) + +AC_CHECK_HEADER(sys/priocntl.h, ,) + +AC_CHECK_HEADER(sys/procfs.h, dnl + AC_DEFINE(ACE_HAS_PROC_FS)) + +AC_CHECK_HEADER(sys/select.h, dnl + AC_DEFINE(ACE_HAS_SELECT_H)) + +AC_CHECK_HEADER(netinet/tcp.h, dnl + , + AC_DEFINE(ACE_LACKS_TCP_H)) + +AC_CHECK_HEADER(sys/sockio.h, dnl + AC_DEFINE(ACE_HAS_SOCKIO_H)) + +AC_CHECK_HEADER(sysent.h, dnl + AC_DEFINE(ACE_HAS_SYSENT_H),) + +AC_CHECK_HEADER(sys/systeminfo.h, ,) dnl + +AC_CHECK_HEADER(sys/filio.h, dnl + AC_DEFINE(ACE_HAS_SYS_FILIO_H),) + +AC_CHECK_HEADER(sys/uio.h,,) dnl + +AC_CHECK_HEADER(sys/ioctl.h, dnl + AC_DEFINE(ACE_HAS_SYS_IOCTL_H),) + +AC_CHECK_HEADER(sys/types.h, dnl + , + AC_DEFINE(ACE_LACKS_SYS_TYPES_H)) + +AC_CHECK_HEADER(sys/termios.h, dnl + [ + AC_EGREP_CPP(ACE_WITH_TERM_IOCTLS, + [ +#include <sys/termios.h> + +#if defined (ACE_HAS_SYS_IOCTL_H) +# include <sys/ioctl.h> +#endif + +#if defined(TCGETS) && defined(TCSETS) + ACE_WITH_TERM_IOCTLS +#elif defined(TCGETA) && defined(TCSETA) + ACE_WITH_TERM_IOCTLS +#endif + ], + [ + AC_DEFINE(ACE_HAS_TERM_IOCTLS) + ],) + ],) + +if test "$ace_has_tli_funcs" = yes; then +AC_CHECK_HEADER(xti.h, dnl + [ + ace_has_tli=yes + AC_DEFINE(ACE_HAS_XTI) + AC_DEFINE(ACE_HAS_TLI) + ],) + +AC_CHECK_HEADER(sys/xti.h, dnl + [ + ace_has_tli=yes + AC_DEFINE(ACE_HAS_SYS_XTI_H) + AC_DEFINE(ACE_HAS_XTI) + AC_DEFINE(ACE_HAS_TLI) + ],) + +AC_CHECK_HEADER(sys/timod.h, dnl + [ + AC_DEFINE(ACE_HAS_TIMOD_H) + ], + [ + AC_CHECK_HEADER(tli/timod.h, + [ + AC_DEFINE(ACE_HAS_OSF_TIMOD_H) + ],) + ]) + +AC_CHECK_HEADER(tiuser.h, dnl + [ + ace_has_tli=yes + AC_DEFINE(ACE_HAS_TIUSER_H) + AC_DEFINE(ACE_HAS_TLI) + ],) + +if test "$ac_cv_header_tiuser_h" = yes; then + ACE_CACHE_CHECK(if tiuser.h is protected by extern \"C\", + ace_cv_lib_tiuser_with_extern_c,[ + AC_EGREP_HEADER(extern \"C\", tiuser.h, + [ + ace_cv_lib_tiuser_with_extern_c=yes + ], + [ + ace_cv_lib_tiuser_with_extern_c=no + ]) + ], , AC_DEFINE(ACE_HAS_TIUSER_H_BROKEN_EXTERN_C)) +fi dnl test "$ac_cv_header_tiuser_h" = yes + +AC_CHECK_HEADER(xliuser.h, dnl + [ + ace_has_tli=yes + AC_DEFINE(ACE_HAS_XLI) + AC_DEFINE(ACE_HAS_TLI) + ],) + + +dnl Check for TLI prototypes +if test "$ace_has_tli" = yes; then + ACE_CACHE_CHECK(for TLI prototypes, + ace_cv_lib_tli_prototypes, + [ +dnl We only check for t_accept. This should hopefully be enough. + AC_EGREP_CPP(t_accept, + [ +#if defined (ACE_HAS_TIMOD_H) +# include <sys/timod.h> +#endif + +#if defined (ACE_HAS_OSF_TIMOD_H) +# include <tli/timod.h> +#endif + +#if defined (ACE_HAS_TIUSER_H) || defined (ACE_HAS_XTI) +# if defined (ACE_HAS_TIUSER_H) +# include /**/ <tiuser.h> +# else +# if defined (ACE_HAS_BROKEN_XTI_MACROS) +# undef TCP_NODELAY +# undef TCP_MAXSEG +# endif /* ACE_HAS_BROKEN_XTI_MACROS */ +# if defined ACE_HAS_SYS_XTI_H +# define class ace_xti_class +# include /**/ <sys/xti.h> +# undef class +# else +# include /**/ <xti.h> +# endif /* ACE_HAS_SYS_XTI_H */ +# endif /* ACE_HAS_TIUSER_H */ +#endif /* ACE_HAS_TIUSER_H || ACE_HAS_XTI */ + +#if defined (ACE_HAS_XLI) +# include <xliuser.h> +#endif + ], + [ + ace_cv_lib_tli_prototypes=yes + ], + [ + ace_cv_lib_tli_prototypes=no + ]) + ], AC_DEFINE(ACE_HAS_TLI_PROTOTYPES),) + +dnl Check for t_errno type in TLI headers + ACE_CACHE_CHECK(for t_errno in TLI headers, + ace_cv_lib_has_t_errno, + [ + dnl Check if t_errno is declared in the TLI headers + AC_EGREP_CPP(t_errno, + [ +#if defined (ACE_HAS_TIMOD_H) +# include <sys/timod.h> +#endif + +#if defined (ACE_HAS_OSF_TIMOD_H) +# include <tli/timod.h> +#endif + +#if defined (ACE_HAS_TIUSER_H) || defined (ACE_HAS_XTI) +# if defined (ACE_HAS_TIUSER_H) +# include /**/ <tiuser.h> +# else +# if defined (ACE_HAS_BROKEN_XTI_MACROS) +# undef TCP_NODELAY +# undef TCP_MAXSEG +# endif /* ACE_HAS_BROKEN_XTI_MACROS */ +# if defined ACE_HAS_SYS_XTI_H +# define class ace_xti_class +# include /**/ <sys/xti.h> +# undef class +# else +# include /**/ <xti.h> +# endif /* ACE_HAS_SYS_XTI_H */ +# endif /* ACE_HAS_TIUSER_H */ +#endif /* ACE_HAS_TIUSER_H || ACE_HAS_XTI */ + +#if defined (ACE_HAS_XLI) +# include <xliuser.h> +#endif + +#ifndef _THREAD_SAFE +# define _THREAD_SAFE +#endif + ], + [ + ace_cv_lib_has_t_errno=yes + ], + [ + ace_cv_lib_has_t_errno=no + ]) + ], + [ + dnl Do not define ACE_HAS_BROKEN_T_ERRNO if t_errno isn't declared in a + dnl header since ACE's definition of _terrno needs a previously declared + dnl t_errno. + AC_CHECK_FUNC(_terrno, , AC_DEFINE(ACE_HAS_BROKEN_T_ERRNO)) + ], + [ + AC_DEFINE(ACE_LACKS_T_ERRNO) + ]) + +fi dnl test "$ace_has_tli" = yes +fi dnl test "$ace_has_tli_funcs" = yes + +AC_CHECK_HEADER(sys/time.h, dnl + [ + AC_EGREP_HEADER(sys/time.h, time.h, + , + [ + AC_DEFINE(ACE_LACKS_SYSTIME_H) + ]) + ],) + +dnl See the notes about ACE_LACKS_MMAP in the functions section of this +dnl configure script. +dnl -Ossama +AC_CHECK_HEADER(sys/mman.h, dnl + [ + AC_EGREP_HEADER(extern \"C\", sys/mman.h, + , + [ + AC_DEFINE(ACE_HAS_BROKEN_MMAP_H) + ]) + ], + [ + AC_DEFINE(ACE_LACKS_MMAP) + ]) + +dnl Check for bzero() prototype if bstring.h exists. +AC_CHECK_HEADER(bstring.h, dnl + [ + AC_EGREP_HEADER(bzero, bstring.h, + [ + AC_DEFINE(ACE_HAS_BSTRING) + ],) + ],) + +AC_CHECK_HEADER(strings.h, dnl + [ + AC_EGREP_HEADER(bzero, strings.h, + [ + AC_DEFINE(ACE_HAS_STRINGS) + ],) + ],) + +AC_CHECK_HEADER(sys/syscall.h, dnl + AC_DEFINE(ACE_HAS_SYSCALL_H),) + +AC_CHECK_HEADER(poll.h, dnl + AC_DEFINE(ACE_HAS_POLL),) + +dnl We want AC_CHECK_HEADERS so that "HAVE_PWD_H" gets defined if we have it. +dnl "HAVE_PWD_H" is used in one of the tests later on. +AC_CHECK_HEADERS(pwd.h,,) dnl + +AC_CHECK_HEADER(regexpr.h, dnl + AC_DEFINE(ACE_HAS_REGEX),) + +AC_CHECK_HEADER(stropts.h, dnl + AC_DEFINE(ACE_HAS_STREAMS),) + +AC_CHECK_HEADER(siginfo.h, dnl + , + AC_DEFINE(ACE_LACKS_SIGINFO_H)) + +AC_CHECK_HEADER(unistd.h, dnl + , + AC_DEFINE(ACE_LACKS_UNISTD_H)) + +AC_CHECK_HEADER(ucontext.h, dnl + , + AC_DEFINE(ACE_LACKS_UCONTEXT_H)) + +AC_CHECK_HEADER(utime.h, dnl + AC_DEFINE(ACE_HAS_UTIME),) + +dnl This check will be disabled until we can get ACE to compile when it +dnl ACE_HAS_UNICODE is defined on UN*X systems +dnl AC_CHECK_HEADER(wchar.h, +dnl AC_DEFINE(ACE_HAS_UNICODE),) + +AC_CHECK_HEADER(libc.h, dnl + AC_DEFINE(ACE_HAS_LIBC_H)) + +AC_CHECK_HEADER(osfcn.h, dnl + AC_DEFINE(ACE_HAS_OSFCN_H)) + +AC_CHECK_HEADER(new, dnl + AC_DEFINE(ACE_HAS_NEW_NO_H), + [ + AC_CHECK_HEADER(new.h, dnl + AC_DEFINE(ACE_HAS_NEW_H)) + ]) + +AC_CHECK_HEADER(stdexcept, dnl + AC_DEFINE(ACE_HAS_STDEXCEPT_NO_H), + [ + AC_CHECK_HEADER(exception.h, dnl + AC_DEFINE(ACE_HAS_EXCEPTION_H)) + ]) + +AC_CHECK_HEADER(iomanip, dnl + AC_DEFINE(ACE_HAS_IOMANIP_NO_H)) + +dnl ace/OS.i can #include <cstring>, not #include <cstring.h> +dnl "cstring" is the correct form. +dnl TODO: Double check the above comment. +AC_CHECK_HEADER(cstring, dnl + AC_DEFINE(ACE_HAS_GNU_CSTRING_H),) + +AC_CHECK_HEADER(auto_ptr,,) dnl + +AC_CHECK_HEADER(map, dnl +[ + AC_CHECK_HEADER(net/if.h, + [ + ACE_CACHE_CHECK(if STL map class conflicts with <net/if.h> map struct, + ace_cv_header_stl_map_conflict, + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <map> +#include <net/if.h> + ], + [ + map<char, char> ace_map; + ], + [ + ace_cv_header_stl_map_conflict=no + ], + [ + ace_cv_header_stl_map_conflict=yes + ]) + ], AC_DEFINE(ACE_HAS_STL_MAP_CONFLICT),) + ],) +],) + +AC_CHECK_HEADER(queue, dnl +[ + AC_CHECK_HEADER(netinet/in.h, + [ + ACE_CACHE_CHECK(if STL queue class conflicts with <netinet/in.h> queue struct, + ace_cv_header_stl_queue_conflict, + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <queue> +#include <netinet/in.h> + ], + [ + queue<char> ace_queue; + ], + [ + ace_cv_header_stl_queue_conflict=no + ], + [ + ace_cv_header_stl_queue_conflict=yes + ]) + ], AC_DEFINE(ACE_HAS_STL_QUEUE_CONFLICT),) + ],) +],) + +dnl Check for availablity of "new style" C++ stream headers +AC_CHECK_HEADERS(iomanip ios iostream istream ostream fstream streambuf, + , + AC_DEFINE(ACE_USES_OLD_IOSTREAMS)) + +AC_CHECK_HEADER(iostream.h, dnl + AC_CHECK_HEADER(fstream.h, , AC_DEFINE(ACE_LACKS_IOSTREAM_TOTALLY)), + AC_DEFINE(ACE_LACKS_IOSTREAM_TOTALLY)) + +dnl Check if platform needs to #include <sched.h> to get thread +dnl scheduling defs. +ACE_CACHE_CHECK(if platform needs sched.h for thread scheduling definitions, + ace_cv_needs_sched_h,[ + AC_EGREP_HEADER(sched_yield, sched.h, + [ + ace_cv_needs_sched_h=yes + ], + [ + ace_cv_needs_sched_h=no + ]) + ], AC_DEFINE(ACE_LACKS_SCHED_H),) + +dnl Check if platform needs to #include <regexpr.h> for +dnl regular expression support +ACE_CACHE_CHECK(if platform needs regexpr.h for regular expression support, + ace_cv_needs_regexpr_h, [ + AC_EGREP_HEADER(compile, regexpr.h, + [ + ace_cv_needs_regexpr_h=yes + AC_DEFINE(ACE_NEEDS_REGEXPR_H) + ], + [ + AC_EGREP_HEADER(step, regexpr.h, + [ + ace_cv_needs_regexpr_h=yes + ], + [ + ace_cv_needs_regexpr_h=no + ]) + ]) + ], AC_DEFINE(ACE_NEEDS_REGEXPR_H),) + +dnl Check if sprintf() returns char* +ACE_CONVERT_WARNINGS_TO_ERRORS([ +ACE_CACHE_CHECK(if sprintf() returns char*, + ace_cv_lib_charptr_sprintf, + [ + AC_TRY_COMPILE( + [ +#include <stdlib.h> +#include <stdio.h> + ], + [ + char *str = 0; + const char *fmt = "%d"; + int num = 0; + + char *s = 0; + + s = sprintf(str, fmt, num); + ], + [ + ace_cv_lib_charptr_sprintf=yes + ], + [ + ace_cv_lib_charptr_sprintf=no + ]) + ], AC_DEFINE(ACE_HAS_CHARPTR_SPRINTF),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check for getopt() prototype +ACE_CACHE_CHECK(for getopt() prototype, ace_cv_lib_getopt_proto, [ + AC_EGREP_HEADER(getopt, unistd.h, + [ + ace_cv_lib_getopt_proto=yes + ], + [ + AC_EGREP_HEADER(getopt, stdlib.h, + [ + ace_cv_lib_getopt_proto=yes + ], + [ + ace_cv_lib_getopt_proto=no + ]) + ]) +], , AC_DEFINE(ACE_LACKS_GETOPT_PROTO)) + +dnl Check for old malloc() prototype. +ACE_CONVERT_WARNINGS_TO_ERRORS([ +ACE_CACHE_CHECK(for old malloc() prototype, + ace_cv_lib_old_malloc_proto, + [ + AC_TRY_COMPILE( + [ +#include <stdlib.h> +#ifndef ACE_LACKS_MALLOC_H +# include <malloc.h> +#endif + ], + [ + char *s = 0; + s = malloc(sizeof(int)); + ], + [ + ace_cv_lib_old_malloc_proto=yes + ], + [ + ace_cv_lib_old_malloc_proto=no + ]) + ], AC_DEFINE(ACE_HAS_OLD_MALLOC),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check for *_timedwait() prototypes +dnl TODO: We only check for one of the *_timedwait() prototypes. +dnl Is this enough? +ACE_CACHE_CHECK(for *_timedwait() prototypes, ace_cv_lib_timedwait_proto, [ + AC_EGREP_HEADER(recv_timedwait, pthread.h, + [ + ace_cv_lib_timedwait_proto=yes + ], + [ + AC_EGREP_HEADER(recv_timedwait, fcntl.h, + [ + ace_cv_lib_timedwait_proto=yes + ], + [ + ace_cv_lib_timedwait_proto=no + ]) + ]) +], , AC_DEFINE(ACE_LACKS_TIMEDWAIT_PROTOTYPES)) + +dnl Check for ualarm prototype in unistd.h. +dnl Most Unices seem to put it there (?) +ACE_CACHE_CHECK(for ualarm() prototype, ace_cv_lib_ualarm_proto, [ + AC_EGREP_HEADER(ualarm, unistd.h, + [ + ace_cv_lib_ualarm_proto=yes + ], + [ + ace_cv_lib_ualarm_proto=no + ]) +], , AC_DEFINE(ACE_LACKS_UALARM_PROTOTYPE)) + +dnl Check for getrusage prototype in sys/resource.h +ACE_CACHE_CHECK(for getrusage() in sys/resource.h, + ace_cv_lib_has_getrusage_proto, [ + AC_EGREP_HEADER(getrusage, sys/resource.h, + [ + ace_cv_lib_has_getrusage_proto=yes + ], + [ + ace_cv_lib_has_getrusage_proto=no + ]) +], AC_DEFINE(ACE_HAS_GETRUSAGE_PROTO),) + +dnl Check for {get,set}rlimit prototypes in sys/resource.h +ACE_CACHE_CHECK(for getrlimit() and setrlimit() in sys/resource.h, + ace_cv_lib_has_getsetrlimit_proto, [ + AC_EGREP_HEADER(getrlimit, sys/resource.h, + [ + AC_EGREP_HEADER(getrlimit, sys/resource.h, + [ + ace_cv_lib_has_getsetrlimit_proto=yes + ], + [ + ace_cv_lib_has_getsetrlimit_proto=no + ]) + ], + [ + ace_cv_lib_has_getsetrlimit_proto=no + ]) +], , AC_DEFINE(ACE_LACKS_RLIMIT_PROTOTYPE)) + +dnl Check for platforms that don't declare dl* functions +dnl as extern "C" in dlfcn.h. +dnl TODO: This check looks feeble to me... +dnl NOTE: Linux header files ARE protected with extern "C" by the +dnl __BEGIN_DECLS macro, so don't be surprised! +ACE_CACHE_CHECK(if dlfcn.h is protected by extern \"C\", + ace_cv_lib_dlfcn_with_extern_c,[ + AC_EGREP_HEADER(extern \"C\", dlfcn.h, + [ + ace_cv_lib_dlfcn_with_extern_c=yes + ], + [ + ace_cv_lib_dlfcn_with_extern_c=no + ]) +], , AC_DEFINE(ACE_HAS_DLFCN_H_BROKEN_EXTERN_C)) + +dnl +dnl SECTION 6: Checks for typedefs +dnl + +dnl Standard typedef checks (All of them may not be needed +AC_TYPE_UID_T +AC_TYPE_MODE_T +AC_TYPE_OFF_T +AC_TYPE_PID_T +AC_TYPE_SIZE_T + +dnl Specific typedef checks +dnl TODO: Check whether these typedefs can be defined somewhere else. +ACE_CHECK_TYPE(idtype_t, signal.h, AC_DEFINE(ACE_HAS_IDTYPE_T),) +ACE_CHECK_TYPE(sem_t, semaphore.h,,) +ACE_CHECK_TYPE(key_t, sys/types.h, ,AC_DEFINE(ACE_LACKS_KEY_T)) +ACE_CHECK_TYPE(ssize_t, sys/types.h, AC_DEFINE(ACE_HAS_SSIZE_T),) +ACE_CHECK_TYPE(u_longlong_t, sys/types.h, , AC_DEFINE(ACE_LACKS_U_LONGLONG_T)) +ACE_CHECK_TYPE(pri_t, sys/types.h, ,AC_DEFINE(ACE_LACKS_PRI_T)) +ACE_CHECK_TYPE(socklen_t, sys/socket.h, AC_DEFIE(ACE_HAS_SOCKLEN_T),) +ACE_CHECK_TYPE(ucontext_t, ucontext.h, AC_DEFINE(ACE_HAS_UCONTEXT_T),) +ACE_CHECK_TYPE(wchar_t, wchar.h, AC_DEFINE(ACE_HAS_XPG4_MULTIBYTE_CHAR), + [ + ACE_CHECK_TYPE(wchar_t, sys/types.h,,AC_DEFINE(ACE_LACKS_WCHAR_T)) + ]) + +dnl Check for sig_atomic_t +ACE_CACHE_CHECK(for sig_atomic_t, + ace_cv_lib_posix_defines_sig_atomic_t,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <signal.h> + ], + [ + sig_atomic_t sat; + ], + [ + ace_cv_lib_posix_defines_sig_atomic_t=yes + ], + [ + ace_cv_lib_posix_defines_sig_atomic_t=no + ]) +], AC_DEFINE(ACE_HAS_SIG_ATOMIC_T),) + +dnl +dnl SECTION 7: checks for structures +dnl + +dnl TODO: Check whether these structures can be defined somewhere else. +ACE_CHECK_STRUCT(flock, fcntl.h, , AC_DEFINE(ACE_LACKS_FILELOCKS)) +ACE_CHECK_STRUCT(rwlock_t, synch.h, , AC_DEFINE(ACE_LACKS_RWLOCK_T)) +ACE_CHECK_STRUCT(strbuf, stropts.h, AC_DEFINE(ACE_HAS_STRBUF_T),) +ACE_CHECK_STRUCT(msgbuf, sys/msg.h, , AC_DEFINE(ACE_LACKS_MSGBUF_T)) +case "$target" in +*irix*) + dnl IRIX prusage fields don't match what ACE currently supports. + ;; +*) + ACE_CHECK_STRUCT(prusage_t, sys/procfs.h, AC_DEFINE(ACE_HAS_PRUSAGE_T),) + ;; +esac +ACE_CHECK_STRUCT(strrecvfd, stropts.h, , AC_DEFINE(ACE_LACKS_STRRECVFD)) +ACE_CHECK_STRUCT(sembuf, sys/sem.h, , AC_DEFINE(ACE_LACKS_SEMBUF_T)) +ACE_CHECK_STRUCT(sigaction, signal.h, , AC_DEFINE(ACE_LACKS_SIGACTION)) +ACE_CHECK_STRUCT(sigset_t, signal.h, , AC_DEFINE(ACE_LACKS_SIGSET)) +ACE_CHECK_STRUCT(utsname, sys/utsname.h, , AC_DEFINE(ACE_LACKS_UTSNAME_T)) + +dnl Thanks to Konstantinos Margaritis <kmargar@cc.uoa.gr> for pointing out +dnl that struct siginfo_t may also be defined in signal.h +ACE_CACHE_CHECK(for struct siginfo_t, ace_cv_struct_siginfo_t, + [ + dnl Since we are checking for siginfo_t in more than one header + dnl we can't use the ACE_CHECK_STRUCT macro so we have to do things + dnl manually. + ACE_TRY_COMPILE_STRUCT(siginfo_t, siginfo.h, + [ + ace_cv_struct_siginfo_t=yes + ], + [ + ACE_TRY_COMPILE_STRUCT(siginfo_t, signal.h, + [ + ace_cv_struct_siginfo_t=yes + ], + [ + ace_cv_struct_siginfo_t=no + ]) + ]) + ], + [ + AC_DEFINE(ACE_HAS_SIGINFO_T) + ],) + +dnl Some platforms need to include sys/types.h before sys/socket.h +dnl in order for struct msghdr to work. +dnl Check for msghdr structure. +ACE_CACHE_CHECK(for struct msghdr, ace_cv_struct_msghdr, + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + struct msghdr ace_msghdr; + ], + [ + ace_cv_struct_msghdr=yes + ], + [ + ace_cv_struct_msghdr=no + ]) + ], AC_DEFINE(ACE_HAS_MSG),) + +ACE_CACHE_CHECK(for condition variable support, ace_cv_struct_cond_t, + [ + AC_TRY_COMPILE( + [ +#include <pthread.h> + ], + [ + pthread_cond_t ace_pthread_cond_t; + ], + [ + ace_cv_struct_cond_t=yes + ], + [ + AC_TRY_COMPILE( + [ +#include <synch.h> + ], + [ + cond_t ace_cond_t; + ], + [ + ace_cv_struct_cond_t=yes + ], + [ + ace_cv_struct_cond_t=no + ]) + ]) + ], , AC_DEFINE(ACE_LACKS_COND_T)) + +dnl Check for struct timespec +ACE_CACHE_CHECK(for POSIX timer structure, + ace_cv_lib_posix_timer_struct,[ + AC_TRY_COMPILE( + [ +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + ], + [ + timespec sr; + ], + [ + ace_cv_lib_posix_timer_struct=yes + ], + [ + dnl Check if platform uses struct timestruc_t for POSIX timers + dnl instead of struct timespec. + AC_TRY_COMPILE( + [ +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + ], + [ + timestruc_t sr; + ], + [ + ace_cv_lib_posix_timer_struct=yes + dnl Check for struct timespec in <sys/timers.h> + ACE_CACHE_CHECK(for struct timespec in sys/timers.h, + ace_cv_lib_posix_struct_timespec_broken,[ + AC_TRY_COMPILE( + [ +#include <sys/timers.h> + ], + [ + timespec sr; + ], + [ + ace_cv_lib_posix_struct_timespec_broken=yes + ], + [ + ace_cv_lib_posix_struct_timespec_broken=no + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_POSIX_TIME),) + ], + [ + ace_cv_lib_posix_timer_struct=no + ]) + ]) + ], + [ + AC_DEFINE(ACE_HAS_POSIX_TIME) + if test "$ace_cv_lib_posix_struct_timespec_broken" = yes; then + AC_DEFINE(ACE_HAS_BROKEN_POSIX_TIME) + fi + ], + [ + dnl Check for struct timespec in <sys/timers.h> + ACE_CACHE_CHECK(for struct timespec in sys/timers.h, + ace_cv_lib_posix_struct_timespec_broken,[ + AC_TRY_COMPILE( + [ +#include <sys/timers.h> + ], + [ + timespec sr; + ], + [ + ace_cv_lib_posix_struct_timespec_broken=yes + ], + [ + ace_cv_lib_posix_struct_timespec_broken=no + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_POSIX_TIME),) + ]) + +dnl Check for typedef timespec_t +dnl TODO: Check whether this typedef can be defined somewhere else. +ACE_CACHE_CHECK(for timespec_t, + ace_cv_lib_posix_timespec_t,[ + AC_TRY_COMPILE( + [ +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + ], + [ + timespec_t tt; + ], + [ + ace_cv_lib_posix_timespec_t=yes + ], + [ + ace_cv_lib_posix_timespec_t=no + ]) +], , AC_DEFINE(ACE_LACKS_TIMESPEC_T)) + +dnl Check for union semun +ACE_CACHE_CHECK(for union semun, + ace_cv_lib_posix_defines_union_semun,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/sem.h> + ], + [ + semun us; + ], + [ + ace_cv_lib_posix_defines_union_semun=yes + ], + [ + ace_cv_lib_posix_defines_union_semun=no + ]) +], AC_DEFINE(ACE_HAS_SEMUN),) + +dnl +dnl SECTION 8: checks for variables +dnl + +dnl Check for broken struct timespec members +ACE_CACHE_CHECK(for broken struct timespec members, + ace_cv_lib_broken_timespec, + [ + AC_TRY_COMPILE( + [ +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + ], + [ + timespec sr; + sr.ts_sec = 0; + sr.ts_nsec = 0; + ], + [ + ace_cv_lib_broken_timespec=yes + ], + [ + ace_cv_lib_broken_timespec=no + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_TIMESPEC_MEMBERS),) + +dnl Check for more than two fields in struct rusage +ACE_CACHE_CHECK(for limited struct rusage, + ace_cv_lib_limited_rusage,[ + AC_TRY_COMPILE( + [ +#include <sys/resource.h> + ], + [ + rusage ace_rusage; + /* + We just pick three (i.e. > 2) of the fields that + ACE uses to see if we have a struct rusage that + has more than two fields. + */ + ace_rusage.ru_ixrss = 0; + ace_rusage.ru_idrss = 0; + ace_rusage.ru_isrss = 0; + ], + [ + ace_cv_lib_limited_rusage=no + ], + [ + ace_cv_lib_limited_rusage=yes + ]) +], AC_DEFINE(ACE_HAS_LIMITED_RUSAGE_T),) + +if test "$ace_cv_struct_siginfo_t" = yes; then + dnl Check for si_addr member in struct siginfo_t + ACE_CACHE_CHECK(for si_addr member in struct siginfo_t, + ace_cv_lib_posix_si_addr,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SIGINFO_H +# include <siginfo.h> +#endif +#include <signal.h> + ], + [ + siginfo_t acesig; + acesig.si_addr = 0; + ], + [ + ace_cv_lib_posix_si_addr=yes + ], + [ + ace_cv_lib_posix_si_addr=no + ]) + ], , AC_DEFINE(ACE_LACKS_SI_ADDR)) +fi dnl test "$ace_cv_struct_siginfo_t" = yes + +dnl Check for sin_len member in struct sockaddr_in +ACE_CACHE_CHECK(for sin_len member in struct sockaddr_in, + ace_cv_lib_has_sin_len,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +qQqq#include <netinet/in.h> + ], + [ + sockaddr_in ace_sin; + ace_sin.sin_len = sizeof(ace_sin); + ], + [ + ace_cv_lib_has_sin_len=yes + ], + [ + ace_cv_lib_has_sin_len=no + ]) +], AC_DEFINE(ACE_HAS_SIN_LEN),) + +dnl Check for sys_siglist +dnl TODO: Check whether this variable can be defined somewhere else. +dnl [OSSAMA: Should we use autoconf's AC_DECL_SYS_SIGLIST test instead?] +ACE_CACHE_CHECK(for sys_siglist, + ace_cv_lib_posix_sys_siglist,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif +#include <signal.h> +#if !defined (_sys_siglist) +# define _sys_siglist sys_siglist +#endif + ], + [ + void* vp = (void*) &_sys_siglist; + ], + [ + ace_cv_lib_posix_sys_siglist=yes + ], + [ + ace_cv_lib_posix_sys_siglist=no + ]) +], AC_DEFINE(ACE_HAS_SYS_SIGLIST),) + +dnl Check for sys_errlist +dnl TODO: Check whether this variable can be defined somewhere else. +ACE_CACHE_CHECK(for sys_errlist, + ace_cv_lib_posix_sys_errlist,[ + AC_TRY_COMPILE( + [ +#include <stdio.h> +#include <errno.h> +#if !defined (_sys_errlist) +# define _sys_errlist sys_errlist +#endif + ], + [ + void* vp = (void*) &_sys_errlist; + ], + [ + ace_cv_lib_posix_sys_errlist=yes + ], + [ + ace_cv_lib_posix_sys_errlist=no + ]) +], AC_DEFINE(ACE_HAS_SYS_ERRLIST),) + +dnl Check for sys_nerr +dnl TODO: Check whether this variable can be defined somewhere else. +ACE_CACHE_CHECK(for sys_nerr in headers, + ace_cv_lib_posix_sys_nerr,[ + AC_TRY_COMPILE( + [ +#include <stdio.h> +#include <errno.h> +#if !defined (_sys_nerr) +# define _sys_nerr sys_nerr +#endif + ], + [ + void* vp = (void*) &_sys_nerr; + ], + [ + ace_cv_lib_posix_sys_nerr=yes + ], + [ + ace_cv_lib_posix_sys_nerr=no + ]) + ], + [ + dnl Do nothing + ], + [ + AC_CHECK_FUNC(sys_nerr,, + AC_DEFINE(ACE_LACKS_SYS_NERR)) + ]) + +dnl +dnl SECTION 9: checks for compiler characteristics +dnl + +dnl Check if compiler accepts "#pragma once" directive +ACE_CONVERT_WARNINGS_TO_ERRORS([ + ACE_CACHE_CHECK(if compiler accepts \"pragma once\" directive, + ace_cv_has_pragma_once, + [ + AC_TRY_COMPILE( + [ +#pragma once + ], + [ + int a = 0; /* Put this here so we don't have an empty main(). */ + ], + [ + ace_cv_has_pragma_once=yes + ], + [ + ace_cv_has_pragma_once=no + ]) + ], , AC_DEFINE(ACE_LACKS_PRAGMA_ONCE)) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl If we are using GNU C++, see if it accepts the -pipe compiler flag. +dnl "-pipe" on cygwin32 doesn't seem to work, for example. +if test -n "$GXX"; then + PREPIPECXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS -pipe" + PREPIPECFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -pipe" + ACE_CACHE_CHECK(if \"-pipe\" compiler flag is supported, + ace_cv_feature_gxx_has_pipe, + [ + AC_TRY_COMPILE(, [int a = 0;], + [ + ace_cv_feature_gxx_has_pipe=yes + ], + [ + ace_cv_feature_gxx_has_pipe=no + ]) + ], + [ + dnl We don't need to add "-pipe" here since it was already added + dnl for the test. + dnl CXXFLAGS="$PREPIPECXXFLAGS -pipe" + dnl CFLAGS="$PREPIPECFLAGS -pipe" + ], + [ + CXXFLAGS="$PREPIPECXXFLAGS" + CFLAGS="$PREPIPECFLAGS" + ]) +fi + +dnl Check for working "const" +dnl This test doesn't always work. +dnl AC_C_CONST + +dnl Check for working "inline" +AC_C_INLINE +if test "$ac_cv_c_inline" = no; then + AC_DEFINE(ACE_LACKS_INLINE_FUNCTIONS) +fi + +dnl Check to see if we are running on a big endian platform +dnl "ace/Basic_Types.h" should perhaps be modified to take advantage +dnl of the results of this test. +dnl Do not run this test if we are using a cross-compiler. +if test "$cross_compiling" != yes; then + AC_C_BIGENDIAN +fi + +dnl Check type sizes +dnl If we get a size of zero, then the type is unknown to the compiler. + +dnl We don't need to check for sizeof(char) right now. Also conflicts with +dnl ACE definition in Basic_Types.h, so we leave the test out. +if test "$cross_compiling" != yes; then + dnl AC_CHECK_SIZEOF(char, 1) + dnl if test "$ac_cv_sizeof_char" != "0"; then + dnl AC_DEFINE(ACE_SIZEOF_CHAR, SIZEOF_CHAR) + dnl fi + AC_CHECK_SIZEOF(short, 2) + if test $ac_cv_sizeof_short != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_SHORT, $ac_cv_sizeof_short) + fi + AC_CHECK_SIZEOF(int, 4) + if test $ac_cv_sizeof_int != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_INT, $ac_cv_sizeof_int) + fi + AC_CHECK_SIZEOF(long, 4) + if test $ac_cv_sizeof_long != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_LONG, $ac_cv_sizeof_long) + fi + AC_CHECK_SIZEOF(long long, 8) + if test $ac_cv_sizeof_long_long != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_LONG_LONG, $ac_cv_sizeof_long_long) + else + AC_DEFINE(ACE_LACKS_LONGLONG_T) + fi + AC_CHECK_SIZEOF(void *, 4) + if test $ac_cv_sizeof_void_p != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_VOID_P, $ac_cv_sizeof_void_p) + fi + AC_CHECK_SIZEOF(float, 4) + if test $ac_cv_sizeof_float != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_FLOAT, $ac_cv_sizeof_float) + else + AC_DEFINE(ACE_LACKS_FLOATING_POINT) + fi + AC_CHECK_SIZEOF(double, 8) + if test $ac_cv_sizeof_double != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_DOUBLE, $ac_cv_sizeof_double) + else + AC_DEFINE(ACE_LACKS_FLOATING_POINT) + fi + AC_CHECK_SIZEOF(long double, 16) + if test $ac_cv_sizeof_long_double != 0; then + AC_DEFINE_UNQUOTED(ACE_SIZEOF_LONG_DOUBLE, $ac_cv_sizeof_long_double) + fi + + dnl Set the 64 bit unsigned int typedef + ACE_UINT64="" + dnl if test "$ace_cv_type_u_longlong_t" = yes; then + dnl This doesn't work: AC_CHECK_SIZEOF(u_longlong_t, 8) + dnl if test $ac_cv_sizeof_u_longlong_t = 8; then + dnl ACE_UINT64="u_longlong_t" + dnl ace_u_long_long_typedef_set=yes + dnl fi + dnl elif test $ac_cv_sizeof_long = 8; then + if test $ac_cv_sizeof_long = 8; then + ACE_UINT64="unsigned long" + ace_u_long_long_typedef_set=yes + elif test $ac_cv_sizeof_long_long = 8; then + ACE_UINT64="unsigned long long" + ace_u_long_long_typedef_set=yes + else + ace_u_long_long_typedef_set=no + fi + + dnl Check for broken "signed char" + dnl If AC_CHECK_SIZEOF(signed char) returns zero then "signed char" + dnl is broken. + AC_CHECK_SIZEOF(signed char, 1) + if test $ac_cv_sizeof_signed_char = 0; then + AC_DEFINE(ACE_LACKS_SIGNED_CHAR) + fi +fi dnl test "$cross_compiling" != yes + +dnl Other checks + +dnl Check if we have working C++ explicit template destructors +dnl Thanks to Nanbor Wang <nanbor@cs.wustl.edu> for providing this test. +ACE_CACHE_CHECK(for working C++ explicit template destructors, + ace_cv_feature_working_explicit_des, + [ + AC_TRY_COMPILE([ +#include <iostream.h> + +class dyn +{ + public: + dyn () { cout << "dyn" << endl; } + ~dyn () { cout << "~dyn" << endl; } +}; + +template <class T> +class Base +{ + public: + Base () { cout << "Base" << endl; } + virtual void f (void) { cout << "Base::f" << endl; } + ~Base () { cout << "~Base" << endl; } +}; + +template <class T> +class Derived +{ + public: + Derived () + { + x_ = new Base<T> (); cout << "Derived" << endl ; + } + virtual void f (void) { cout << "Derived::f" << endl; } + ~Derived () { x_->~Base (); cout << "~Derived" << endl; } + private: + Base<T> *x_; + T t_; +}; + ], + [ + Derived<dyn> *x = new Derived<dyn> (); + + x->f (); + + delete x; + return 0; + ], + [ + ace_cv_feature_working_explicit_des=yes + ], + [ + ace_cv_feature_working_explicit_des=no + ]) + ], AC_DEFINE(ACE_HAS_WORKING_EXPLICIT_TEMPLATE_DESTRUCTOR),) + +dnl Checkfor C++ "using" keyword support +ACE_CACHE_CHECK(for C++ \"using\" keyword support, + ace_cv_feature_cxx_using_keyword, + [ + AC_TRY_COMPILE([ +#include <iostream.h> + ], + [ + using namespace std; + ], + [ + ace_cv_feature_cxx_using_keyword=yes + ], + [ + ace_cv_feature_cxx_using_keyword=no + ]) + ], AC_DEFINE(ACE_HAS_USING_KEYWORD),) + +dnl Check for C++ standard namespace +ACE_CACHE_CHECK(for C++ standard namespace, + ace_cv_feature_posix_uses_std_namespace,[ + AC_TRY_COMPILE([ +#include <vector.h> + ], + [ + std::vector< int > iv; + ], + [ + ace_cv_feature_posix_uses_std_namespace=yes + ], + [ + ace_cv_feature_posix_uses_std_namespace=no + ]) + ], AC_DEFINE(ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB),) + +dnl Check for new style C++ include file support +ACE_CACHE_CHECK(for new style C++ include file support, + ace_cv_lib_posix_standard_includes,[ + ace_cv_lib_posix_standard_includes=no + if test "$ace_cv_feature_posix_uses_std_namespace" = yes; then + AC_TRY_COMPILE( + [ +#include <string> + ], + [ + std::string str; + ], + ace_cv_lib_posix_standard_includes=yes) + else + AC_TRY_COMPILE( + [ +#include <string> + ], + [ + string str; + ], + ace_cv_lib_posix_standard_includes=yes) + fi + ], + [ + AC_DEFINE(ACE_HAS_STDCPP_STL_INCLUDES) + AC_DEFINE(ACE_HAS_STRING_CLASS) + ],) + +dnl Check for ANSI C++ cast support +ACE_CACHE_CHECK(for ANSI C++ cast support, + ace_cv_lib_posix_standard_casts,[ + AC_TRY_COMPILE( + [/* No headers */], + [ + class B { public: int b_; virtual int b() const = 0; }; + class D : public B { virtual int b() const { return b_; } }; + + void* vp = 0; + char* cp = 0; + float f = 1.0; + int i = 0; + int* ip = 0; + const int* jp = 0; + + i = static_cast<int> (f); + ip = const_cast<int*> (jp); + cp = reinterpret_cast<char*> (vp); + + B* bp = new D; + D* dp = dynamic_cast<D*> (bp); + delete bp; + ], + [ + ace_cv_lib_posix_standard_casts=yes + AC_CACHE_VAL(ace_cv_lib_rtti, ace_cv_lib_rtti=yes) + ], + [ + AC_TRY_COMPILE( + [/* No headers */], + [ + class B { public: int b_; virtual int b() const = 0; }; + class D : public B { virtual int b() const { return b_; } }; + + void* vp = 0; + char* cp = 0; + float f = 1.0; + int i = 0; + int* ip = 0; + const int* jp = 0; + + i = static_cast<int> (f); + ip = const_cast<int*> (jp); + cp = reinterpret_cast<char*> (vp); + ], + [ + ace_cv_lib_posix_standard_casts=yes + AC_CACHE_VAL(ace_cv_lib_rtti, ace_cv_lib_rtti=no) + ], + [ + ace_cv_lib_posix_standard_casts=no + ]) + ]) + ], + [ + AC_DEFINE(ACE_HAS_ANSI_CASTS) + if test "$ace_cv_lib_rtti" = no; then + AC_DEFINE(ACE_LACKS_RTTI) + fi + ],) + +dnl Check if platform supports explicit template instantiation +ACE_CACHE_CHECK(if platform supports explicit template instantiation, + ace_cv_feature_explicit_template_instantiation,[ + AC_TRY_COMPILE([ + template <class T> + class Foo + { + public: + Foo(T bar) : bar_(bar) {}; + private: + T bar_; + }; + template class Foo<int>; + ], + [ + Foo<int> foo(11); + ], + [ + ace_cv_feature_explicit_template_instantiation=yes + ], + [ + ace_cv_feature_explicit_template_instantiation=no + ]) + ], + [ + AC_DEFINE(ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + ], + [ + ACE_CACHE_CHECK(if platform supports pragma template instantiation, + ace_cv_feature_pragma_template_instantiation,[ + AC_TRY_COMPILE([ + template <class T> + class Foo + { + public: + Foo(T bar) : bar_(bar) {}; + private: + T bar_; + }; +#pragma instantiate Foo<int>; + ], + [ + Foo<int> foo(11); + ], + [ + ace_cv_feature_pragma_template_instantiation=yes + ], + [ + ace_cv_feature_pragma_template_instantiation=no + ]) + ], AC_DEFINE(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA),) + ]) + +dnl Check if templates require source on platform +dnl FIXME: This test may be broken. +ACE_CACHE_CHECK(if templates require source on platform, + ace_cv_feature_templates_require_source,[ + AC_TRY_LINK([ +/* +#include "config/trs.h" +*/ + ], + [ + Foo<int> foo(15); + ], + [ + ace_cv_feature_templates_require_source=no + ], + [ + ace_cv_feature_templates_require_source=yes + ]) + ], + [ + AC_DEFINE(ACE_TEMPLATES_REQUIRE_SOURCE) + ],) +AM_CONDITIONAL(TEMPLATES_REQUIRE_SOURCE, + test X$ace_cv_feature_templates_require_source = Xyes) + +dnl Check if platform supports template specialization +ACE_CACHE_CHECK(if platform supports template specialization, + ace_cv_feature_posix_template_specialization,[ + AC_TRY_COMPILE([ + template <class T> + class Foo + { + public: + Foo(T bar) : bar_(bar) {}; + private: + T bar_; + }; + class Foo<int> + { + public: + Foo(int bar) : bar_(bar + 1) {}; + private: + int bar_; + }; + ], + [ + Foo<int> foo(11); + ], + [ + ace_cv_feature_posix_template_specialization=yes + ], + [ + ace_cv_feature_posix_template_specialization=no + ]) + ], AC_DEFINE(ACE_HAS_TEMPLATE_SPECIALIZATION),) + +dnl Check if platform supports typename keyword +ACE_CACHE_CHECK(if platform supports typename keyword, + ace_cv_feature_posix_typename_keyword,[ + AC_TRY_COMPILE([ + class Bar + { + public: + typedef int Y; + Bar(int bar) : bar_(bar) {} + private: + int bar_; + }; + + template <class T> + class Foo + { + public: + typedef typename T::Y Y; + Foo(T* foo) : foo_(foo) {} + void bilbo(typename T::Y y); + private: + T* foo_; + }; + + template <class T> + void Foo<T>::bilbo(typename T::Y y) + { + } + ], + [ + Bar bar(15); + Foo<Bar> foo(&bar); + foo.bilbo(10); + ], + [ + ace_cv_feature_posix_typename_keyword=yes + ], + [ + ace_cv_feature_posix_typename_keyword=no + ]) + ], AC_DEFINE(ACE_HAS_TYPENAME_KEYWORD),) + +dnl Check if platform supports template typedefs +ACE_CACHE_CHECK(if platform supports template typedefs, + ace_cv_feature_posix_template_typedefs,[ + AC_TRY_COMPILE([ +#if defined (ACE_HAS_TYPENAME_KEYWORD) +#define TYPENAME typename +#else +#define TYPENAME +#endif + + class Bar + { + public: + typedef int Y; + Bar(int bar) : bar_(bar) {} + int value() const { return bar_; } + private: + int bar_; + }; + + template <class T> + class Foo + { + public: + typedef TYPENAME T::Y Y; + Foo(T* foo) : foo_(foo) {} + void print(Y y); + private: + T* foo_; + }; + + template <class T> + void Foo<T>::print(TYPENAME T::Y y) + { + } + ], + [ + Bar bar(15); + Foo<Bar> foo(&bar); + foo.print(11); + ], + [ + ace_cv_feature_posix_template_typedefs=yes + ], + [ + ace_cv_feature_posix_template_typedefs=no + ]) + ], AC_DEFINE(ACE_HAS_TEMPLATE_TYPEDEFS),) + +dnl Check if platform supports static data member templates +ACE_CACHE_CHECK(if platform supports static data member templates, + ace_cv_feature_posix_static_data_member_templates,[ + AC_TRY_COMPILE([ + template <class T> + class Foo + { + public: + static T* sdm; + }; + template <class T> T* Foo<T>::sdm = 0; + ], + [ + /* No body */ + ], + [ + ace_cv_feature_posix_static_data_member_templates=yes + ], + [ + ace_cv_feature_posix_static_data_member_templates=no + ]) + ], ,AC_DEFINE(ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)) + +dnl if platform supports C++ exceptions +if test "$ace_user_enable_exceptions" = yes; then + ACE_CACHE_CHECK(if platform supports C++ exceptions, + ace_cv_feature_posix_exceptions,[ + AC_TRY_COMPILE(, + [ + int ret = 0; + class ACE {}; + try + { + throw ACE(); + } + catch (ACE) + { + ret = 1; + } + ], + [ + ace_cv_feature_posix_exceptions=yes + ], + [ + ace_cv_feature_posix_exceptions=no + ]) + ], AC_DEFINE(ACE_HAS_EXCEPTIONS), ace_user_enable_exceptions=no) + +fi dnl test "$ace_user_enable_exceptions" = yes + +dnl Check if we need a non-static object manager +dnl TODO / FIXME +dnl ACE_CACHE_CHECK(if we need a non-static object manager, +dnl ace_cv_feature_nonstatic_object_manager,[ +dnl ace_cv_feature_nonstatic_object_manager=yes + dnl TODO: Should we check for this thing (and HOW), or + dnl should it be the user's choice? + dnl + dnl For now, we will leave it as a user's choice. + dnl -Ossama +dnl ], +dnl [ + dnl Don't define anything until we have a test for this. + dnl AC_DEFINE(ACE_HAS_NONSTATIC_OBJECT_MANAGER) +dnl ],) + +dnl Check whether platform supports the standard C++ library +dnl TODO: For now, check whether headers <new> and <iomanip> +dnl and <auto_ptr> exist; is there a better way? +if test "$ac_cv_header_new" = yes && + test "$ac_cv_header_iomanip" = yes && + test "$ac_cv_header_auto_ptr" = yes; then + AC_DEFINE(ACE_HAS_STANDARD_CPP_LIBRARY) +fi + + +dnl +dnl SECTION 10: checks for library functions +dnl + +AC_FUNC_ALLOCA +if test "$ac_cv_header_alloca_h" = yes; then + AC_DEFINE(ACE_HAS_ALLOCA_H) +fi +if test "$ac_cv_func_alloca_works" = yes; then + AC_DEFINE(ACE_HAS_ALLOCA) +fi + +dnl ACE should really have something for both the sys/mman.h header +dnl and the mmap function since we need sys/mman.h for functions like +dnl mprotect and msync, but don't want to use mmap if it doesn't work. +dnl For now, we just check for the sys/mman.h header earlier in this +dnl configure script. +dnl +dnl AC_FUNC_MMAP +dnl if test "$ac_cv_func_mmap_fixed_mapped" = no; then +dnl Even if we have mmap, do not use if broken! +dnl AC_DEFINE(ACE_LACKS_MMAP) +dnl fi + +dnl Check if closedir() returns a meaningful value +AC_FUNC_CLOSEDIR_VOID + +dnl Check for PWD functions +AC_CHECK_FUNC(getpwnam,,) dnl +AC_CHECK_FUNC(setpwent,,) dnl +AC_CHECK_FUNC(endpwent,,) dnl +AC_CHECK_FUNC(getpwent,,) dnl + +if test "$ac_cv_func_getpwnam" != yes || + test "$ac_cv_func_setpwent" != yes || + test "$ac_cv_func_endpwent" != yes || + test "$ac_cv_func_getpwent" != yes; then + AC_DEFINE(ACE_LACKS_PWD_FUNCTIONS) +fi + +dnl Check for `strftime' in the `intl' library, for SCO UNIX +AC_FUNC_STRFTIME + +case "$target" in + *win32*) + AC_CHECK_FUNC(CancelIO, dnl + AC_DEFINE(ACE_HAS_CANCEL_IO),) + + AC_CHECK_FUNC(SignalObjectAndWait, dnl + AC_DEFINE(ACE_HAS_SIGNAL_OBJECT_AND_WAIT),) + + AC_CHECK_FUNC(TryEnterCriticalSection, dnl + AC_DEFINE(ACE_HAS_WIN32_TRYLOCK),) + ;; + *) + ;; +esac + +AC_CHECK_FUNC(access, dnl + , + AC_DEFINE(ACE_LACKS_ACCESS)) + +AC_CHECK_FUNC(bsearch, dnl + , + AC_DEFINE(ACE_LACKS_BSEARCH)) + +AC_CHECK_FUNC(qsort, dnl + , + AC_DEFINE(ACE_LACKS_QSORT)) + +dnl ACE uses execv, execvp and execve, so we don't bother to check +dnl for the others (e.g. execl, execlp, execle) +AC_CHECK_FUNCS(execv execvp execve, dnl + , + AC_DEFINE(ACE_LACKS_EXEC)) + +AC_CHECK_FUNC(fcntl, dnl + , + AC_DEFINE(ACE_LACKS_FCNTL)) + +AC_CHECK_FUNC(fsync, dnl + , + AC_DEFINE(ACE_LACKS_FSYNC)) + +dnl TODO: Right now we only check for the getmsg() function when checking +dnl for ACE_HAS_STREAM_PIPES. Is this enough? +AC_CHECK_FUNC(getmsg, dnl + AC_DEFINE(ACE_HAS_STREAM_PIPES),) + +AC_CHECK_FUNC(gethostbyaddr,,) dnl + +dnl We already check for getservbyname during the library checks. +dnl AC_CHECK_FUNC(getservbyname, dnl +dnl , +dnl AC_DEFINE(ACE_LACKS_GETSERVBYNAME)) + +AC_CHECK_FUNC(difftime, dnl + , + AC_DEFINE(ACE_LACKS_DIFFTIME)) + +AC_CHECK_FUNC(bind, dnl + [ + ACE_CACHE_CHECK(if bind() will select the port if it is zero, + ace_cv_have_wildcard_bind, + [ + AC_TRY_RUN( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> +#include <netinet/in.h> +#include <string.h> /* for memset() */ + + int main () { + + int sockfd = socket(AF_INET, SOCK_STREAM, 0); + + sockaddr_in serv_addr; + + (void) memset ((void *) &serv_addr, 0, sizeof(serv_addr)); + + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); + serv_addr.sin_port = 0; + + return bind (sockfd, (struct sockaddr *) &serv_addr, + sizeof(serv_addr)); + } + ], + [ + ace_cv_have_wildcard_bind=yes + ], + [ + ace_cv_have_wildcard_bind=no + ], + [ + dnl action if cross-compiling + ace_cv_have_wildcard_bind=yes + ]) + ],, AC_DEFINE(ACE_LACKS_WILDCARD_BIND)) + ],) + +AC_CHECK_FUNC(poll, dnl + [ + ACE_CACHE_CHECK(if poll is broken, + ace_cv_poll_is_broken, + [ + AC_TRY_RUN( + [ +#include <poll.h> +#include <time.h> + +#ifdef ACE_LACKS_SYSTIME_H +# include <sys/time.h> +#endif + + int main () { + + int timeout = 2000; /* 2000 milliseconds */ + int timeout_arg = timeout; + /* poll() modifies timeout argument on some platforms */ + + int result = 0; + + time_t *t = 0; + + time_t time1 = time(t); + + result = poll(0, 0, timeout_arg); + + time_t time2 = time(t); + time_t diff = time2 - time1; + + /* If (diff * 1000) < timeout then poll() is broken! */ + if (result >= 0) + return (((diff * 1000) < timeout) ? 1 : 0); + else + return 1; /* We had a problem with poll() so we don't + know what really happened. */ + } + ], + [ + ace_cv_poll_is_broken=no + ], + [ + ace_cv_poll_is_broken=yes + ], + [ + dnl action if cross-compiling + ace_cv_poll_is_broken=no + ]) + ], AC_DEFINE(ACE_POLL_IS_BROKEN), AC_DEFINE(ACE_USE_POLL)) + ],) + +AC_CHECK_FUNC(gethrtime, dnl + [ + ACE_CHECK_TYPE(hrtime_t, sys/time.h, AC_DEFINE(ACE_HAS_HI_RES_TIMER),) + ],) + +AC_CHECK_FUNC(pread, dnl + AC_CHECK_FUNC(pwrite, + AC_DEFINE(ACE_HAS_P_READ_WRITE),), + ) + +AC_CHECK_FUNC(readv, , AC_DEFINE(ACE_LACKS_READV)) dnl + +AC_CHECK_FUNC(writev, , AC_DEFINE(ACE_LACKS_WRITEV)) dnl + +AC_CHECK_FUNC(set_t_errno, AC_DEFINE(ACE_HAS_SET_T_ERRNO),) dnl + +AC_CHECK_FUNC(socketpair, dnl + , + AC_DEFINE(ACE_LACKS_SOCKETPAIR)) + +AC_CHECK_FUNC(strcasecmp, dnl + , + AC_DEFINE(ACE_LACKS_STRCASECMP)) + +AC_CHECK_FUNC(strdup, dnl + , + AC_DEFINE(ACE_HAS_STRDUP_EMULATION)) + +AC_CHECK_FUNC(strrchr, dnl + , + AC_DEFINE(ACE_LACKS_STRRCHR)) + +AC_CHECK_FUNC(syscall, dnl + , + AC_DEFINE(ACE_LACKS_SYSCALL)) + +AC_CHECK_FUNC(ualarm, dnl + AC_DEFINE(ACE_HAS_UALARM),) + +AC_CHECK_FUNC(alarm,,) dnl +AC_CHECK_FUNC(signal,,) dnl + +if test "$ac_cv_func_alarm" != yes && + test "$ac_cv_func_signal" != yes; then + AC_DEFINE(ACE_LACKS_UNIX_SIGNALS) +fi + +AC_CHECK_FUNC(clock_gettime, dnl + AC_DEFINE(ACE_HAS_CLOCK_GETTIME),) + +AC_CHECK_FUNC(fork, dnl + , + AC_DEFINE(ACE_LACKS_FORK)) + +AC_CHECK_FUNC(getrlimit, dnl + [ + AC_CHECK_FUNC(setrlimit, + , + AC_DEFINE(ACE_LACKS_RLIMIT)) + ], + [ + AC_DEFINE(ACE_LACKS_RLIMIT) + ]) + +AC_CHECK_FUNC(sysinfo, dnl + [ + if test "$ac_cv_header_sys_systeminfo_h" = yes; then + AC_DEFINE(ACE_HAS_SYSINFO) + fi + ],) + +AC_CHECK_FUNC(strerror, dnl + AC_DEFINE(ACE_HAS_STRERROR),) + +AC_CHECK_FUNC(lstat, dnl + , + AC_DEFINE(ACE_LACKS_LSTAT)) + +AC_CHECK_FUNC(readlink, dnl + , + AC_DEFINE(ACE_LACKS_READLINK)) + +AC_CHECK_FUNC(recvmsg, dnl + , + AC_DEFINE(ACE_LACKS_RECVMSG)) + +AC_CHECK_FUNC(sendmsg, dnl + , + AC_DEFINE(ACE_LACKS_SENDMSG)) + +if test "$ace_has_tli" = yes; then + AC_CHECK_FUNC(t_getname, dnl + AC_DEFINE(ACE_HAS_SVR4_TLI),) +fi + +AC_CHECK_FUNC(getrusage, dnl + AC_DEFINE(ACE_HAS_GETRUSAGE),) + +AC_CHECK_FUNC(getpgid, dnl + , + AC_DEFINE(ACE_LACKS_GETPGID)) + +AC_CHECK_FUNC(getpagesize, dnl + AC_DEFINE(ACE_HAS_GETPAGESIZE), + AC_DEFINE(ACE_PAGE_SIZE, 4096)) + +AC_CHECK_FUNC(msync, dnl + , + AC_DEFINE(ACE_LACKS_MSYNC)) + +AC_CHECK_FUNC(mprotect, dnl + , + AC_DEFINE(ACE_LACKS_MPROTECT)) + +AC_CHECK_FUNC(mkfifo, dnl + , + AC_DEFINE(ACE_LACKS_MKFIFO)) + +AC_CHECK_FUNC(mktemp, dnl + , + AC_DEFINE(ACE_LACKS_MKTEMP)) + +AC_CHECK_FUNC(madvise, dnl + , + AC_DEFINE(ACE_LACKS_MADVISE)) + +if test "$ac_cv_header_sys_priocntl_h" = yes; then + AC_CHECK_FUNC(priocntl, dnl + AC_DEFINE(ACE_HAS_PRIOCNTL),) + +dnl Some platforms define priocntl as a macro! + if test "$ac_cv_func_priocntl" = no; then + ACE_CACHE_CHECK(if platform defines priocntl as a macro, + ace_cv_lib_has_priocntl_macro, + [ + AC_EGREP_CPP(ACE_PRIOCNTL_MACRO, + [ +#include <sys/priocntl.h> + +#if defined (priocntl) + ACE_PRIOCNTL_MACRO +#endif + ], + [ + ace_cv_lib_has_priocntl_macro=yes + ], + [ + ace_cv_lib_has_priocntl_macro=no + ]) + ], AC_DEFINE(ACE_HAS_PRIOCNTL),) + fi dnl test "$ac_cv_func_priocntl" = no +fi dnl test "$ac_cv_header_sys_priocntl_h" = yes + +dnl FIXME: How do we check for a working sbrk()? Do we need to? +AC_CHECK_FUNC(sbrk,, AC_DEFINE(ACE_LACKS_SBRK)) + +dnl Check for SYSV IPC functions +AC_CHECK_FUNC(msgctl,,) + +AC_CHECK_FUNC(msgget,,) + +AC_CHECK_FUNC(msgrcv,,) + +AC_CHECK_FUNC(semctl,,) + +AC_CHECK_FUNC(semget,,) + +AC_CHECK_FUNC(semop,,) + +AC_CHECK_FUNC(shmat,,) + +AC_CHECK_FUNC(shmctl,,) + +AC_CHECK_FUNC(shmdt,,) + +AC_CHECK_FUNC(shmget,,) +dnl End check for SYSV IPC functions + +AC_CHECK_FUNC(read_real_time, dnl + AC_DEFINE(ACE_HAS_AIX_HI_RES_TIMER),) + +AC_CHECK_FUNC(shm_open, dnl + [ + AC_MSG_WARN(platform supports shm_open but shm_open support will not be) + AC_MSG_WARN(enabled since ACE currently supports it only on LynxOS) +dnl AC_DEFINE(ACE_HAS_SHM_OPEN) + ],) + +AC_CHECK_FUNC(tempnam, dnl + , + AC_DEFINE(ACE_LACKS_TEMPNAM)) + +AC_CHECK_FUNC(truncate, dnl + , + AC_DEFINE(ACE_LACKS_TRUNCATE)) + +dnl Check for MIT pthreads APIs for timed send/recv operations +AC_CHECK_FUNC(recv_timedwait, dnl + AC_DEFINE(ACE_HAS_RECV_TIMEDWAIT),) + +AC_CHECK_FUNC(recvfrom_timedwait, dnl + AC_DEFINE(ACE_HAS_RECVFROM_TIMEDWAIT),) + +AC_CHECK_FUNC(recvmsg_timedwait, dnl + AC_DEFINE(ACE_HAS_RECVMSG_TIMEDWAIT),) + +AC_CHECK_FUNC(send_timedwait, dnl + AC_DEFINE(ACE_HAS_SEND_TIMEDWAIT),) + +AC_CHECK_FUNC(sendto_timedwait, dnl + AC_DEFINE(ACE_HAS_SENDTO_TIMEDWAIT),) + +AC_CHECK_FUNC(sendmsg_timedwait, dnl + AC_DEFINE(ACE_HAS_SENDMSG_TIMEDWAIT),) + +AC_CHECK_FUNC(read_timedwait, dnl + AC_DEFINE(ACE_HAS_READ_TIMEDWAIT),) + +AC_CHECK_FUNC(readv_timedwait, dnl + AC_DEFINE(ACE_HAS_READV_TIMEDWAIT),) + +AC_CHECK_FUNC(write_timedwait, dnl + AC_DEFINE(ACE_HAS_WRITE_TIMEDWAIT),) + +AC_CHECK_FUNC(writev_timedwait, dnl + AC_DEFINE(ACE_HAS_WRITEV_TIMEDWAIT),) + +dnl Check for POSIX Semaphore functions +dnl We only check for a few of them since some platforms don't have these. +AC_CHECK_FUNC(sem_init,,) dnl +AC_CHECK_FUNC(sem_destroy,,) dnl +AC_CHECK_FUNC(sem_open,,) dnl +AC_CHECK_FUNC(sem_close,,) dnl + +dnl We only enable POSIX semaphores if we are not using UNIX International +dnl threads. Enabling POSIX semaphores on Solaris seems to cause problems +dnl for ACE, for example. +if test "$ac_cv_func_sem_init" = yes && + test "$ac_cv_func_sem_destroy" = yes && + test "$ace_cv_type_sem_t" = yes && + test "$ace_has_sthreads" != yes; then + AC_DEFINE(ACE_HAS_POSIX_SEM) + + if test "$ac_cv_func_sem_open" != yes || + test "$ac_cv_func_sem_close" != yes; then + AC_DEFINE(ACE_LACKS_NAMED_POSIX_SEM) + fi +fi dnl check for POSIX Semaphore functions + +dnl +dnl The following tests are performed only when the user has enabled +dnl support for threads. + +dnl NOTE: Make sure the thread library is in "LIBS" +dnl (e.g.: LIBS="$LIBS -lpthread") +dnl otherwise the below thread "CHECK_FUNCs" +dnl will not work correctly. +if test "$ace_user_enable_threads" = yes; then + + if test "$ace_has_pthreads" = yes; then +dnl Digital UNIX 4.0 "mangles" the following pthread functions: +dnl pthread_attr_getguardsize_np +dnl pthread_attr_getinheritsched +dnl pthread_attr_getstacksize +dnl pthread_attr_setguardsize_np +dnl pthread_attr_setinheritsched +dnl pthread_attr_setstacksize +dnl pthread_cancel +dnl pthread_cond_broadcast +dnl pthread_cond_destroy +dnl pthread_cond_init +dnl pthread_cond_sig_preempt_int_np +dnl pthread_cond_signal +dnl pthread_cond_signal_int_np +dnl pthread_cond_timedwait +dnl pthread_cond_wait +dnl pthread_create +dnl pthread_delay_np +dnl pthread_detach +dnl pthread_equal +dnl pthread_exit +dnl pthread_get_expiration_np +dnl pthread_getspecific +dnl pthread_join +dnl pthread_lock_global_np +dnl pthread_mutex_destroy +dnl pthread_mutex_init +dnl pthread_mutex_lock +dnl pthread_mutex_trylock +dnl pthread_mutex_unlock +dnl pthread_once +dnl pthread_self +dnl pthread_setspecific +dnl pthread_testcancel +dnl pthread_unlock_global_np +dnl These functions have a double underscore "__" prepended to maintain +dnl backwards compatibility with Pthread Draft 4 functions of the same +dnl name. + + AC_CHECK_FUNC(pthread_sigmask, dnl + AC_DEFINE(ACE_HAS_PTHREAD_SIGMASK),) + + AC_CHECK_FUNC(pthread_key_create, dnl + AC_DEFINE(ACE_HAS_THREAD_SPECIFIC_STORAGE), + AC_DEFINE(ACE_HAS_TSS_EMULATION)) + + AC_CHECK_FUNC(pthread_condattr_setpshared, dnl + , + AC_DEFINE(ACE_LACKS_CONDATTR_PSHARED)) + + AC_CHECK_FUNC(pthread_attr_setstackaddr, dnl + , + AC_DEFINE(ACE_LACKS_THREAD_STACK_ADDR)) + + ACE_CHECK_FUNC(pthread_attr_setstacksize, pthread.h, dnl + , + AC_DEFINE(ACE_LACKS_THREAD_STACK_SIZE)) + + ACE_CHECK_FUNC(pthread_cancel, pthread.h, dnl + , + AC_DEFINE(ACE_LACKS_PTHREAD_CANCEL)) + + AC_CHECK_FUNC(pthread_yield, dnl + , + AC_DEFINE(ACE_LACKS_PTHREAD_YIELD)) + + AC_CHECK_FUNC(pthread_thr_sigsetmask, dnl + , + AC_DEFINE(ACE_LACKS_PTHREAD_THR_SIGSETMASK)) + + AC_CHECK_FUNC(pthread_attr_setdetachstate, dnl + , + AC_DEFINE(ACE_LACKS_SETDETACH)) + + AC_CHECK_FUNC(pthread_attr_setsched,, dnl + AC_CHECK_FUNC(pthread_attr_setschedpolicy,, + AC_DEFINE(ACE_LACKS_SETSCHED))) + + AC_CHECK_FUNC(pthread_attr_setscope, dnl + , + AC_DEFINE(ACE_LACKS_THREAD_PROCESS_SCOPING)) + + AC_CHECK_FUNC(pthread_mutexattr_setpshared, dnl + , + AC_DEFINE(ACE_LACKS_MUTEXATTR_PSHARED)) + +dnl Check for POSIX Threads Draft 4 functions + AC_CHECK_FUNC(pthread_mutexattr_create,,) dnl + AC_CHECK_FUNC(pthread_mutexattr_delete,,) dnl + AC_CHECK_FUNC(pthread_condattr_delete,,) dnl + AC_CHECK_FUNC(pthread_condattr_create,,) dnl + AC_CHECK_FUNC(pthread_setprio,,) dnl + AC_CHECK_FUNC(pthread_getprio,,) dnl + AC_CHECK_FUNC(pthread_setcancel,,) dnl + AC_CHECK_FUNC(pthread_setasynccancel,,) dnl + AC_CHECK_FUNC(pthread_kill,,) dnl +dnl Check for POSIX Threads Draft 6 functions + AC_CHECK_FUNC(pthread_attr_setprio,,) dnl + AC_CHECK_FUNC(pthread_attr_getprio,,) dnl + AC_CHECK_FUNC(pthread_setintr,,) dnl + AC_CHECK_FUNC(pthread_setintrtype,,) dnl +dnl Check for POSIX threads Draft 6, 7 and Standard common functions + AC_CHECK_FUNC(pthread_mutexattr_init,,) dnl + AC_CHECK_FUNC(pthread_mutexattr_destroy,,) dnl + AC_CHECK_FUNC(pthread_condattr_init,,) dnl + AC_CHECK_FUNC(pthread_condattr_destroy,,) dnl +dnl Check for POSIX Threads Draft 7 and Draft Standard common functions + AC_CHECK_FUNC(pthread_setschedparam,,) dnl + AC_CHECK_FUNC(pthread_getschedparam,,) dnl + AC_CHECK_FUNC(pthread_setcancelstate,,) dnl + AC_CHECK_FUNC(pthread_setcanceltype,,) dnl +dnl Check for POSIX Threads Draft Standard functions +dnl sched_yield() is in the C library or perhaps in "-lposix4." +dnl We need to add other library checks in this script's "check libraries" +dnl section if it is in another library. +dnl AC_CHECK_FUNC(sched_yield,,) dnl +dnl We already check for this during the library checks + +dnl Check if platform has thread_self() rather than pthread_self() + ACE_CHECK_FUNC(pthread_self, pthread.h, dnl + , + [ + AC_CHECK_FUNC(thread_self, + [ + AC_DEFINE(ACE_HAS_THREAD_SELF) + ],) + ]) + + +dnl FIXME: These tests look sloppy to me. -Ossama + AC_CACHE_CHECK(if platform defines a minimum thread priority, + ace_cv_lib_pthread_pthread_min_priority,[ + ace_cv_lib_pthread_pthread_min_priority=0 + AC_EGREP_HEADER(PTHREAD_MIN_PRIORITY, pthread.h, + ace_cv_lib_pthread_pthread_min_priority=PTHREAD_MIN_PRIORITY) + AC_EGREP_HEADER(PX_PRIO_MIN, pthread.h, + ace_cv_lib_pthread_pthread_min_priority=PX_PRIO_MIN) + ]) + AC_DEFINE_UNQUOTED(ACE_THREAD_MIN_PRIORITY, + $ace_cv_lib_pthread_pthread_min_priority) + + AC_CACHE_CHECK(if platform defines a maximum thread priority, + ace_cv_lib_pthread_pthread_max_priority,[ + ace_cv_lib_pthread_pthread_max_priority=99 + case "$target" in + *linux*) + if test "$ac_cv_func_pthread_sigmask" = yes; then + ace_cv_lib_pthread_pthread_max_priority=99 + else + ace_cv_lib_pthread_pthread_max_priority=32 + fi + ;; + *) + esac + AC_EGREP_HEADER(PTHREAD_MAX_PRIORITY, pthread.h, + ace_cv_lib_pthread_pthread_max_priority=PTHREAD_MAX_PRIORITY) + AC_EGREP_HEADER(PX_PRIO_MAX, pthread.h, + ace_cv_lib_pthread_pthread_max_priority=PX_PRIO_MAX) + ]) + AC_DEFINE_UNQUOTED(ACE_THREAD_MAX_PRIORITY, + $ace_cv_lib_pthread_pthread_max_priority) + + fi dnl test "$ace_has_pthreads" = yes + + if test "$ace_has_sthreads" = yes; then +dnl Only check for these functions if we have the UNIX International +dnl Threads library "thread." + AC_CHECK_FUNC(thr_keycreate, dnl + AC_DEFINE(ACE_HAS_THREAD_SPECIFIC_STORAGE), + AC_DEFINE(ACE_HAS_TSS_EMULATION)) + + AC_CHECK_FUNC(thr_yield, dnl + AC_DEFINE(ACE_HAS_THR_YIELD),) + + AC_CHECK_FUNC(thr_keydelete, dnl + AC_DEFINE(ACE_HAS_THR_KEYDELETE),) + + AC_CHECK_FUNC(thr_min_stack, dnl + , + [ + AC_CHECK_FUNC(thr_minstack, + AC_DEFINE(ACE_HAS_THR_MINSTACK),) + ]) + + fi dnl test "$ace_has_sthreads" = yes + +fi dnl test "$ace_user_enable_threads" = yes + +dnl +dnl By Eric: +dnl ACE will define a sigwait function if we lie and say we don't have +dnl one. Unfortunately, the ACE function may conflict with our +dnl function, so we'll go ahead and turn this on, even if we are +dnl ignoring threads. +dnl + +AC_CHECK_FUNC(sigwait, dnl + AC_DEFINE(ACE_HAS_SIGWAIT),) + + +dnl Check for reentrant functions +if test "$ace_user_enable_reentrant_funcs" = yes; then + AC_CHECK_FUNC(rand_r,,) + + AC_CHECK_FUNC(strtok_r,,) + + AC_CHECK_FUNC(getpwnam_r,, AC_DEFINE(ACE_LACKS_PWD_REENTRANT_FUNCTIONS)) + + AC_CHECK_FUNC(ctime_r,,) + + AC_CHECK_FUNC(localtime_r,,) + + AC_CHECK_FUNC(gmtime_r,,) + + AC_CHECK_FUNC(asctime_r,,) + + AC_CHECK_FUNC(getprotobyname_r,,) + + AC_CHECK_FUNC(getprotobynumber_r,,) + + AC_CHECK_FUNC(gethostbyaddr_r,,) + + AC_CHECK_FUNC(gethostbyname_r,,) + + AC_CHECK_FUNC(getservbyname_r,,) +fi dnl End checks for reentrant functions + +AC_CHECK_FUNC(readdir_r, dnl + , + AC_DEFINE(ACE_LACKS_READDIR_R)) + +AC_CHECK_FUNC(seekdir, dnl + , + AC_DEFINE(ACE_LACKS_SEEKDIR)) + +AC_CHECK_FUNC(telldir, dnl + , + AC_DEFINE(ACE_LACKS_TELLDIR)) + + +dnl +dnl SECTION 11: checks for function characteristics +dnl + +ACE_CONVERT_WARNINGS_TO_ERRORS([ +dnl Check if dlopen takes a char * arg instead of const char * + if test "$ace_has_svr4_dynamic_linking" = yes; then + ACE_CACHE_CHECK(if dlopen takes a char *, + ace_cv_lib_charptr_dl, + [ + dnl Check if it takes a const char *, first. + AC_TRY_COMPILE( + [ +#include <dlfcn.h> + ], + [ + const char *filename = 0; + int flag = 0; + void *ptr = dlopen(filename, flag); + ], + [ + ace_cv_lib_charptr_dl=no + ], + [ + dnl Now check if it takes a non-const char *. + AC_TRY_COMPILE( + [ +#include <dlfcn.h> + ], + [ + char *filename = 0; + int flag = 0; + void *ptr = dlopen(filename, flag); + ], + [ + ace_cv_lib_charptr_dl=yes + ], + [ + ace_cv_lib_charptr_dl=no + ]) + ]) + ], AC_DEFINE(ACE_HAS_CHARPTR_DL),) + fi dnl test "$ace_has_svr4_dynamic_linking" = yes +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +ACE_CONVERT_WARNINGS_TO_ERRORS([ +dnl Check if "getby" functions use a non-const char * argument + if test "$ac_cv_func_gethostbyaddr" = yes; then + ACE_CACHE_CHECK(\"getby\" functions take a non-const char *, + ace_cv_lib_nonconst_getby, + [ + AC_TRY_COMPILE( + [ +#include <sys/socket.h> + ], + [ + char *addr = 0; + int len = 0; + int type = 0; + struct hostent *mystruct = 0; + + mystruct = gethostbyaddr(name, len, type); + ], + [ + ace_cv_lib_nonconst_getby=yes + ], + [ + ace_cv_lib_nonconst_getby=no + ]) + ], AC_DEFINE(ACE_HAS_NONCONST_GETBY),) + fi dnl test "$ac_cv_func_gethostbyaddr" = yes +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if new throws exception upon failure +if test "$ace_user_enable_exceptions" = yes; then + ACE_CACHE_CHECK(if new throws bad_alloc exception on failure, + ace_cv_new_throws_bad_alloc_exception, + [ + AC_TRY_RUN( + [ +#if defined (ACE_HAS_NEW_NO_H) +# include <new> +#elif defined (ACE_HAS_NEW_H) +# include <new.h> +#endif + +#if defined (ACE_HAS_STDEXCEPT_NO_H) +# include <stdexcept> +#elif defined (ACE_HAS_EXCEPTION_H) +# include <exception.h> +#endif + + int main() { + while (1) { + try { + char *a = new char[1024*1024]; + if (a == 0) { + return 1; /* new() does NOT throw exceptions */ + } + } + + catch (bad_alloc) + { + return 0; /* new() does throw exceptions */ + } + }; + + return 1; /* ERROR: We shouldn't get this far! */ + } + ], + [ + ace_cv_new_throws_bad_alloc_exception=yes + ], + [ + ace_cv_new_throws_bad_alloc_exception=no + ], + [ + ace_cv_new_throws_bad_alloc_exception=no + ]) + ], AC_DEFINE(ACE_NEW_THROWS_EXCEPTIONS),) + + if test "$ace_cv_new_throws_bad_alloc_exception" != yes; then + ACE_CACHE_CHECK(if new throws xalloc exception on failure, + ace_cv_new_throws_xalloc_exception, + [ + AC_TRY_RUN( + [ +#if defined (ACE_HAS_NEW_NO_H) +# include <new> +#elif defined (ACE_HAS_NEW_H) +# include <new.h> +#endif + +#if defined (ACE_HAS_STDEXCEPT_NO_H) +# include <stdexcept> +#elif defined (ACE_HAS_EXCEPTION_H) +# include <exception.h> +#endif + + int main() { + while (1) { + try { + char *a = new char[1024*1024]; + if (a == 0) { + return 1; /* new() does NOT throw exceptions */ + } + } + + catch (xalloc) + { + return 0; /* new() does throw exceptions */ + } + }; + + return 1; /* ERROR: We shouldn't get this far! */ + } + ], + [ + ace_cv_new_throws_xalloc_exception=yes + ], + [ + ace_cv_new_throws_xalloc_exception=no + ], + [ + ace_cv_new_throws_xalloc_exception=no + ]) + ], AC_DEFINE(ACE_NEW_THROWS_EXCEPTIONS),) + fi dnl ace_cv_new_throws_bad_alloc_exceptions = no +fi dnl $ace_user_enable_exceptions = yes + +ACE_CONVERT_WARNINGS_TO_ERRORS([ +dnl Check if putmsg takes a const struct strbuf * +dnl If we have getmsg() we can be pretty sure that we have putmsg() + if test "$ac_cv_func_getmsg" = yes || + test "$ac_cv_header_stropts_h" = yes; then + ACE_CACHE_CHECK(if putmsg takes a const struct strbuf*, + ace_cv_lib_const_strbufptr, + [ + dnl Check if it takes a const struct strbuf *, first. + AC_TRY_COMPILE( + [ +#include <stropts.h> + ], + [ + int result = 0; + int fd = 0; + const struct strbuf * ace_str = 0; + int flags = 0; + + result = putmsg(fd, ace_str, ace_str, flags); + ], + [ + ace_cv_lib_const_strbufptr=yes + ], + [ + ace_cv_lib_const_strbufptr=no + ]) + ],, AC_DEFINE(ACE_LACKS_CONST_STRBUF_PTR)) + fi dnl "$ac_cv_func_getmsg" = yes || "$ac_cv_header_stropts_h" = yes +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if select takes int instead of fd_set +ACE_CONVERT_WARNINGS_TO_ERRORS([ + ACE_CACHE_CHECK(if select takes int instead of fd_set, + ace_cv_lib_select_takes_int, + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/time.h> +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif +#ifdef ACE_HAS_SELECT_H +# include <sys/select.h> +#endif + ], + [ + int n; + fd_set* readfds = 0; + fd_set* writefds = 0; + fd_set* exceptfds = 0; + timeval* timeout = 0; + int result = 0; + + result = select(n, readfds, writefds, exceptfds, timeout); + ], + [ + ace_cv_lib_select_takes_int=no + ], + [ +dnl Now check if select will actually take int* arguments + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/time.h> +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif +#ifdef ACE_HAS_SELECT_H +# include <sys/select.h> +#endif + ], + [ + int n; + int* readfds = 0; + int* writefds = 0; + int* exceptfds = 0; + timeval* timeout = 0; + int result = 0; + + result = select(n, readfds, writefds, exceptfds, timeout); + ], + [ + ace_cv_lib_select_takes_int=yes + ], + [ + ace_cv_lib_select_takes_int=no + dnl If we get here we don't know what select() takes. + ]) + ]) + ], AC_DEFINE(ACE_SELECT_USES_INT),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + + +dnl Check if setrlimit() takes an enum as 1st parameter (a) +AC_CACHE_CHECK(if setrlimit() takes an enum as 1st parameter (a), + ace_cv_lib_posix_setrlimit_enum_1_a,[ + ace_cv_lib_posix_setrlimit_enum_1_a=no + AC_TRY_COMPILE([#include <sys/resource.h>], + [enum __rlimit_resource rsrc; + const struct rlimit* rlp; + setrlimit(rsrc, rlp);], + ace_cv_lib_posix_setrlimit_enum_1_a=yes) + ]) + +dnl Check if setrlimit() takes an enum as 1st parameter (b) +AC_CACHE_CHECK(if setrlimit() takes an enum as 1st parameter (b), + ace_cv_lib_posix_setrlimit_enum_1_b,[ + ace_cv_lib_posix_setrlimit_enum_1_b=no + AC_TRY_COMPILE([#include <sys/resource.h>], + [enum __rlimit_resource rsrc; + struct rlimit* rlp; + setrlimit(rsrc, rlp);], + ace_cv_lib_posix_setrlimit_enum_1_b=yes) + ]) + +if test "$ace_cv_lib_posix_setrlimit_enum_1_a" = yes || + test "$ace_cv_lib_posix_setrlimit_enum_1_b" = yes; then + AC_DEFINE(ACE_HAS_RLIMIT_RESOURCE_ENUM, enum __rlimit_resource) +fi + +dnl These two tests fail (i.e. pass when they shouldn't) when compiling with +dnl GCC/G++ since the compiler treats passing a const to a non-const argument +dnl as a warning and not as an error since the const is simply discarded. +dnl To correct this problem, we use "-Werror" which converts all warnings +dnl to errors, whenever we are compiling with G++. +dnl -Ossama + +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if setrlimit() takes a const pointer as 2nd parameter (a) +AC_CACHE_CHECK(if setrlimit() takes a const pointer as 2nd parameter (a), + ace_cv_lib_posix_setrlimit_const_2_a,[ + AC_TRY_COMPILE( + [ +#include <sys/resource.h> + ], + [ + int rsrc; + const struct rlimit* rlp; + setrlimit(rsrc, rlp); + ], + [ + ace_cv_lib_posix_setrlimit_const_2_a=yes + ], + [ + ace_cv_lib_posix_setrlimit_const_2_a=no + ]) + ]) + +dnl Check if setrlimit() takes a const pointer as 2nd parameter (b) +AC_CACHE_CHECK(if setrlimit() takes a const pointer as 2nd parameter (b), + ace_cv_lib_posix_setrlimit_const_2_b,[ + ace_cv_lib_posix_setrlimit_const_2_b=no + AC_TRY_COMPILE([#include <sys/resource.h>], + [enum __rlimit_resource rsrc; + const struct rlimit* rlp; + setrlimit(rsrc, rlp);], + ace_cv_lib_posix_setrlimit_const_2_b=yes) + ]) + +if test "$ace_cv_lib_posix_setrlimit_const_2_a" != yes && + test "$ace_cv_lib_posix_setrlimit_const_2_b" != yes; then + AC_DEFINE(ACE_HAS_BROKEN_SETRLIMIT) +fi +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if getrusage() takes an enum as 1st parameter +if test "$ac_cv_func_getrusage" = yes; then + ACE_CACHE_CHECK(if getrusage() takes an enum as 1st parameter, + ace_cv_lib_posix_getrusage_enum_1,[ + AC_TRY_COMPILE( + [ +#include <sys/resource.h> + ], + [ + enum __rusage_who who; + struct rusage* rup; + getrusage(who, rup); + ], + [ + ace_cv_lib_posix_getrusage_enum_1=yes + ], + [ + ace_cv_lib_posix_getrusage_enum_1=no + ]) + ], AC_DEFINE(ACE_HAS_RUSAGE_WHO_ENUM, enum __rusage_who),) +fi + +dnl TODO: This doesn't work. +dnl The compiler in linux just issues a warning, and the test passes!!! +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if select takes a const fifth parameter +ACE_CACHE_CHECK(if select takes a const fifth parameter, + ace_cv_lib_posix_select_const_5,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/time.h> +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif +#ifdef ACE_HAS_SELECT_H +# include <sys/select.h> +#endif + ], + [ + int n; + fd_set *readfds; + fd_set *writefds; + fd_set *exceptfds; + const struct timeval* timeout = 0; + select(n, readfds, writefds, exceptfds, timeout); + ], + [ + ace_cv_lib_posix_select_const_5=yes + ], + [ + ace_cv_lib_posix_select_const_5=no + ]) + ], , AC_DEFINE(ACE_HAS_NONCONST_SELECT_TIMEVAL)) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Only run the following tests if the msghdr structure exists. +if test "$ace_cv_struct_msghdr" = yes && + test "$ac_cv_func_sendmsg" = yes; then + ACE_CONVERT_WARNINGS_TO_ERRORS( dnl + [ +dnl Check if sendmsg takes a const 2nd parameter + ACE_CACHE_CHECK(if sendmsg omits the const from the second parameter, + ace_cv_lib_broken_sendmsg,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + int s = 0; + const struct msghdr *msg = 0; + unsigned int flags = 0; + + int result = 0; + + result = (int) sendmsg(s, msg, flags); + ], + [ + ace_cv_lib_broken_sendmsg=no + ], + [ + ace_cv_lib_broken_sendmsg=yes + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_SENDMSG),) + ]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS +fi dnl test "$ace_cv_struct_msghdr" = yes + +dnl Only run the following tests if the writev function exists +if test "$ac_cv_header_sys_uio_h" = yes && + test "$ac_cv_func_writev" = yes; then + ACE_CONVERT_WARNINGS_TO_ERRORS( dnl + [ +dnl Check if writev omits the const from the iovec parameter + ACE_CACHE_CHECK(if writev omits the const from the iovec parameter, + ace_cv_lib_broken_writev,[ + AC_TRY_COMPILE( + [ +#ifdef ACE_HAS_UNISTD_H +# include <unistd.h> +#endif + +#include <sys/uio.h> + ], + [ + int filedes = 0; + const struct iovec *vector = 0; + size_t count = 0; + + int result = 0; + + result = (int) writev(filedes, vector, count); + ], + [ + ace_cv_lib_broken_writev=no + ], + [ + ace_cv_lib_broken_writev=yes + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_WRITEV),) + ]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS +fi dnl $ac_cv_header_sys_uio_h = yes && $ac_cv_func_writev = yes + + +dnl The compiler in linux just issues a warning, and the test passes!!! +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if socket size is denoted by size_t +ACE_CACHE_CHECK(if socket size is denoted by size_t, + ace_cv_lib_posix_socket_len_size_t,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + int s; + struct sockaddr* addr; + int* addrlen; + accept(s, addr, addrlen); + ], + [ + ace_cv_lib_posix_socket_len_size_t=no + ], + [ +dnl Now see if it really does take a size_t socket size + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + int s; + struct sockaddr* addr; + size_t* addrlen; + accept(s, addr, addrlen); + ], + [ + ace_cv_lib_posix_socket_len_size_t=yes + ], + [ + ace_cv_lib_posix_socket_len_size_t=no + ]) + ]) + ], AC_DEFINE(ACE_HAS_SIZET_SOCKET_LEN),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +ACE_CACHE_CHECK(for (struct sockaddr *) msg_name field, + ace_cv_lib_sockaddr_msg_name,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + msghdr ace_msghdr; + sockaddr name; + + ace_msghdr.msg_name = (struct sockaddr *)name; + ], + [ + ace_cv_lib_sockaddr_msg_name=yes + ], + [ + ace_cv_lib_sockaddr_msg_name=no + ]) + ], AC_DEFINE(ACE_HAS_SOCKADDR_MSG_NAME),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + + +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +ACE_CACHE_CHECK(if setsockopt() takes a char* fourth parameter, + ace_cv_lib_posix_setsockopt_charp_4,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + int s; + int level; + int optname; + char* optval; +#if defined(ACE_HAS_SIZET_SOCKET_LEN) + size_t* optlen; +#else + int* optlen; +#endif + setsockopt(s, level, optname, optval, optlen); + ], + [ + ace_cv_lib_posix_setsockopt_charp_4=yes + ], + [ + ace_cv_lib_posix_setsockopt_charp_4=no + ]) + ], AC_DEFINE(ACE_HAS_CHARPTR_SOCKOPT),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +ACE_CACHE_CHECK(if setsockopt() takes a void* fourth parameter, + ace_cv_lib_posix_setsockopt_voidp_4,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + int s; + int level; + int optname; + void* optval; +#if defined(ACE_HAS_SIZET_SOCKET_LEN) + size_t* optlen; +#else + int* optlen; +#endif + setsockopt(s, level, optname, optval, optlen); + ], + [ + ace_cv_lib_posix_setsockopt_voidp_4=yes + ], + [ + ace_cv_lib_posix_setsockopt_voidp_4=no + ]) + ], AC_DEFINE(ACE_HAS_VOIDPTR_SOCKOPT),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +ACE_CACHE_CHECK(if mmap() takes a void* first argument, + ace_cv_lib_posix_voidptr_mmap,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif +#include <sys/mman.h> + ], + [ + void *start; + size_t length; + int prot; + int flags; + int fd; + off_t offset; + + void *result = 0; + + result = (void *)mmap(start, length, prot, flags, fd, offset); + ], + [ + ace_cv_lib_posix_voidptr_mmap=yes + ], + [ + ace_cv_lib_posix_voidptr_mmap=no + ]) + ], AC_DEFINE(ACE_HAS_VOIDPTR_MMAP),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if msync is broken, i.e. doesn't accept third "sync" argument. +dnl This test should come after the test for checking if mmap takes a void* +dnl argument since we need the ACE_MMAP_TYPE type for this test. +if test "$ac_cv_func_msync" = yes; then +ACE_CACHE_CHECK(if msync accepts a third "sync" argument, + ace_cv_lib_broken_msync, + [ + AC_TRY_COMPILE( + [ +#include <sys/mman.h> + +#if defined (ACE_HAS_VOIDPTR_MMAP) + /* Needed for some odd OS's (e.g., SGI). */ + typedef void *ACE_MMAP_TYPE; +#else + typedef char *ACE_MMAP_TYPE; +#endif /* ACE_HAS_VOIDPTR_MMAP */ + ], + [ + ACE_MMAP_TYPE start = 0; + size_t length = 0; + int flags = MS_SYNC; + + int result; + + result = msync(start, length, flags); + ], + [ + ace_cv_lib_broken_msync=no + ], + [ + dnl Now see if it works with just two arguments + AC_TRY_COMPILE( + [ +#include <sys/mman.h> + +#if defined (ACE_HAS_VOIDPTR_MMAP) + /* Needed for some odd OS's (e.g., SGI). */ + typedef void *ACE_MMAP_TYPE; +#else + typedef char *ACE_MMAP_TYPE; +#endif /* ACE_HAS_VOIDPTR_MMAP */ + ], + [ + ACE_MMAP_TYPE start = 0; + size_t length = 0; + + int result; + + result = msync(start, length); + ], + [ + ace_cv_lib_broken_msync=yes + ], + [ + dnl If we get to this point then we don't know if msync is + dnl is broken or not. + ace_cv_lib_broken_msync=no + ]) + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_NETBSD_MSYNC),) +fi dnl test "$ac_cv_func_msync" = yes + +dnl Check if platform has iostream method ipfx() +ACE_CACHE_CHECK(if platform has iostream method ipfx(), + ace_cv_feature_has_iostream_ipfx,[ + AC_TRY_COMPILE( + [ +#include <iostream.h> + ], + [ + cin.ipfx(); + ], + [ + ace_cv_feature_has_iostream_ipfx=yes + ], + [ + ace_cv_feature_has_iostream_ipfx=no + ]) + ], , AC_DEFINE(ACE_LACKS_IOSTREAM_FX)) + +dnl Check if platform has line-buffered streambufs +ACE_CACHE_CHECK(if platform has line-buffered streambufs, + ace_cv_feature_has_linebuffered_streambuf,[ + AC_TRY_COMPILE( + [ +#include <iostream.h> + ], + [ + cin.rdbuf()->linebuffered(1); + ], + [ + ace_cv_feature_has_linebuffered_streambuf=yes + ], + [ + ace_cv_feature_has_linebuffered_streambuf=no + ]) + ], , AC_DEFINE(ACE_LACKS_LINEBUFFERED_STREAMBUF)) + +dnl Check if platform has unbuffered streambufs +ACE_CACHE_CHECK(if platform has unbuffered streambufs, + ace_cv_feature_has_unbuffered_streambuf,[ + A_TRY_COMPILE( + [ +#include <iostream.h> + ], + [ + cin.rdbuf()->unbuffered(1); + ], + [ + ace_cv_feature_has_unbuffered_streambuf=yes + ], + [ + ace_cv_feature_has_unbuffered_streambuf=no + ]) + ], , AC_DEFINE(ACE_LACKS_UNBUFFERED_STREAMBUF)) + +dnl Check if signal takes a void (*)(int) as second parameter +AC_CACHE_CHECK(if signal takes a void (*)(int) as second parameter, + ace_cv_lib_signal_vi1_2,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int); + void handler(int) + { + } + ], + [ + SA nn = handler; + signal(SIGINT, nn); + ], + [ + ace_cv_lib_signal_vi1_2=yes + ], + [ + ace_cv_lib_signal_vi1_2=no + ]) + ]) + +dnl Check if signal takes a void (*)(void) as second parameter +AC_CACHE_CHECK(if signal takes a void (*)(void) as second parameter, + ace_cv_lib_signal_vv1_2,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(void); + void handler(int) { } + ], + [ + SA nn = handler; + signal(SIGINT, nn); + ], + [ + ace_cv_lib_signal_vv1_2=yes + ], + [ + ace_cv_lib_signal_vv1_2=no + ]) + ]) + +dnl Check if signal takes a void (*)(int, ...) as second parameter +AC_CACHE_CHECK(if signal takes a void (*)(int, ...) as second parameter, + ace_cv_lib_signal_vi1a2_2,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int, ...); + void handler(int, ...) { } + ], + [ + SA nn = handler; + signal(SIGINT, nn); + ], + [ + ace_cv_lib_signal_vi1a2_2=yes + ], + [ + ace_cv_lib_signal_vi1a2_2=no + ]) + ]) + +dnl Check if signal takes a void (*)(...) as second parameter +AC_CACHE_CHECK(if signal takes a void (*)(...) as second parameter, + ace_cv_lib_signal_va1_2,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(...); + void handler(...) { } + ], + [ + SA nn = handler; + signal(SIGINT, nn); + ], + [ + ace_cv_lib_signal_va1_2=yes + ], + [ + ace_cv_lib_signal_va1_2=no + ]) + ]) + +dnl Check if signal returns a void (*)(int) +AC_CACHE_CHECK(if signal returns a void (*)(int), + ace_cv_lib_signal_vi1_ret,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int); + void foo(SA nn) { } + ], + [ + SA nn = SIG_DFL; + nn = signal(SIGINT, 0); + foo(nn); + ], + [ + ace_cv_lib_signal_vi1_ret=yes + ], + [ + ace_cv_lib_signal_vi1_ret=no + ]) + ]) + +dnl Check if signal returns a void (*)(void) +AC_CACHE_CHECK(if signal returns a void (*)(void), + ace_cv_lib_signal_vv1_ret,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(void); + void foo(SA nn) { } + ], + [ + SA nn = SIG_DFL; + nn = signal(SIGINT, 0); + foo(nn); + ], + [ + ace_cv_lib_signal_vv1_ret=yes + ], + [ + ace_cv_lib_signal_vv1_ret=no + ]) + ]) + +dnl Check if signal returns a void (*)(int, ...) +AC_CACHE_CHECK(if signal returns a void (*)(int, ...), + ace_cv_lib_signal_vi1a2_ret,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int, ...); + ], + [ + SA oo = signal(SIGINT, 0); + ], + [ + ace_cv_lib_signal_vi1a2_ret=yes + ], + [ + ace_cv_lib_signal_vi1a2_ret=no + ]) + ]) + +dnl Check if signal returns a void (*)(...) +AC_CACHE_CHECK(if signal returns a void (*)(...), + ace_cv_lib_signal_va1_ret,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(...); + ], + [ + SA oo = signal(SIGINT, 0); + ], + [ + ace_cv_lib_signal_va1_ret=yes + ], + [ + ace_cv_lib_signal_va1_ret=no + ]) + ]) + +if test "$ace_cv_struct_sigaction" = yes; then +dnl Check if struct sigaction takes a void (*)(int) handler + AC_CACHE_CHECK(if struct sigaction takes a void (*)(int) handler, + ace_cv_lib_struct_sigaction_vi1_handler,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int); + void foo(struct sigaction* sa, SA nn) { } + ], + [ + struct sigaction sa; + SA nn = SIG_DFL; + sa.sa_handler = nn; + foo(&sa, nn); + ], + [ + ace_cv_lib_struct_sigaction_vi1_handler=yes + ], + [ + ace_cv_lib_struct_sigaction_vi1_handler=no + ]) + ]) + +dnl Check if struct sigaction takes a void (*)(void) handler + AC_CACHE_CHECK(if struct sigaction takes a void (*)(void) handler, + ace_cv_lib_struct_sigaction_vv1_handler,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(void); + void foo(struct sigaction* sa, SA nn) { } + ], + [ + struct sigaction sa; + SA nn = SIG_DFL; + sa.sa_handler = nn; + foo(&sa, nn); + ], + [ + ace_cv_lib_struct_sigaction_vv1_handler=yes + ], + [ + ace_cv_lib_struct_sigaction_vv1_handler=no + ]) + ]) + +dnl Check if struct sigaction takes a void (*)(int, ...) handler + AC_CACHE_CHECK(if struct sigaction takes a void (*)(int, ...) handler, + ace_cv_lib_struct_sigaction_vi1a2_handler,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(int, ...); + void foo(struct sigaction* sa, SA nn) { } + ], + [ + struct sigaction sa; + SA nn = SIG_DFL; + sa.sa_handler = nn; + foo(&sa, nn); + ], + [ + ace_cv_lib_struct_sigaction_vi1a2_handler=yes + ], + [ + ace_cv_lib_struct_sigaction_vi1a2_handler=no + ]) + ]) + +dnl Check if struct sigaction takes a void (*)(...) handler + AC_CACHE_CHECK(if struct sigaction takes a void (*)(...) handler, + ace_cv_lib_struct_sigaction_va1_handler,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + typedef void (*SA)(...); + void foo(struct sigaction* sa, SA nn) { } + ], + [ + struct sigaction sa; + SA nn = SIG_DFL; + sa.sa_handler = nn; + foo(&sa, nn); + ], + [ + ace_cv_lib_struct_sigaction_va1_handler=yes + ], + [ + ace_cv_lib_struct_sigaction_va1_handler=no + ]) + ]) +fi dnl test "$ace_cv_struct_sigaction" = yes + +dnl TODO: This doesn't work. +dnl The linux compiler issues a warning regarding the invalid void* +dnl conversion. +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if msgsnd() takes a struct msgbuf* second parameter +ACE_CACHE_CHECK(if msgsnd() takes a struct msgbuf* second parameter, + ace_cv_lib_posix_msgsnd_msgbufp_2,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +# include <sys/ipc.h> +#ifndef ACE_LACKS_SYSV_MSG_H +# include <sys/msg.h> +#endif + ], + [ + int msqid; + struct msgbuf* msgp = 0; + int msgsz; + int msgflg; + msgsnd(msqid, msgp, msgsz, msgflg); + ], + [ + ace_cv_lib_posix_msgsnd_msgbufp_2=yes + ], + [ + ace_cv_lib_posix_msgsnd_msgbufp_2=no + ]) + ], + [ + dnl "ACTIONS-IF-SUCCESSFUL" handled later in configure.in + ], + [ + dnl Check if msgsnd() takes a const void* second parameter + ACE_CACHE_CHECK(if msgsnd() takes a const void* second parameter, + ace_cv_lib_posix_msgsnd_cvoidp_2,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +# include <sys/ipc.h> +#ifndef ACE_LACKS_SYSV_MSG_H +# include <sys/msg.h> +#endif + ], + [ + int msqid; + const void* msgp = 0; + int msgsz; + int msgflg; + msgsnd(msqid, msgp, msgsz, msgflg); + ], + [ + ace_cv_lib_posix_msgsnd_cvoidp_2=yes + ], + [ + ace_cv_lib_posix_msgsnd_cvoidp_2=no + ]) + ], + [ + dnl Do nothing if msgsnd takes a const void* second parameter + ], + [ + dnl If we get this far we presumably have a non-const void* second param + AC_DEFINE(ACE_HAS_NONCONST_MSGSND) + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl TODO: This doesn't work. +dnl The linux compiler issues a warning regarding the invalid void* +dnl conversion. +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if msgrcv() takes a void* second parameter +AC_CACHE_CHECK(if msgrcv() takes a void* second parameter, + ace_cv_lib_posix_msgrcv_voidp_2,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +# include <sys/ipc.h> +#ifndef ACE_LACKS_SYSV_MSG_H +# include <sys/msg.h> +#endif + ], + [ + int msqid; + void* msgp; + int msgsz; + long msgtyp; + int msgflg; + msgrcv(msqid, msgp, msgsz, msgtyp, msgflg); + ], + [ + ace_cv_lib_posix_msgrcv_voidp_2=yes + ], + [ + ace_cv_lib_posix_msgrcv_voidp_2=no + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl TODO: This doesn't work. +dnl The linux compiler issues a warning regarding the invalid void* +dnl conversion. +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if shmat() takes a void* second parameter +AC_CACHE_CHECK(if shmat() takes a void* second parameter, + ace_cv_lib_posix_shmat_voidp_2,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +# include <sys/ipc.h> +# include <sys/shm.h> + ], + [int shmid; + void* shmaddr; + int shmflg; + shmat(shmid, shmaddr, shmflg); + ], + [ + ace_cv_lib_posix_shmat_voidp_2=yes + ], + [ + ace_cv_lib_posix_shmat_voidp_2=no + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl TODO: This doesn't work. +dnl The linux compiler issues a warning regarding the invalid void* +dnl conversion. +dnl +dnl FIXED by adding "-Werror" to compiler flags when using GNU C++ +dnl -Ossama +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check if sigaction() takes a const* second parameter +AC_CACHE_CHECK(if sigaction() takes a const* second parameter, + ace_cv_lib_posix_sigaction_constp_2,[ + AC_TRY_COMPILE( + [ +#include <signal.h> + ], + [ + int signum; + const struct sigaction* act = 0; + struct sigaction* oldact; + sigaction(signum, act, oldact); + ], + [ + ace_cv_lib_posix_sigaction_constp_2=yes + ], + [ + ace_cv_lib_posix_sigaction_constp_2=no + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if the wait() system call takes a (union wait *) rather than int * +ACE_CACHE_CHECK(if wait() takes a (union wait *) rather than int *, + ace_cv_lib_wait_takes_union_wait_ptr, + [ + AC_TRY_COMPILE( + [ +#include <sys/wait.h> + ], + [ + int* status; + int result; + result=wait(status); + ], + [ + ace_cv_lib_wait_takes_union_wait_ptr=no + ], + [ + AC_TRY_COMPILE( + [ +#include <sys/wait.h> + ], + [ + union wait* status; + int result; + result=wait(status); + ], + [ + ace_cv_lib_wait_takes_union_wait_ptr=yes + ], + [ +dnl If we get here then we're screwed! We can't use int* or union wait*. +dnl It is very unlikely that we will ever get this far. For the sake +dnl of setting some result, we'll assume that we can actually use int*. + ace_cv_lib_wait_takes_union_wait_ptr=no + AC_MSG_WARN(wait() doesn't seem to take either int* or union wait*) + AC_MSG_WARN(as an argument. Going to assume that int* will work.) + ]) + ]) + ], AC_DEFINE(ACE_HAS_UNION_WAIT),) + +dnl We need to use the ACE_CONVERT_WARNINGS_TO_ERRORS() macro since +dnl passing a void * just caused implicit conversion warnings when +dnl using GNU C++, for example. +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check for SVR4 style gettimeofday() +AC_CACHE_CHECK(if gettimeofday() takes a void * second argument, + ace_cv_lib_voidptr_gettimeofday, + [ + AC_TRY_COMPILE( + [ +#include <sys/time.h> +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif + ], + [ + struct timeval *tv = 0; + void *tzp = 0; + + gettimeofday(tv, tzp); + ], + [ + ace_cv_lib_voidptr_gettimeofday=yes + ], + [ + ace_cv_lib_voidptr_gettimeofday=no + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +if test "$ace_cv_lib_voidptr_gettimeofday" = no; then +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl Check for old OSF1 style gettimeofday() + AC_CACHE_CHECK(if gettimeofday() takes a timzeone * second argument, + ace_cv_lib_timezone_gettimeofday, + [ + AC_TRY_COMPILE( + [ +#include <sys/time.h> +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif + ], + [ + struct timeval *tv = 0; + struct timezone *tzp = 0; + + gettimeofday(tv, tzp); + ], + [ + ace_cv_lib_timezone_gettimeofday=yes + ], + [ + ace_cv_lib_timezone_gettimeofday=no + ]) + ]) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS +fi dnl test "$ace_cv_lib_voidptr_gettimeofday" = no + +dnl Check for gettimeofday() protoype +if test "$ace_cv_lib_voidptr_gettimeofday" = yes || + test "$ace_cv_lib_timezone_gettimeofday" = yes; then + ACE_CACHE_CHECK(for gettimeofday() protoype, + ace_cv_lib_has_gettimeofday_prototype, + [ + AC_EGREP_CPP(gettimeofday, + [ +#include <time.h> + +#ifdef ACE_LACKS_SYSTIME_H +# include <sys/time.h> +#endif + ], + [ +dnl We have a gettimeofday prototype + ace_cv_lib_has_gettimeofday_prototype=yes + ], + [ +dnl We don't have a gettimeofday prototype + ace_cv_lib_has_gettimeofday_prototype=no + ]) + ], + [ + if test "$ace_cv_lib_voidptr_gettimeofday" = yes; then + AC_DEFINE(ACE_HAS_SUNOS4_GETTIMEOFDAY) + else + AC_DEFINE(ACE_HAS_TIMEZONE_GETTIMEOFDAY) + fi + ], + [ + if test "$ace_cv_lib_voidptr_gettimeofday" = yes; then + AC_DEFINE(ACE_HAS_SVR4_GETTIMEOFDAY) + else + AC_DEFINE(ACE_HAS_OSF1_GETTIMEOFDAY) + fi + ]) +fi dnl Check for gettimeofday() protoype + + +dnl Check if ctime_r() takes two parameters +if test "$ac_cv_func_ctime_r" = yes; then + ACE_CACHE_CHECK(if ctime_r() takes two parameters, + ace_cv_lib_posix_ctime_r_2_params, + [ + AC_TRY_COMPILE( + [ +#ifndef _REENTRANT +# define _REENTRANT +#endif + +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + ], + [ + const time_t *t ; + char *buf; + ctime_r(t, buf); + ], + [ + ace_cv_lib_posix_ctime_r_2_params=yes + ], + [ + ace_cv_lib_posix_ctime_r_2_params=no + ]) + ], AC_DEFINE(ACE_HAS_2_PARAM_ASCTIME_R_AND_CTIME_R),) +fi dnl test "$ac_cv_func_ctime_r" = yes + + +dnl +dnl SECTION 12: checks for type characteristics +dnl + +dnl struct msghdr stuff +dnl Only run the following tests if the msghdr structure exists. +if test "$ace_cv_struct_msghdr" = yes; then + + ACE_CACHE_CHECK(if struct msghdr has a msg_accrights member, + ace_cv_lib_posix_struct_msghdr_has_msg_accrights,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + msghdr mh; + mh.msg_accrights = 0; + ], + [ + ace_cv_lib_posix_struct_msghdr_has_msg_accrights=yes + ], + [ + ace_cv_lib_posix_struct_msghdr_has_msg_accrights=no + ]) + ]) + + ACE_CACHE_CHECK(if struct msghdr has a msg_accrights_len member, + ace_cv_lib_posix_struct_msghdr_has_msg_accrights_len,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + ], + [ + msghdr mh; + mh.msg_accrightslen = 0; + ], + [ + ace_cv_lib_posix_struct_msghdr_has_msg_accrights_len=yes + ], + [ + ace_cv_lib_posix_struct_msghdr_has_msg_accrights_len=no + ]) + ]) + +dnl Check for 4.4 BSD style struct msghdr members +dnl The following test should only be run if the above two testsfail. + if test "$ace_cv_lib_posix_struct_msghdr_has_msg_accrights" = no && + test "$ace_cv_lib_posix_struct_msghdr_has_msg_accrights_len" = no; then + AC_DEFINE(ACE_LACKS_MSG_ACCRIGHTS) + ACE_CACHE_CHECK(for 4.4 BSD style struct msghdr, + ace_cv_lib_4_4bsd_msghdr,[ + AC_EGREP_HEADER(msg_control, sys/socket.h, + [ + ace_cv_lib_4_4bsd_msghdr=yes + ], + [ + ace_cv_lib_4_4bsd_msghdr=no + ]) + ], + [ + AC_DEFINE(ACE_HAS_4_4BSD_SENDMSG_RECVMSG) + ], + [ + AC_MSG_WARN(No supported msghdr structure was found. ACE may not compile or function properly.) + ]) + fi + +dnl Now check if CMSG_DATA is defined if and only if we have 4.4 BSD +dnl style struct msghdr members. If CMSG_DATA isn't defined, then +dnl we try to figure out what it should be defined to. + if test "$ace_cv_lib_4_4bsd_msghdr" = yes; then + ACE_CACHE_CHECK(if CMSG_DATA is defined, + ace_cv_lib_cmsg_data, + [ + AC_EGREP_CPP(ACE_CMSG_DATA_DEFINED, + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> +#include <sys/un.h> + +#if defined (CMSG_DATA) + ACE_CMSG_DATA_DEFINED +#endif + ], + [ + ace_cv_lib_cmsg_data=yes + ], + [ + ace_cv_lib_cmsg_data=no +dnl Now check which type of CMSG_DATA #define we need. + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> +#include <sys/un.h> + ], + [ + /* This is sloppy. Oh well. :) */ + unsigned char ace_cmsg_data[0]; + + cmsghdr ace_cmsg; + ace_cmsg.cmsg_data = ace_cmsg_data; + ], + [ + dnl Do nothing + ], + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> +#include <sys/un.h> + ], + [ + /* This is sloppy. Oh well. :) */ + unsigned char ace_cmsg_data[0]; + + cmsghdr ace_cmsg; + ace_cmsg.__cmsg_data = ace_cmsg_data; + ], + [ + AC_MSG_ERROR(cmsgmdr member '__cmsg_data[0]' not supported by ACE's CMSG_DATA macro) + ], + [ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> +#include <sys/un.h> + ], + [ + cmsghdr ace_cmsg; + ], + [ + AC_CACHE_VAL(ace_cv_lib_cmsg_data_member, + ace_cv_lib_cmsg_data_member=no) + ], + [ + AC_MSG_ERROR(No supported cmsghdr structure exists. ACE cannot be built without one.) + ]) + ]) + ]) + ]) + ], , + [ + AC_DEFINE(ACE_LACKS_CMSG_DATA_MACRO) + if test "$ace_cv_lib_cmsg_data_member"=no; then + AC_DEFINE(ACE_LACKS_CMSG_DATA_MEMBER) + fi + + ]) + fi dnl test "$ace_cv_lib_4_4bsd_msghdr" = yes + +fi dnl End struct msghdr_stuff + +dnl +dnl SECTION 13: checks for system services +dnl + +dnl TODO: I'm not sure if I am interpreting the meaning of +dnl ACE_HAS_SIGNAL_SAFE_OS_CALLS. Could someone make +dnl sure I am testing for ACE_HAS_SIGNAL_SAFE_OS_CALLS +dnl correctly? +dnl -Ossama +dnl Do not run this test if we are using a cross-compiler. +if test "$cross_compiling" != yes; then + AC_SYS_RESTARTABLE_SYSCALLS + if test "$ac_cv_sys_restartable_syscalls" = yes; then + AC_DEFINE(ACE_HAS_SIGNAL_SAFE_OS_CALLS) + fi +fi + +dnl Check if platform defines ctime() as a macro +ACE_CACHE_CHECK(if platform defines ctime() as a macro, + ace_cv_feature_have_ctime_macro, + [ + AC_EGREP_CPP(ACE_CTIME_MACRO, + [ +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + +#if defined (ctime) + ACE_CTIME_MACRO +#endif + ], + [ + ace_cv_feature_have_ctime_macro=yes + ], + [ + ace_cv_feature_have_ctime_macro=no + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_CTIME),) + +dnl Check if platform defines ctime_r, asctime_r, rand_r or getpwnam_r +dnl as macros. +ACE_CACHE_CHECK(if platform defines some reentrant functions as macros, + ace_cv_feature_has_broken_r_routines, + [ + AC_EGREP_CPP(ACE_R_MACROS, + [ +#ifndef _REENTRANT +# define _REENTRANT +#endif + +#include <time.h> + +#if defined(ACE_LACKS_SYSTIME_H) +# include <sys/time.h> +#endif + +#if defined (HAVE_PWD_H) +# include <pwd.h> +#endif + +#if defined (ctime_r) || \ + defined (asctime_r) || \ + defined (rand_r) || \ + defined (getpwnam_r) + ACE_R_MACROS +#endif + ], + [ + ace_cv_feature_has_broken_r_routines=yes + ], + [ + ace_cv_feature_has_broken_r_routines=no + ]) + ], AC_DEFINE(ACE_HAS_BROKEN_R_ROUTINES),) + +dnl Check if platform defines sig{empty,fill,add,del}set as macros +ACE_CACHE_CHECK(if platform defines sig{empty fill add del}set as macros, + ace_cv_feature_have_sig_macros, + [ + AC_EGREP_CPP(ACE_SIG_MACROS, + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <signal.h> + +#if defined (sigemptyset) && \ + defined (sigfillset) && \ + defined (sigaddset) && \ + defined (sigdelset) && \ + defined (sigismember) + ACE_SIG_MACROS +#endif + ], + [ + ace_cv_feature_have_sig_macros=yes + ], + [ + ace_cv_feature_have_sig_macros=no + ]) + ], AC_DEFINE(ACE_HAS_SIG_MACROS),) + +dnl Check for open() mode masks +ACE_CACHE_CHECK(for open() mode masks, + ace_cv_feature_have_open_mode_masks,[ + AC_EGREP_CPP(ACE_OPEN_MODE_MASKS_EXIST, + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/stat.h> +#include <fcntl.h> + + /* These are ORed so that ACE will not redefine + any of them if any of them exist. */ +#if defined (S_IRWXU) || \ + defined (S_IRUSR) || \ + defined (S_IWUSR) || \ + defined (S_IXUSR) || \ + defined (S_IRWXG) || \ + defined (S_IRGRP) || \ + defined (S_IWGRP) || \ + defined (S_IXGRP) || \ + defined (S_IRWXO) || \ + defined (S_IROTH) || \ + defined (S_IWOTH) || \ + defined (S_IXOTH) + ACE_OPEN_MODE_MASKS_EXIST +#endif + ], + [ + ace_cv_feature_have_open_mode_masks=yes + ], + [ + ace_cv_feature_have_open_mode_masks=no + ]) + ], , AC_DEFINE(ACE_LACKS_MODE_MASKS)) + + +dnl Check if platform supports POSIX O_NONBLOCK semantics +ACE_CACHE_CHECK(for POSIX O_NONBLOCK semantics, + ace_cv_feature_posix_o_nonblock,[ + AC_EGREP_CPP(ACE_POSIX_O_NONBLOCK, + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/stat.h> +#include <fcntl.h> + +#if defined (O_NONBLOCK) + ACE_POSIX_O_NONBLOCK +#endif + ], + [ + ace_cv_feature_posix_o_nonblock=yes + ], + [ + ace_cv_feature_posix_o_nonblock=no + ]) + ], AC_DEFINE(ACE_HAS_POSIX_NONBLOCK),) + +dnl Check if platform defines MAP_FAILED as a long constant +ACE_CACHE_CHECK(if platform defines MAP_FAILED as a long constant, + ace_cv_feature_long_map_failed,[ + dnl We need the square brackets around "ACEMAPFAILED.+[0-9]L" to + dnl prevent the character class "[0-9]" from becoming "0-9" due to + dnl M4 quoting. + AC_EGREP_CPP([ACEMAPFAILED.+[0-9]L], + [ +#include <sys/mman.h> + ACEMAPFAILED MAP_FAILED + ], + [ + ace_cv_feature_long_map_failed=yes + ], + [ + ace_cv_feature_long_map_failed=no + ]) + ], AC_DEFINE(ACE_HAS_LONG_MAP_FAILED),) + +dnl Check if platform supports SO_SNDBUF/SO_RCVBUF socket options +ACE_CACHE_CHECK(if platform supports SO_SNDBUF/SO_RCVBUF socket options, + ace_cv_feature_so_sndbuf_rcvbuf,[ + AC_EGREP_CPP(ACE_SO_BUF, + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/socket.h> + +#if defined (SO_SNDBUF) && \ + defined (SO_RCVBUF) + ACE_SO_BUF +#endif + ], + [ + ace_cv_feature_so_sndbuf_rcvbuf=yes + ], + [ + ace_cv_feature_so_sndbuf_rcvbuf=no + ]) + ], , AC_DEFINE(ACE_LACKS_SOCKET_BUFSIZ)) + +dnl TODO: We only check for ACE_HAS_AUTOMATIC_INIT_FINI on platforms that +dnl have SVR4 dynamic linking since ACE doesn't support it otherwise. +if test "$ac_cv_header_dlfcn_h" = yes && + test "$ace_has_svr4_dynamic_linking" = yes; then +dnl Check if platform calls init/fini automatically + ACE_CACHE_CHECK(if platform calls init/fini automatically, + ace_cv_feature_auto_init_fini,[ + ace_cv_feature_auto_init_fini=yes + # TODO: We know how to check for this, but we need to: + # + # 1. Compile one file. + # 2. Compile and link another file. + # 3. Run file in point (2); it returns what we need. + # + # How do we do all that? + ], AC_DEFINE(ACE_HAS_AUTOMATIC_INIT_FINI),) +fi dnl test "$ac_cv_header_dlfcn_h" = yes && + dnl "$ace_has_svr4_dynamic_linking" = yes + +dnl Check for recursive thread exit semantics +if test "$ace_user_enable_threads" = yes; then + ACE_CACHE_CHECK(for recursive thread exit semantics, + ace_cv_feature_recursive_thr_exit,[ + ace_cv_feature_recursive_thr_exit=yes + # TODO: How do we check for recursive thread exit semantics + ], AC_DEFINE(ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS),) +fi + +dnl Check for asynchronous IO calls +if test "$ace_has_aio_funcs" = yes; then + ACE_CACHE_CHECK(for asynchronous IO calls, + ace_cv_feature_aio_calls,[ + AC_TRY_COMPILE( + [ +#include <aio.h> + ], + [ + aiocb* aiocb_ptr (void); + ], + [ + ace_cv_feature_aio_calls=yes + ], + [ + ace_cv_feature_aio_calls=no + ]) + ], AC_DEFINE(ACE_HAS_AIO_CALLS),) +fi dnl test "$ace_has_aio_funcs" = yes + +dnl Check for UNIX domain sockets +ACE_CACHE_CHECK(for UNIX domain sockets, + ace_cv_feature_unix_sockets, + [ + AC_TRY_COMPILE( + [ +#include <sys/un.h> + ], + [ + sockaddr_un su; + ], + [ + ace_cv_feature_unix_sockets=yes + ], + [ + ace_cv_feature_unix_sockets=no + ]) + ], , AC_DEFINE(ACE_LACKS_UNIX_DOMAIN_SOCKETS)) + +dnl Check for ACE_Handle_Set optimized for select() +ACE_CACHE_CHECK(for ACE_Handle_Set optimized for select(), + ace_cv_feature_handle_set_optimized_for_select,[ + ace_cv_feature_handle_set_optimized_for_select=yes + # TODO: We know how to check this. We need to: + # + # 1. Compile and link a file. + # 2. Run nm on that file. + # + # How do we do that? + ], AC_DEFINE(ACE_HAS_HANDLE_SET_OPTIMIZED_FOR_SELECT),) + +dnl Even we if we don't have IP multicasting, we still need to define +dnl "ACE_HAS_IP_MULTICAST" since struct ip_mreq gets redefined by ACE. +dnl What do we do about this problem? +dnl -Ossama +dnl Check for IP multicast support +ACE_CACHE_CHECK(for IP multicast support, + ace_cv_feature_ip_multicast,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <netinet/in.h> + ], + [ + ip_mreq im; + ], + [ + ace_cv_feature_ip_multicast=yes + ], + [ +dnl Some platforms define ip_mreq in <sys/netinet/in.h>. + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/netinet/in.h> + ], + [ + ip_mreq im; + ], + [ + ace_cv_feature_ip_multicast=yes + ], + [ + ace_cv_feature_ip_multicast=no + ]) + ]) + ], AC_DEFINE(ACE_HAS_IP_MULTICAST),) + +ACE_CACHE_CHECK(if platform runs on an Alpha, + ace_cv_feature_alpha,[ + case "$target" in + alpha*) + ace_cv_feature_alpha=yes + ;; + *) + ace_cv_feature_alpha=no + ;; + esac + ], + [ + case "$target" in + *linux*) + dnl We only define ACE_HAS_ALPHA_TIMER if we are running Linux + dnl on an Alpha and are using GNU C++! + if test -n "$GXX"; then + AC_DEFINE(ACE_HAS_ALPHA_TIMER) + fi + ;; + esac + ],) + +ACE_CACHE_CHECK(if platform runs on a Power PC, + ace_cv_feature_powerpc,[ + case "$target" in + powerpc*) + ace_cv_feature_powerpc=yes + ;; + *) + ace_cv_feature_powerpc=no + ;; + esac + ], + [ + case "$target" in + *aix*) + dnl We don't do anything for AIX since AIX already has a + dnl hi-res timer function! + ;; + *) + dnl Only define ACE_HAS_POWERPC_TIMER when using GNU C++! + if test -n "$GXX"; then + AC_DEFINE(ACE_HAS_POWERPC_TIMER) + fi + ;; + esac + ],) + +ACE_CACHE_CHECK(if platform runs on a Pentium(tm) processor, + ace_cv_feature_pentium,[ + case "$target" in + i386-* | i486-* |i586-* | i686-*) +dnl If we do have a pentium, than define ACE_HAS_PENTIUM and add +dnl gethrtime.cpp to the source list + ace_cv_feature_pentium=yes + ;; + *) + ace_cv_feature_pentium=no + ;; + esac + ], + [ + AC_DEFINE(ACE_HAS_PENTIUM) + ],) +AM_CONDITIONAL(ACE_ON_PENTIUM, test X$ace_cv_feature_pentium = Xyes) + +dnl We need to convert warnings to errors here since GNU C++ just gives +dnl a warning about an implicit declaration of getpgid. +ACE_CONVERT_WARNINGS_TO_ERRORS( dnl +[ +dnl getpgid() requires _GNU_SOURCE to be defined in some platforms. +dnl First check to see if getgpid calls fail without _GNU_SOURCE defines +ACE_CACHE_CHECK(if platform requires _GNU_SOURCE for getpgid definition, + ace_cv_feature_gnu_source,[ + AC_TRY_COMPILE( + [ +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif + ], + [ + int id = getpgid(0); + ], + [ + ace_cv_feature_gnu_source=no + ], + [ +dnl Now check to make sure that these defines actually fix getpgid + AC_TRY_COMPILE( + [ +#define _GNU_SOURCE +/* #define _GNU_SOURCE_EXTENDED */ +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif + ], + [ + int id = getpgid(0); + ], + [ + ace_cv_feature_gnu_source=yes + ], + [ + ace_cv_feature_gnu_source=no + ]) + ]) + ], AC_DEFINE(_GNU_SOURCE),) +]) dnl ACE_CONVERT_WARNINGS_TO_ERRORS + +dnl Check if platform only supports SCHED_OTHER scheduling policy +ACE_CACHE_CHECK(if platform only supports SCHED_OTHER scheduling policy, + ace_cv_feature_only_have_sched_other,[ + AC_EGREP_CPP(WE_ONLY_HAVE_SCHED_OTHER, + [ +#ifdef ACE_HAS_PTHREADS +# include <pthread.h> +#elif defined (ACE_HAS_STHREADS) +# include <thread.h> +#endif + +#if defined (ACE_LACKS_SCHED_H) +# include <sched.h> +#endif + + /* These are ORed so that ACE will not redefine + any of them if any of them exist. */ +#if !defined (SCHED_FIFO) && \ + !defined (SCHED_RR) + WE_ONLY_HAVE_SCHED_OTHER +#endif + ], + [ + ace_cv_feature_only_have_sched_other=yes + ], + [ + ace_cv_feature_only_have_sched_other=no + ]) + ], AC_DEFINE(ACE_HAS_ONLY_SCHED_OTHER),) + +dnl +dnl SECTION 14: checks for aggregated features +dnl TODO: Little by little, get rid of these... +dnl + + +dnl Macro ACE_HAS_REENTRANT_FUNCTIONS means the following functions +dnl are usable: +dnl +dnl rand_r +dnl strtok_r +dnl getpwnam_r (if we don't have, define ACE_LACKS_PWD_REENTRANT_FUNCTIONS) +dnl ctime_r +dnl localtime_r +dnl gmtime_r +dnl asctime_r +dnl * getprotobyname_r +dnl * getprotobynumber_r +dnl * gethostbyaddr_r +dnl * gethostbyname_r +dnl * getservbyname_r +dnl +dnl Those marked with '*' are NOT usable if +dnl ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) is defined. +dnl +dnl The time has come to create feature macros for each of these... +dnl With the separate feature macros, we will define (for now) +dnl ACE_HAS_REENTRANT_FUNCTIONS only when all of those WITHOUHT a '*' +dnl are defined. Also, if any of those with '*' are missing, we will +dnl define ACE_LACKS_NETDB_REENTRANT_FUNCTIONS. + +dnl Don't bother with reentrant functions if they are disabled by the user. +if test "$ace_user_enable_reentrant_funcs" = yes && + test "$ac_cv_func_rand_r" = yes && + test "$ac_cv_func_strtok_r" = yes && + test "$ac_cv_func_ctime_r" = yes && + test "$ac_cv_func_localtime_r" = yes && + test "$ac_cv_func_gmtime_r" = yes && + test "$ac_cv_func_asctime_r" = yes; then + AC_DEFINE(ACE_HAS_REENTRANT_FUNCTIONS +fi + +dnl Don't bother with reentrant functions if they are disabled by the user. +if test "$ace_user_enable_reentrant_funcs" = no || + test "$ac_cv_func_getprotobyname_r" = no || + test "$ac_cv_func_getprotobynumber_r" = no || + test "$ac_cv_func_gethostbyaddr_r" = no || + test "$ac_cv_func_gethostbyname_r" = no || + test "$ac_cv_func_getservbyname_r" = no; then + AC_DEFINE(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS) +fi + +dnl FIXME!!! +dnl The following is a kludge until the netdb reentrant function +dnl number of arguments is handled. +case "$target" in + *linux*) AC_DEFINE(ACE_LACKS_NETDB_REENTRANT_FUNCTIONS);; + *) ;; +esac + + +dnl Macro ACE_LACKS_SOME_POSIX_PROTOTYPES implies any of the following +dnl features: +dnl +dnl ! ACE_HAS_MSGSND_MSGBUFP_2 +dnl ! ACE_LACKS_MSGRCV_VOIDP_2 +dnl ! ACE_LACKS_SHMAT_VOIDP_2 +dnl ! ACE_LACKS_SIGACTION_CONSTP_2 +dnl +dnl So, for now, we define it if any of those were autoconf'ed. + +if test "$ace_cv_lib_posix_msgsnd_msgbufp_2" = yes || + test "$ace_cv_lib_posix_msgrcv_voidp_2" != yes || + test "$ace_cv_lib_posix_shmat_voidp_2" != yes || + test "$ace_cv_lib_posix_sigaction_constp_2" != yes; then + AC_DEFINE(ACE_LACKS_SOME_POSIX_PROTOTYPES) +fi + +if test "$ac_cv_func_msgctl" = yes && + test "$ac_cv_func_msgget" = yes && + test "$ac_cv_func_msgrcv" = yes && + test "$ac_cv_func_semctl" = yes && + test "$ac_cv_func_semget" = yes && + test "$ac_cv_func_semop" = yes && + test "$ac_cv_func_shmat" = yes && + test "$ac_cv_func_shmctl" = yes && + test "$ac_cv_func_shmdt" = yes && + test "$ac_cv_func_shmget" = yes; then + AC_DEFINE(ACE_HAS_SYSV_IPC) +fi + +if test "$ac_cv_func_shmat" != yes || + test "$ac_cv_func_shmctl" != yes || + test "$ac_cv_func_shmdt" != yes || + test "$ac_cv_func_shmget" != yes; then + AC_DEFINE(ACE_LACKS_SYSV_SHMEM) +fi + +dnl Check for what POSIX threads draft we have +AC_MSG_CHECKING(which POSIX thread library was found) + +ace_has_pthreads=no + +dnl Check if we have Pthreads Draft 4 +dnl if test "$ac_cv_func_pthread_delay_np" = yes && +if test "$ac_cv_func_pthread_mutexattr_create" = yes && +dnl test "$ac_cv_func_pthread_mutexattr_setkind_np" = yes && + test "$ac_cv_func_pthread_mutexattr_delete" = yes && + test "$ac_cv_func_pthread_condattr_delete" = yes && + test "$ac_cv_func_pthread_condattr_create" = yes && + test "$ac_cv_func_pthread_setprio" = yes && + test "$ac_cv_func_pthread_getprio" = yes && +dnl test "$ac_cv_func_pthread_getspecific" = yes && + test "$ac_cv_func_pthread_setcancel" = yes && + test "$ac_cv_func_pthread_setasynccancel" = yes && + test "$ac_cv_func_pthread_kill" = yes; then + ace_has_pthreads=yes + AC_MSG_RESULT(POSIX Threads Draft 4) + AC_DEFINE(ACE_HAS_PTHREADS_DRAFT4) +dnl Check if we have Pthreads Draft 6 +elif test "$ac_cv_func_pthread_mutexattr_init" = yes && + test "$ac_cv_func_pthread_mutexattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_init" = yes && + test "$ac_cv_func_pthread_attr_setprio" = yes && + test "$ac_cv_func_pthread_attr_getprio" = yes && + test "$ac_cv_func_pthread_setintr" = yes && + test "$ac_cv_func_pthread_setintrtype" = yes; then + ace_has_pthreads=yes + AC_MSG_RESULT(POSIX Threads Draft 6) + AC_DEFINE(ACE_HAS_PTHREADS_DRAFT6) +dnl Check if we have Pthreads Draft 7 +elif test "$ac_cv_func_pthread_mutexattr_init" = yes && + test "$ac_cv_func_pthread_mutexattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_init" = yes && + test "$ac_cv_func_pthread_setschedparam" = yes && + test "$ac_cv_func_pthread_getschedparam" = yes && + test "$ac_cv_func_pthread_setcancelstate" = yes && + test "$ac_cv_func_pthread_setcanceltype" = yes && + test "$ace_has_sched_yield" != yes; then + ace_has_pthreads=yes + AC_MSG_RESULT(POSIX Threads Draft 7) + AC_DEFINE(ACE_HAS_PTHREADS_DRAFT7) +dnl Check if we have Pthreads Draft Standard +elif test "$ac_cv_func_pthread_mutexattr_init" = yes && + test "$ac_cv_func_pthread_mutexattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_destroy" = yes && + test "$ac_cv_func_pthread_condattr_init" = yes && + test "$ac_cv_func_pthread_setschedparam" = yes && + test "$ac_cv_func_pthread_getschedparam" = yes && + test "$ac_cv_func_pthread_setcancelstate" = yes && + test "$ac_cv_func_pthread_setcanceltype" = yes && + test "$ace_has_sched_yield" = yes; then + ace_has_pthreads=yes + AC_MSG_RESULT(POSIX Threads Draft Standard) + AC_DEFINE(ACE_HAS_PTHREADS_STD) +else + ace_has_pthreads=no + AC_MSG_RESULT(none) +fi dnl PTHREAD DRAFT CHECKS + +dnl Check if we have UNIX International threads +AC_MSG_CHECKING(if a UNIX International thread library was found) +if test "$ace_has_sthreads" = yes; then + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +if test "$ace_user_enable_threads" != yes || + test "$ace_has_pthreads" != yes && + test "$ace_has_sthreads" != yes; then +dnl We don't have a usable thread library! + ace_user_enable_threads=no + AC_MSG_WARN(It appears that you do NOT have any usable thread libraries) + AC_MSG_WARN(or thread support was explicitly disabled.) + AC_MSG_WARN(Disabling thread support.) + dnl ACE uses different versions of readdir_r depending on the thread + dnl library being used, i.e. on the ACE_HAS_*THREADS* macros. Since + dnl it doesn't seem like a good idea to define any ACE_HAS_*THREADS* + dnl macro if ACE won't be supporting threads, define ACE_LACKS_READDIR_R + dnl regardless if readdir_r() exists. + if test "$ac_cv_func_readdir_r" = yes; then + AC_MSG_WARN(Disabling support for readdir_r() since thread support) + AC_MSG_WARN(is being disabled.) + AC_DEFINE(ACE_LACKS_READDIR_R) + fi dnl test "$ac_cv_func_readdir_r" = yes +fi dnl + +if test "$ace_user_enable_threads" = yes; then +dnl If we get this far then we have threads. +dnl FIXME: The "_POSIX" macros may need to be defined _before_ the checks for +dnl reentrant functions! However, we don't want to define them if +dnl the UNIX International threads library was detected. + AC_DEFINE(ACE_HAS_THREADS) + AC_DEFINE(ACE_MT_SAFE) + AC_DEFINE(_REENTRANT) + if test "$ace_has_pthreads" = yes && + test "$ace_has_sthreads" != yes; then + AC_DEFINE(_POSIX_THREADS) + AC_DEFINE(_POSIX_THREAD_SAFE_FUNCTIONS) + AC_DEFINE(_POSIX_PTHREAD_SEMANTICS) + fi dnl test "$ace_has_pthreads" = yes +fi dnl test "$ace_user_enable_threads" = yes + + +if test "$ac_cv_header_libc_h" != yes || + test "$ac_cv_header_osfcn_h" != yes; then + AC_DEFINE(ACE_HAS_CPLUSPLUS_HEADERS) +fi + + + +if test "$ace_cv_lib_signal_vi1_2" = yes && + test "$ace_cv_lib_signal_vi1_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vi1_handler" = yes; then + AC_DEFINE(ACE_HAS_CONSISTENT_SIGNAL_PROTOTYPES) +elif test "$ace_cv_lib_signal_vi1_2" != yes && + test "$ace_cv_lib_signal_vv1_2" != yes && + test "$ace_cv_lib_signal_vi1a2_2" != yes && + test "$ace_cv_lib_signal_va1_2" = yes && + test "$ace_cv_lib_signal_vi1_ret" != yes && + test "$ace_cv_lib_signal_vv1_ret" != yes && + test "$ace_cv_lib_signal_vi1a2_ret" != yes && + test "$ace_cv_lib_signal_va1_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vi1_handler" != yes && + test "$ace_cv_lib_struct_sigaction_vv1_handler" != yes && + test "$ace_cv_lib_struct_sigaction_vi1a2_handler" != yes && + test "$ace_cv_lib_struct_sigaction_va1_handler" = yes; then + AC_DEFINE(ACE_HAS_LYNXOS_SIGNALS) + AC_DEFINE(ACE_HAS_TANDEM_SIGNALS) + AC_DEFINE(ACE_HAS_IRIX_53_SIGNALS) + AC_DEFINE(ACE_HAS_SUNOS4_SIGNAL_T) +elif test "$ace_cv_lib_signal_vi1a2_2" = yes && + test "$ace_cv_lib_signal_vi1a2_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vi1a2_handler" = yes; then + AC_DEFINE(ACE_HAS_SPARCWORKS_401_SIGNALS) +elif test "$ace_cv_lib_signal_vi1_2" = yes && + test "$ace_cv_lib_signal_vi1_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vi1_handler" != yes; then + AC_DEFINE(ACE_HAS_SVR4_SIGNAL_T) +elif test "$ace_cv_lib_signal_vi1_2" = yes && + test "$ace_cv_lib_signal_vv1_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vv1_handler" = yes; then + AC_DEFINE(ACE_HAS_SVR4_SIGNAL_T) +elif test "$ace_cv_lib_signal_vi1_2" = yes && + test "$ace_cv_lib_signal_vi1_ret" != yes && + test "$ace_cv_lib_signal_vv1_ret" != yes && + test "$ace_cv_lib_signal_vi1a2_ret" != yes && + test "$ace_cv_lib_signal_va1_ret" = yes && + test "$ace_cv_lib_struct_sigaction_vi1_handler" != yes && + test "$ace_cv_lib_struct_sigaction_vv1_handler" != yes && + test "$ace_cv_lib_struct_sigaction_vi1a2_handler" != yes && + test "$ace_cv_lib_struct_sigaction_va1_handler" = yes; then + AC_DEFINE(ACE_HAS_UNIXWARE_SVR4_SIGNAL_T) +fi dnl ACE_HAS_CONSISTENT_SIGNAL_PROTOTYPES + +dnl +dnl SECTION 15: Final checks +dnl + +dnl At some point the below platform specific settings should be automated +dnl as much as possible! We set things manually just to get things going +dnl with the auto{conf,make}/libtool integration into the ACE source tree. + +dnl Platform specific flags +case "$target" in + *aix3*) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + ;; + *aix4.1*) + AC_DEFINE(AIX) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + AC_DEFINE(ACE_HAS_AIX_BROKEN_SOCKET_HEADER) + ;; + *aix4.2*) + AC_DEFINE(AIX) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) +dnl AC_DEFINE(ACE_HAS_AIX_BROKEN_SOCKET_HEADER) + AC_DEFINE(ACE_TLI_TCP_DEVICE, "/dev/xti/tcp") + ;; + *cray*) + ;; + *dgux4.11*) + AC_DEFINE(ACE_DGUX) + AC_DEFINE(IP_ADD_MEMBERSHIP, 0x13) + AC_DEFINE(IP_DROP_MEMBERSHIP, 0x14) + ;; + *dgux4*) + AC_DEFINE(ACE_DGUX) + AC_DEFINE(IP_ADD_MEMBERSHIP, 0x13) + AC_DEFINE(IP_DROP_MEMBERSHIP, 0x14) + ;; + *freebsd*) + ;; + *fsu*) +dnl FIXME: "FSU" isn't a platform! We need to move this somewhere. + AC_DEFINE(PTHREAD_STACK_MIN, (1024*10)) + ;; + *hpux9*) + AC_DEFINE(HPUX) + ;; + *hpux10*) + AC_DEFINE(HPUX) + AC_DEFINE(HPUX_10) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + AC_DEFINE(ACE_TLI_TCP_DEVICE, "/dev/inet_cots") + ;; + *hpux11*) + AC_DEFINE(HPUX) + AC_DEFINE(HPUX_11) + AC_EGREP_CPP(ACE_ON_64BIT_HP, + [ +#ifdef __LP64__ + ACE_ON_64BIT_HP +#endif + ], + [ + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x0000001100000000)) + AC_DEFINE(ACE_DEFAULT_BASE_ADDRL, ((char *) 0x0000001100000000)) + ], + [ + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + ]) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *irix5.2*) + AC_DEFINE(IRIX5) + ;; + *irix5.3*) + AC_DEFINE(IRIX5) + ;; + *irix6*) + AC_DEFINE(IRIX6) + AC_DEFINE(ACE_HAS_IRIX62_THREADS) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) (1024U * 1024 * 1024))) + if test "$ace_user_enable_threads" = yes; then + AC_DEFINE(ACE_HAS_IRIX62_THREADS) + fi + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *linux*) + AC_DEFINE(ACE_DEFAULT_MAX_SOCKET_BUFSIZ, 65535) + AC_DEFINE(ACE_DEFAULT_SELECT_REACTOR_SIZE, 256) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + AC_DEFINE(ACE_HAS_BIG_FD_SET) dnl FIXME: We need a test for this! + AC_DEFINE(ACE_UINT64_FORMAT_SPECIFIER, "%Lu") + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *lynxos*) + AC_DEFINE(ACE_MALLOC_ALIGN, 8) + AC_DEFINE(ACE_MAP_PRIVATE, ACE_MAP_SHARED) + AC_DEFINE(ACE_USE_RCSID, 0) + AC_DEFINE(ACE_HAS_LYNXOS_SIGNALS) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *m88k*) + AC_DEFINE(m88k) + AC_DEFINE(__m88k__) + AC_DEFINE(IP_ADD_MEMBERSHIP, 0x13) + AC_DEFINE(IP_DROP_MEMBERSHIP, 0x14) + ;; + *mvs*) + ;; + *netbsd*) + AC_DEFINE(ACE_NETBSD) + ;; + *osf3.2*) + AC_EGREP_CPP(ACE_DEC_CXX, + [ +#if defined(__DECCXX) + ACE_DEC_CXX +#endif + ], + [ + AC_DEFINE(DEC_CXX) + ],) + ;; + *osf4.0*) +dnl We need to add checks for g++, DEC C++ and Rational C++ + AC_EGREP_CPP(ACE_DEC_CXX, + [ +#if defined(__DECCXX) + ACE_DEC_CXX +#endif + ], + [ + AC_DEFINE(DEC_CXX) + ],) +dnl Check for _POSIX_C_SOURCE macro + AC_EGREP_CPP(ACE_ON_DEC_WITH_POS_SRC, + [ + /* Include unistd.h to define _POSIX_C_SOURCE. */ +#ifndef ACE_LACKS_UNISTD_H +# include <unistd.h> +#endif + +#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 199506L) + ACE_ON_DEC_WITH_POS_SRC +#endif + ], + [ + AC_DEFINE(DIGITAL_UNIX) + ],) + AC_DEFINE(ACE_DEFAULT_BASE_ADDR, ((char *) 0x80000000)) + AC_DEFINE(ACE_NEEDS_HUGE_THREAD_STACKSIZE, (1024 * 1024)) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *psos*) + AC_DEFINE(ACE_PSOS) + AC_DEFINE(ACE_PSOSIM) + AC_DEFINE(ACE_PSOSTBD) + dnl need ACE_HAS_TSS_EMULATION for ACE_DEFAULT_THREAD_KEYS! + AC_EGREP_CPP(ACE_TSS_EMULATION, + [ +#if defined (ACE_HAS_TSS_EMULATION) + ACE_TSS_EMULATION +#endif + ], AC_DEFINE(ACE_DEFAULT_THREAD_KEYS, 256),) + AC_DEFINE(ACE_MAIN, extern "C" void root) + AC_DEFINE(ACE_MALLOC_ALIGN, 8) + AC_DEFINE(ACE_USE_RCSID, 0) + ;; + *sco4.2*) + AC_DEFINE(SCO) + AC_DEFINE(ACE_DEFAULT_CLOSE_ALL_HANDLES, 0) + ;; + *sco5*) + AC_DEFINE(SCO) + AC_DEFINE(ACE_DEFAULT_CLOSE_ALL_HANDLES, 0) + AC_DEFINE(ACE_HAS_BIG_FD_SET) dnl FIXME: We need a test for this! + ;; + *sunos4*) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *solaris2.4*) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + AC_DEFINE(ACE_NEEDS_LWP_PRIO_SET) + ;; + *solaris2.5*) + AC_DEFINE(ACE_MALLOC_ALIGN, 8) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + AC_DEFINE(ACE_NEEDS_LWP_PRIO_SET) + ;; + *solaris2.6*) + AC_DEFINE(ACE_MALLOC_ALIGN, 8) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + AC_DEFINE(ACE_NEEDS_LWP_PRIO_SET) + ;; + *solaris2.7*) + AC_DEFINE(ACE_MALLOC_ALIGN, 8) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + AC_DEFINE(ACE_NEEDS_LWP_PRIO_SET) + ;; + *86*solaris*) + AC_DEFINE(ACE_HAS_X86_STAT_MACROS) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + AC_DEFINE(ACE_NEEDS_LWP_PRIO_SET) + ;; + *tandem*) + AC_DEFINE(ACE_TIMER_SKEW, (1000 * 10)) + ;; + *unixware2.0*) + AC_DEFINE(UNIXWARE) + AC_DEFINE(UNIXWARE_2_0) + ;; + *unixware2.1*) + AC_DEFINE(UNIXWARE) + AC_DEFINE(UNIXWARE_2_1) + ;; + *vxworks*) + AC_DEFINE(VXWORKS) + AC_DEFINE(ACE_MAIN, ace_main) + AC_DEFINE(ACE_DEFAULT_MAX_SOCKET_BUFSIZ, 32768) + dnl need ACE_HAS_TSS_EMULATION for ACE_DEFAULT_THREAD_KEYS! + AC_EGREP_CPP(ACE_TSS_EMULATION, + [ +#if defined (ACE_HAS_TSS_EMULATION) + ACE_TSS_EMULATION +#endif + ], AC_DEFINE(ACE_DEFAULT_THREAD_KEYS, 16),) + AC_DEFINE(ACE_THR_PRI_FIFO_DEF, 101) + AC_DEFINE(ACE_USE_RCSID, 0) + ;; + *cygwin32*) + ;; + *win32*) + AC_DEFINE(ACE_WIN32) + AC_DEFINE(ACE_UINT64_FORMAT_SPECIFIER, "%I64u") +dnl AC_DEFINE(ACE_USE_SELECT_REACTOR_FOR_REACTOR_IMPL) + if test "$ace_u_long_long_typedef_set" != yes; then + ACE_UINT64="unsigned __int64" + ace_u_long_long_typedef_set=yes + fi dnl "$ace_u_long_long_typedef_set" != yes + ;; + *) + ;; +esac + +dnl Make final substitutions and defines +if test "$ace_u_long_long_typedef_set" = yes; then + AC_DEFINE_UNQUOTED(ACE_UINT64_TYPEDEF, $ACE_UINT64) +fi + +dnl Additional flags to set by the configure script + +if test -n "$GXX"; then + ACE_CXXFLAGS="$ACE_CXXFLAGS -Wall -Wpointer-arith" + if test "$ace_user_enable_repo" = no; then + ACE_CXXFLAGS="$ACE_CXXFLAGS -fno-implicit-templates" + fi +fi + +if test -n "$GCC"; then + ACE_CFLAGS="$ACE_CFLAGS -Wall -Wpointer-arith" +fi + +dnl Combine package set flags with user's flags. +dnl User's flags go after package flags to allow user to override +dnl package defaults. +dnl X_CFLAGS comes from AC_PATH_XTRA. It may include, for example, +dnl additional include file paths or macros that need to be defined +dnl in order for X11 related files to be compiled properly. +if test "$ace_user_enable_optimize"; then + dnl We want OCXXFLAGS to be on the end, so we use CXXFLAGS, + dnl not ACE_CXXFLAGS! + CXXFLAGS="$CXXFLAGS $OCXXFLAGS" + CFLAGS="$CFLAGS $OCFLAGS" +fi +CXXFLAGS="$ACE_CXXFLAGS $X_CFLAGS $CXXFLAGS" +CXXCPPFLAGS="$ACE_CXXCPPFLAGS $CXXCPPFLAGS" +CFLAGS="$ACE_CFLAGS $X_CFLAGS $CFLAGS" +CPPFLAGS="$ACE_CPPFLAGS $CPPFLAGS" +LDFLAGS="$ACE_LDFLAGS $LDFLAGS" + +dnl These tests should be performed _after_ the bulk of the ACE macros +dnl have been defined. + +dnl Check for ACE iostream support +ACE_CACHE_CHECK(for ACE iostream support, + ace_cv_feature_ace_iostream, + [ + dnl We want an empty ace/config.h to prevent multiple defines + dnl with Autocnf's confdefs.h + ACE_USE_TEMP_FILE(ace/config.h, + [ + dnl Now run the compilation test + ACE_TRY_COMPILE([-I. -I${srcdir}], + [ +#if defined(ACE_UINT64_TYPEDEF) + typedef ACE_UINT64_TYPEDEF ACE_UINT64; +#endif /* ACE_UINT64_TYPEDEF */ + +#include "ace/IOStream.cpp" + ], + [ + int a=0; a += 1; + ], + [ + ace_cv_feature_ace_iostream=yes + ], + [ + ace_cv_feature_ace_iostream=no + ]) + ]) + ], , AC_DEFINE(ACE_LACKS_ACE_IOSTREAM)) + +dnl Check if ACE needs minimum iostream header inclusion +ACE_CACHE_CHECK(if ACE needs minimum iostream header inclusion, + ace_cv_lib_minimum_iostream, + [ + dnl We want an empty ace/config.h to prevent multiple defines + dnl with Autoconf's confdefs.h + ACE_USE_TEMP_FILE(ace/config.h, + [ + dnl Now run the compilation test + ACE_TRY_COMPILE([-I. -I${srcdir}], + [ +#if defined(ACE_UINT64_TYPEDEF) + typedef ACE_UINT64_TYPEDEF ACE_UINT64; +#endif /* ACE_UINT64_TYPEDEF */ + +#include "ace/OS.cpp" + ], + [ + int a=0; a += 1; + ], + [ + ace_cv_lib_minimum_iostream=no + ], + [ + dnl Now check if ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION makes + dnl compilation work! + ACE_TRY_COMPILE([-I. -I${srcdir}], + [ +#if defined(ACE_UINT64_TYPEDEF) + typedef ACE_UINT64_TYPEDEF ACE_UINT64; +#endif /* ACE_UINT64_TYPEDEF */ + +#define ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION +#include "ace/OS.cpp" + ], + [ + int a=0; a += 1; + ], + [ + ace_cv_lib_minimum_iostream=yes + ], + [ + dnl If we get here, then we have no idea what is wrong! + ace_cv_lib_minimum_iostream=no + ]) + ]) + ]) + ], AC_DEFINE(ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION),) + +dnl Check if compiler can't handle the static ACE_Addr::sap_any construct +ACE_CACHE_CHECK(for ACE_addr::sap_any support, + ace_cv_lib_sap_any_support, + [ + dnl We want an empty ace/config.h to prevent multiple defines + dnl with Autoconf's confdefs.h + ACE_USE_TEMP_FILE(ace/config.h, + [ + dnl Now run the compilation test + ACE_TRY_COMPILE([-I. -I${srcdir}], + [ +#if defined(ACE_UINT64_TYPEDEF) + typedef ACE_UINT64_TYPEDEF ACE_UINT64; +#endif /* ACE_UINT64_TYPEDEF */ + +#include "ace/Addr.cpp" + ], + [ + int a=0; a += 1; + ], + [ + ace_cv_lib_sap_any_support=yes + ], + [ + dnl Now check if ACE_HAS_BROKEN_SAP_ANY makes + dnl compilation work! + ACE_TRY_COMPILE([-I. -I${srcdir}], + [ +#if defined(ACE_UINT64_TYPEDEF) + typedef ACE_UINT64_TYPEDEF ACE_UINT64; +#endif /* ACE_UINT64_TYPEDEF */ + +#define ACE_HAS_BROKEN_SAP_ANY +#include "ace/Addr.cpp" + ], + [ + int a=0; a += 1; + ], + [ + ace_cv_lib_sap_any_support=no + ], + [ + dnl If we get here, then we have no idea what is wrong! + ace_cv_lib_sap_any_support=yes + ]) + ]) + ]) + ],, AC_DEFINE(ACE_HAS_BROKEN_SAP_ANY)) + +dnl End ACE macro tests! + +dnl Substitute whatever X libraries ACE needs, if any. +AC_SUBST(ACE_XLIBS) + +dnl Prepend purify and quantify command lines if purify and quantify are +dnl enabled. Otherwise, PURELINK and PRELINK will just be "blank." +LD="$PURELINK $PRELINK $LD" +dnl LDFLAGS="$ACE_LDFLAGS $LDFLAGS" + +dnl AC_SUBST(LDFLAGS) +dnl AC_SUBST(LIBOBJS) + +dnl These definitions are expanded in the makefile and ace-config +if test "$no_x" != yes; then + ACE_LIBDIR="${X_LIBS} -L\${libdir}" +else + ACE_LIBDIR='-L${libdir}' +fi +ACE_LIBS="${X_PRE_LIBS} ${ACE_XLIBS} ${X_EXTRA_LIBS} ${LIBS}" +ACE_INCLUDEDIR='-I${includedir}' + +AC_SUBST(ACE_LIBDIR) +AC_SUBST(ACE_LIBS) +AC_SUBST(ACE_INCLUDEDIR) + +dnl Force CXXFLAGS to be substituted in Makefiles that don't "need" them. +AC_SUBST(CXXFLAGS) + +dnl +dnl SECTION 16: `AC_OUTPUT([FILE...])' +dnl +dnl +dnl We can finally create all the files listed here; Makefile is +dnl created from Makefile.in, etc. Top-level Makefiles should be +dnl created first. +AC_OUTPUT([ +dnl Makefile +dnl NEWS + ace-config + ace-diff-config +dnl ace/Makefile +dnl apps/Makefile +dnl apps/gperf/Makefile +dnl apps/gperf/src/Makefile +dnl man/Makefile +dnl man/man3/Makefile +dnl netsvcs/Makefile +dnl netsvcs/clients/Makefile +dnl netsvcs/clients/Logger/Makefile +dnl netsvcs/clients/Naming/Makefile +dnl netsvcs/clients/Naming/Client/Makefile +dnl netsvcs/clients/Naming/Dump_Restore/Makefile +dnl netsvcs/clients/Tokens/Makefile +dnl netsvcs/clients/Tokens/collection/Makefile +dnl netsvcs/clients/Tokens/deadlock/Makefile +dnl netsvcs/clients/Tokens/invariant/Makefile +dnl netsvcs/clients/Tokens/manual/Makefile +dnl netsvcs/clients/Tokens/mutex/Makefile +dnl netsvcs/clients/Tokens/rw_lock/Makefile +dnl netsvcs/lib/Makefile +dnl netsvcs/servers/Makefile +dnl tests/Makefile +dnl tests/log/Makefile + ]) + +dnl Make sure ace-diff-config is executable +dnl chmod 755 ace-diff-config + +echo "" +echo "Configuration of ACE is now complete." +echo "" |