From e8ec7aa8e38a93f5b034ac74cebce5de23710317 Mon Sep 17 00:00:00 2001 From: hongbotian Date: Mon, 30 Nov 2015 01:45:08 -0500 Subject: upload http JIRA: BOTTLENECK-10 Change-Id: I7598427ff904df438ce77c2819ee48ac75ffa8da Signed-off-by: hongbotian --- rubbos/app/httpd-2.0.64/srclib/apr/configure.in | 1998 +++++++++++++++++++++++ 1 file changed, 1998 insertions(+) create mode 100644 rubbos/app/httpd-2.0.64/srclib/apr/configure.in (limited to 'rubbos/app/httpd-2.0.64/srclib/apr/configure.in') diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/configure.in b/rubbos/app/httpd-2.0.64/srclib/apr/configure.in new file mode 100644 index 00000000..3e63c9fa --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/configure.in @@ -0,0 +1,1998 @@ +dnl +dnl Autoconf configuration file for APR +dnl +dnl Process this file with autoconf to produce a configure script. +dnl Use ./buildconf to prepare build files and run autoconf for APR. + +AC_INIT(build/apr_common.m4) +AC_CONFIG_HEADER(include/arch/unix/apr_private.h) +AC_CONFIG_AUX_DIR(build) + +dnl +dnl Include our own M4 macros along with those for libtool +dnl +sinclude(build/apr_common.m4) +sinclude(build/apr_network.m4) +sinclude(build/apr_threads.m4) +sinclude(build/apr_hints.m4) +sinclude(build/libtool.m4) + +dnl Save user-defined environment settings for later restoration +dnl +APR_SAVE_THE_ENVIRONMENT(CPPFLAGS) +APR_SAVE_THE_ENVIRONMENT(CFLAGS) +APR_SAVE_THE_ENVIRONMENT(LDFLAGS) +APR_SAVE_THE_ENVIRONMENT(LIBS) +APR_SAVE_THE_ENVIRONMENT(INCLUDES) + +dnl Generate ./config.nice for reproducing runs of configure +dnl +APR_CONFIG_NICE(config.nice) + +AC_CANONICAL_SYSTEM +echo "Configuring APR library" +echo "Platform: $host" + +dnl Some initial steps for configuration. We setup the default directory +dnl and which files are to be configured. + +dnl Setup the directory macros now + +# Absolute source/build directory +apr_srcdir=`(cd $srcdir && pwd)` +apr_builddir=`pwd` +AC_SUBST(apr_srcdir) +AC_SUBST(apr_builddir) + +if test "$apr_builddir" != "$apr_srcdir"; then + USE_VPATH=1 + APR_CONFIG_LOCATION=build +else + APR_CONFIG_LOCATION=source +fi + +AC_SUBST(APR_CONFIG_LOCATION) + +# Libtool might need this symbol -- it must point to the location of +# the generated libtool script (not necessarily the "top" build dir). +# +top_builddir="$apr_builddir" +AC_SUBST(top_builddir) + +# Directory containing apr build macros, helpers, and make rules +# NOTE: make rules (apr_rules.mk) will be in the builddir for vpath +# +apr_buildout=$apr_builddir/build +apr_builders=$apr_srcdir/build +AC_SUBST(apr_builders) + +MKDIR=$apr_builders/mkdir.sh + +dnl Initialize mkdir -p functionality. +APR_MKDIR_P_CHECK($apr_builders/mkdir.sh) + +# get our version information +get_version="$apr_builders/get-version.sh" +version_hdr="$apr_srcdir/include/apr_version.h" +APR_MAJOR_VERSION="`$get_version major $version_hdr APR`" +APR_DOTTED_VERSION="`$get_version all $version_hdr APR`" + +AC_SUBST(APR_DOTTED_VERSION) +AC_SUBST(APR_MAJOR_VERSION) + +echo "APR Version: ${APR_DOTTED_VERSION}" + +dnl Enable the layout handling code, then reparse the prefix-style +dnl arguments due to autoconf being a PITA. +APR_ENABLE_LAYOUT(apr) +APR_PARSE_ARGUMENTS + +dnl Set optional CC hints here in case autoconf makes an inappropriate choice. +dnl This allows us to suggest what the compiler should be, but still +dnl allows the user to override CC externally. +APR_CC_HINTS + +dnl Do the various CC checks *before* preloading values. The preload code +dnl may need to use compiler characteristics to make decisions. This macro +dnl can only be used once within a configure script, so this prevents a +dnl preload section from invoking the macro to get compiler info. +AC_PROG_CC + +dnl Preload +APR_PRELOAD + +dnl These added to allow default directories to be used... +DEFAULT_OSDIR="unix" +echo "(Default will be ${DEFAULT_OSDIR})" + +apr_modules="file_io network_io threadproc misc locks time mmap shmem user memory atomic poll support" + +dnl Checks for programs. +AC_PROG_MAKE_SET +AC_PROG_CPP +AC_PROG_AWK +AC_PROG_LN_S +AC_PROG_RANLIB +AC_PROG_INSTALL +AC_CHECK_PROG(RM, rm, rm) +AC_CHECK_PROG(AS, as, as) +AC_CHECK_PROG(ASCPP, cpp, cpp) +AC_CHECK_TOOL(AR, ar, ar) + +dnl Various OS checks that apparently set required flags +ifdef([AC_USE_SYSTEM_EXTENSIONS], [ +AC_USE_SYSTEM_EXTENSIONS +], [ +AC_AIX +AC_MINIX +]) + +AC_ISC_POSIX +APR_EBCDIC + +dnl this is our library name +APR_LIBNAME="apr${libsuffix}" +AC_SUBST(APR_LIBNAME) + +dnl prep libtool +dnl +echo "performing libtool configuration..." + +AC_ARG_ENABLE(experimental-libtool,[ --experimental-libtool Use experimental custom libtool (not included in source distribution)], + [experimental_libtool=$enableval],[experimental_libtool=no]) + +case $host in +*os2*) + # Use a custom-made libtool replacement + echo "using aplibtool" + LIBTOOL="$srcdir/build/aplibtool" + gcc $CFLAGS $CPPFLAGS -o $LIBTOOL.exe $LIBTOOL.c + ;; +*) + if test "x$LTFLAGS" = "x"; then + LTFLAGS='--silent' + fi + if test "$experimental_libtool" = "yes"; then + # Use a custom-made libtool replacement + echo "using jlibtool" + LIBTOOL="$apr_builddir/libtool" + LIBTOOL_SRC="$apr_srcdir/build/jlibtool.c" + if test ! -f $LIBTOOL_SRC; then + AC_MSG_ERROR([Experimental libtool source not found. It is not included with APR by default.]) + fi + $CC $CFLAGS $CPPFLAGS -o $LIBTOOL $LIBTOOL_SRC + else + dnl libtoolize requires that the following not be indented +AC_PROG_LIBTOOL + # get libtool's setting of shlibpath_var + eval `grep "^shlibpath_var=[[A-Z_]]*$" $apr_builddir/libtool` + if test "x$shlibpath_var" = "x"; then + shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR + fi + fi + ;; +esac + +AC_ARG_WITH(installbuilddir, [ --with-installbuilddir=DIR location to store APR build files (defaults to '${datadir}/build')], + [ installbuilddir=$withval ], [ installbuilddir="${datadir}/build" ] ) +AC_SUBST(installbuilddir) + +AC_ARG_WITH(libtool, [ --without-libtool avoid using libtool to link the library], + [ use_libtool=$withval ], [ use_libtool="yes" ] ) + +if test "x$use_libtool" = "xyes"; then + lt_compile='$(LIBTOOL) $(LTFLAGS) --mode=compile $(COMPILE) -c $< && touch $@' + LT_VERSION="-version-info `$get_version libtool $version_hdr APR`" + link="\$(LIBTOOL) \$(LTFLAGS) --mode=link \$(LT_LDFLAGS) \$(COMPILE) ${LT_VERSION} \$(ALL_LDFLAGS) -o \$@" + so_ext='lo' + lib_target='-rpath $(libdir) $$objects' + export_lib_target='-rpath \$(libdir) \$\$objects' +else + lt_compile='$(COMPILE) -c $<' + link='$(AR) cr $(TARGET_LIB) $$objects; $(RANLIB) $(TARGET_LIB)' + so_ext='o' + lib_target='' + export_lib_target='' +fi + +case $host in + *-solaris2*) + apr_platform_runtime_link_flag="-R" + ;; + *) + ;; +esac + +AC_SUBST(lt_compile) +AC_SUBST(link) +AC_SUBST(so_ext) +AC_SUBST(lib_target) +AC_SUBST(export_lib_target) +AC_SUBST(shlibpath_var) +AC_SUBST(LTFLAGS) +AC_SUBST(LT_LDFLAGS) + +dnl ----------------------------- Checks for compiler flags +nl=' +' +echo "${nl}Check for compiler flags..." + +dnl AC_PROG_CC sets -g in CFLAGS (and -O2 for gcc) by default. +dnl On OS/390 this causes the compiler to insert extra debugger +dnl hook instructions. That's fine for debug/maintainer builds, not fine +dnl otherwise. + +case $host in + *os390) + if test "$ac_test_CFLAGS" != set; then + APR_REMOVEFROM(CFLAGS,-g) + fi + ;; +esac + +AC_ARG_ENABLE(debug,[ --enable-debug Turn on debugging and compile time warnings], + [APR_ADDTO(CFLAGS,-g) + if test "$GCC" = "yes"; then + APR_ADDTO(CFLAGS,-Wall) + elif test "$AIX_XLC" = "yes"; then + APR_ADDTO(CFLAGS,-qfullpath) + fi +])dnl + +AC_ARG_ENABLE(maintainer-mode,[ --enable-maintainer-mode Turn on debugging and compile time warnings], + [APR_ADDTO(CFLAGS,-g) + if test "$GCC" = "yes"; then + APR_ADDTO(CFLAGS,[-Wall -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations]) + elif test "$AIX_XLC" = "yes"; then + APR_ADDTO(CFLAGS,-qfullpath -qinitauto=FE -qcheck=all -qinfo=pro) + fi +])dnl + +AC_ARG_ENABLE(profile,[ --enable-profile Turn on profiling for the build (GCC)], + if test "$GCC" = "yes"; then + APR_ADDTO(CFLAGS, -pg) + APR_REMOVEFROM(CFLAGS, -g) + if test "$host" = "i586-pc-beos"; then + APR_REMOVEFROM(CFLAGS, -O2) + APR_ADDTO(CFLAGS, -O1) + APR_ADDTO(LDFLAGS, -p) + fi + fi +)dnl + +AC_ARG_ENABLE(pool-debug, + [ --enable-pool-debug[[=yes|no|verbose|verbose-alloc|lifetime|owner|all]] Turn on pools debugging], + [ if test -z "$enableval"; then + APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=1) + elif test ! "$enableval" = "no"; then + apr_pool_debug=1 + + for i in $enableval + do + flag=0 + + case $i in + yes) + flag=1 + ;; + verbose) + flag=2 + ;; + lifetime) + flag=4 + ;; + owner) + flag=8 + ;; + verbose-alloc) + flag=16 + ;; + all) + apr_pool_debug=31 + ;; + *) + ;; + esac + + if test $flag -gt 0; then + apr_pool_debug=`expr '(' $apr_pool_debug - $apr_pool_debug % \ + '(' $flag '*' 2 ')' ')' + $flag + $apr_pool_debug % $flag` + fi + done + + APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=$apr_pool_debug) + fi + ]) + +dnl Electric Fence malloc checker. +dnl --with-efence specifies the path to Electric Fence +AC_ARG_WITH(efence, + [ --with-efence[[=DIR]] path to Electric Fence installation], + [ apr_efence_dir="$withval" + if test "$apr_efence_dir" != "yes"; then + APR_ADDTO(LDFLAGS,[-L$apr_efence_dir/lib]) + if test "x$apr_platform_runtime_link_flag" != "x"; then + APR_ADDTO(LDFLAGS, + [$apr_platform_runtime_link_flag$apr_efence_dir/lib]) + fi + fi + AC_CHECK_LIB(efence, malloc, + [ APR_ADDTO(LIBS,-lefence) ], + [ AC_MSG_ERROR(Electric Fence requested but not detected) ]) + ]) + +if test "$host" = "i586-pc-beos"; then + AC_ARG_ENABLE(malloc-debug,[ --enable-malloc-debug Switch on malloc_debug for BeOS], + APR_REMOVEFROM(CFLAGS, -O2) + APR_ADDTO(CPPFLAGS, -fcheck-memory-usage -D_KERNEL_MODE) + ) dnl +fi + +# this is the place to put specific options for platform/compiler +# combinations +case "$host:$CC" in + *-hp-hpux*:cc ) + APR_ADDTO(CFLAGS,[-Ae +Z]) + case $host in + ia64-* ) + ;; + * ) + if echo "$CFLAGS " | grep '+DA' >/dev/null; then : + else + APR_ADDTO(CFLAGS,[+DAportable]) + fi + ;; + esac + ;; + powerpc-*-beos:mwcc* ) + APR_SETVAR(CPP,[mwcc -E]) + APR_SETVAR(CC,mwcc) + APR_SETVAR(AR,ar) + ;; +esac + +dnl Check the depend program we can use +APR_CHECK_DEPEND + +# force_atomic_generic flag +# this will be set we find a cpu/OS combo +# which is historical and doesn't work with the method +# we are using for the more up to date cpu/OS +# (ie.. old sparcs) +apr_force_atomic_generic=0 +proc_mutex_is_global=0 +nonportable_atomics_enabled=0 + +AC_ARG_ENABLE(nonportable-atomics, +[ --enable-nonportable-atomics Turn on optimized atomic code which may produce nonportable binaries], +[ + if test "$enableval" = "yes"; then + nonportable_atomics_enabled=1 + fi +]) + +config_subdirs="none" +INSTALL_SUBDIRS="none" +case $host in + i386-ibm-aix* | *-ibm-aix[[1-2]].* | *-ibm-aix3.* | *-ibm-aix4.1 | *-ibm-aix4.1.* | *-ibm-aix4.2 | *-ibm-aix4.2.*) + OSDIR="aix" + APR_ADDTO(LDFLAGS,-lld) + eolstr="\\n" + ;; + *-os2*) + APR_ADDTO(CPPFLAGS,-DOS2) + APR_ADDTO(CFLAGS,-Zmt) + AC_CHECK_LIB(bsd, random) + OSDIR="os2" + enable_threads="system_threads" + eolstr="\\r\\n" + file_as_socket="0" + proc_mutex_is_global=1 + ;; + *beos*) + OSDIR="beos" + APR_ADDTO(CPPFLAGS,-DBEOS) + enable_threads="system_threads" + native_mmap_emul="1" + APR_CHECK_DEFINE(BONE_VERSION, sys/socket.h) + eolstr="\\n" + osver=`uname -r` + proc_mutex_is_global=1 + case $osver in + 5.0.4) + file_as_socket="1" + ;; + *) + file_as_socket="0" + ;; + esac + ;; + *os390) + OSDIR="os390" + eolstr="\\n" + ;; + *os400) + OSDIR="as400" + eolstr="\\n" + ;; + *cygwin*) + OSDIR="unix" + APR_ADDTO(CPPFLAGS,-DCYGWIN) + enable_threads="no" + eolstr="\\n" + ;; + *linux*) + apr_force_atomic_generic=1 + case $host_cpu in + i486|i586|i686) + if test "$nonportable_atomics_enabled" = 1; then + apr_force_atomic_generic=0 + fi + ;; + esac + OSDIR="unix" + eolstr="\\n" + ;; + *hpux10* ) + enable_threads="no" + OSDIR="unix" + eolstr="\\n" + ;; + *) + OSDIR="unix" + eolstr="\\n" + ;; +esac + +AC_SUBST(apr_force_atomic_generic) +AC_SUBST(proc_mutex_is_global) +AC_SUBST(eolstr) +AC_SUBST(INSTALL_SUBDIRS) + +# For some platforms we need a version string which allows easy numeric +# comparisons. +case $host in + *freebsd*) + if test -x /sbin/sysctl; then + os_version=`/sbin/sysctl -n kern.osreldate` + else + os_version=000000 + fi + ;; + *linux*) + os_version=`uname -r | sed -e 's/\(.\)\.\(.\)\.\(.\).*/\1\2\3/'` + ;; + *darwin*) + os_version=`uname -r | sed -e 's/\(.\)\.\(.\).*/\1\2/'` + ;; + *) + os_version=OS_VERSION_IS_NOT_SET + ;; +esac + +dnl ----------------------------- Checks for Any required Libraries +dnl Note: Autoconf will always append LIBS with an extra " " in AC_CHECK_LIB. +dnl It should check for LIBS being empty and set LIBS equal to the new value +dnl without the extra " " in that case, but they didn't do that. So, we +dnl end up LIBS="-lm -lcrypt -lnsl -ldl" which is an annoyance. +AC_CHECK_LIB(resolv, res_init) +AC_CHECK_LIB(nsl, gethostbyname) +AC_SEARCH_LIBS(gethostname, nsl) +AC_CHECK_LIB(socket, socket) +AC_SEARCH_LIBS(crypt, crypt ufc) +AC_CHECK_LIB(truerand, main) +AC_SEARCH_LIBS(modf, m) +AC_SEARCH_LIBS(sqrt, m) + +dnl ----------------------------- Checking for Threads +echo "${nl}Checking for Threads..." + +if test -z "$enable_threads"; then + AC_ARG_ENABLE(threads, + [ --enable-threads Enable threading support in APR.], + [ enable_threads=$enableval] , + [ APR_CHECK_PTHREADS_H([ enable_threads="pthread" ] , + [ enable_threads="no" ] ) ] ) +fi + +if test "$enable_threads" = "no"; then + threads="0" + pthreadh="0" + pthreadser="0" +else + if test "$enable_threads" = "pthread"; then +# We have specified pthreads for our threading library, just make sure +# that we have everything we need + APR_PTHREADS_CHECK_SAVE + APR_PTHREADS_CHECK + APR_CHECK_PTHREADS_H([ + threads="1" + pthreadh="1" + pthreadser="1" + AC_DEFINE(USE_THREADS, 1, [Define if APR supports threads]) ], [ + threads="0" + pthreadh="0" + pthreadser="0" + APR_PTHREADS_CHECK_RESTORE ] ) + elif test "$enable_threads" = "system_threads"; then + threads="1" + pthreadh="0" + pthreadser="0" + else +# We basically specified that we wanted threads, but not how to implement +# them. In this case, just look for pthreads. In the future, we can check +# for other threading libraries as well. + APR_PTHREADS_CHECK_SAVE + APR_PTHREADS_CHECK + APR_CHECK_PTHREADS_H([ + threads="1" + pthreadh="1" + pthreadser="1" + AC_DEFINE(USE_THREADS) ], [ + threads="0" + pthreadser="0" + pthreadh="0" + APR_PTHREADS_CHECK_RESTORE ] ) + fi + if test "$pthreadh" = "1"; then + APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS + APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG + AC_CHECK_FUNCS(pthread_key_delete pthread_rwlock_init) + + if test "$ac_cv_func_pthread_rwlock_init" = "yes"; then + dnl ----------------------------- Checking for pthread_rwlock_t + AC_CACHE_CHECK([for pthread_rwlock_t], [apr_cv_type_rwlock_t], + AC_TRY_COMPILE([#include +#include ], [pthread_rwlock_t *rwlock;], + [apr_cv_type_rwlock_t=yes], [apr_cv_type_rwlock_t=no], + [apr_cv_type_rwlock_t=no])) + if test "$apr_cv_type_rwlock_t" = "yes"; then + AC_DEFINE(HAVE_PTHREAD_RWLOCKS, 1, [Define if pthread rwlocks are available]) + fi + fi + # this might also require -DXOPEN_SOURCE=500, so leave after the + # rwlock check. + APR_CHECK_PTHREAD_RECURSIVE_MUTEX + fi +fi + +ac_cv_define_READDIR_IS_THREAD_SAFE=no +ac_cv_define_GETHOSTBYNAME_IS_THREAD_SAFE=no +ac_cv_define_GETHOSTBYADDR_IS_THREAD_SAFE=no +if test "$threads" = "1"; then + echo "APR will use threads" + AC_CHECK_LIB(c_r, readdir, + AC_DEFINE(READDIR_IS_THREAD_SAFE, 1, + [Define if readdir is thread safe])) + if test "x$apr_gethostbyname_is_thread_safe" = "x"; then + AC_CHECK_LIB(c_r, gethostbyname, apr_gethostbyname_is_thread_safe=yes) + fi + if test "$apr_gethostbyname_is_thread_safe" = "yes"; then + AC_DEFINE(GETHOSTBYNAME_IS_THREAD_SAFE, 1, + [Define if gethostbyname is thread safe]) + fi + if test "x$apr_gethostbyaddr_is_thread_safe" = "x"; then + AC_CHECK_LIB(c_r, gethostbyaddr, apr_gethostbyaddr_is_thread_safe=yes) + fi + if test "$apr_gethostbyaddr_is_thread_safe" = "yes"; then + AC_DEFINE(GETHOSTBYADDR_IS_THREAD_SAFE, 1, + [Define if gethostbyaddr is thread safe]) + fi + AC_CHECK_FUNCS(gethostbyname_r gethostbyaddr_r) +else + echo "APR will be non-threaded" +fi + +AC_CHECK_FUNCS(sigsuspend, [ have_sigsuspend="1" ], [ have_sigsuspend="0" ]) +AC_CHECK_FUNCS(sigwait, [ have_sigwait="1" ], [ have_sigwait="0" ]) +dnl AC_CHECK_FUNCS doesn't work for this on Tru64 since the function +dnl is renamed in signal.h. Todo: Autodetect +case $host in + *alpha*-dec-osf* ) + have_sigwait="1" + ;; +esac + +AC_SUBST(threads) +AC_SUBST(have_sigsuspend) +AC_SUBST(have_sigwait) + +AC_CHECK_FUNCS(poll) + +dnl ----------------------------- Checking for missing POSIX thread functions +AC_CHECK_FUNCS([getpwnam_r getpwuid_r getgrnam_r getgrgid_r]) + +dnl ----------------------------- Checking for Shared Memory Support +echo "${nl}Checking for Shared Memory Support..." + +# The real-time POSIX extensions (e.g. shm_*, sem_*) may only +# be available if linking against librt. +AC_SEARCH_LIBS(shm_open, rt) + +case $host in + *-sysv*) + ac_includes_default="$ac_includes_default +#if HAVE_SYS_MUTEX_H /* needed to define lock_t for sys/shm.h */ +# include +#endif";; +esac + +AC_CHECK_HEADERS([sys/mman.h sys/ipc.h sys/mutex.h sys/shm.h sys/file.h kernel/OS.h os2.h]) +AC_CHECK_FUNCS([mmap munmap shm_open shm_unlink shmget shmat shmdt shmctl \ + create_area]) +APR_CHECK_DEFINE(MAP_ANON, sys/mman.h) +AC_CHECK_FILE(/dev/zero) + +# Not all systems can mmap /dev/zero (such as HP-UX). Check for that. +if test "$ac_cv_func_mmap" = "yes" && + test "$ac_cv_file__dev_zero" = "yes"; then + AC_MSG_CHECKING(for mmap that can map /dev/zero) + AC_TRY_RUN([ +#include +#include +#include +#ifdef HAVE_SYS_MMAN_H +#include +#endif + int main() + { + int fd; + void *m; + fd = open("/dev/zero", O_RDWR); + if (fd < 0) { + return 1; + } + m = mmap(0, sizeof(void*), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); + if (m == (void *)-1) { /* aka MAP_FAILED */ + return 2; + } + if (munmap(m, sizeof(void*)) < 0) { + return 3; + } + return 0; + }], [], [ac_cv_file__dev_zero=no], [ac_cv_file__dev_zero=no]) + + AC_MSG_RESULT($ac_cv_file__dev_zero) +fi + +# Now we determine which one is our anonymous shmem preference. +haveshmgetanon="0" +havemmapzero="0" +havemmapanon="0" +APR_BEGIN_DECISION([anonymous shared memory allocation method]) +APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl + func:shmget func:shmat func:shmdt func:shmctl, + [haveshmgetanon="1" + APR_DECIDE(USE_SHMEM_SHMGET_ANON, [SysV IPC shmget()])]) +APR_IFALLYES(header:sys/mman.h func:mmap func:munmap file:/dev/zero, + [havemmapzero="1" + APR_DECIDE(USE_SHMEM_MMAP_ZERO, + [SVR4-style mmap() on /dev/zero])]) +APR_IFALLYES(header:sys/mman.h func:mmap func:munmap define:MAP_ANON, + [havemmapanon="1" + APR_DECIDE(USE_SHMEM_MMAP_ANON, + [4.4BSD-style mmap() via MAP_ANON])]) +APR_IFALLYES(header:os2.h, + [haveos2shm="1" + APR_DECIDE(USE_SHMEM_OS2_ANON, [OS/2 DosAllocSharedMem()])]) +APR_IFALLYES(header:kernel/OS.h func:create_area, + [havebeosshm="1" + APR_DECIDE(USE_SHMEM_BEOS_ANON, + [BeOS areas])]) +case $host in + *linux* ) + # Linux has problems with MM_SHMT_MMANON even though it reports + # that it has it. + # FIXME - find exact 2.3 version that MMANON was fixed in. It is + # confirmed fixed in 2.4 series. + if test $os_version -le "240"; then + APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_ZERO USE_SHMEM_SHMGET_ANON) + fi + ;; + *hpux11* ) + APR_DECISION_OVERRIDE(USE_SHMEM_SHMGET_ANON) + ;; +esac +APR_END_DECISION +AC_DEFINE_UNQUOTED($ac_decision) + +useshmgetanon="0" +usemmapzero="0" +usemmapanon="0" + +case $ac_decision in + USE_SHMEM_SHMGET_ANON ) + useshmgetanon="1" + ;; + USE_SHMEM_MMAP_ZERO ) + usemmapzero="1" + ;; + USE_SHMEM_MMAP_ANON ) + usemmapanon="1" + ;; +esac + +AC_SUBST(useshmgetanon) +AC_SUBST(usemmapzero) +AC_SUBST(usemmapanon) +AC_SUBST(haveshmgetanon) +AC_SUBST(havemmapzero) +AC_SUBST(havemmapanon) + +# Now we determine which one is our name-based shmem preference. +havemmaptmp="0" +havemmapshm="0" +haveshmget="0" +havebeosarea="0" +haveos2shm="0" +APR_BEGIN_DECISION([namebased memory allocation method]) +APR_IFALLYES(header:sys/mman.h func:mmap func:munmap, + [havemmaptmp="1" + APR_DECIDE(USE_SHMEM_MMAP_TMP, + [Classical mmap() on temporary file])]) +APR_IFALLYES(header:sys/mman.h func:mmap func:munmap func:shm_open dnl + func:shm_unlink, + [havemmapshm="1" + APR_DECIDE(USE_SHMEM_MMAP_SHM, + [mmap() via POSIX.1 shm_open() on temporary file])]) +APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl + func:shmget func:shmat func:shmdt func:shmctl, + [haveshmget="1" + APR_DECIDE(USE_SHMEM_SHMGET, [SysV IPC shmget()])]) +APR_IFALLYES(header:kernel/OS.h func:create_area, + [havebeosshm="1" + APR_DECIDE(USE_SHMEM_BEOS, [BeOS areas])]) +APR_IFALLYES(header:os2.h, + [haveos2shm="1" + APR_DECIDE(USE_SHMEM_OS2, [OS/2 DosAllocSharedMem()])]) +case $host in + *linux* ) + # Linux has problems with MM_SHMT_MMANON even though it reports + # that it has it. + # FIXME - find exact 2.3 version that MMANON was fixed in. It is + # confirmed fixed in 2.4 series. + if test $os_version -le "240"; then + APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_TMP USE_SHMEM_MMAP_SHM dnl + USE_SHMEM_SHMGET) + fi + ;; +esac +APR_END_DECISION +AC_DEFINE_UNQUOTED($ac_decision) + +usemmaptmp="0" +usemmapshm="0" +useshmget="0" +usebeosarea="0" +useos2shm="0" + +case $ac_decision in + USE_SHMEM_MMAP_TMP ) + usemmaptmp="1" + ;; + USE_SHMEM_MMAP_SHM ) + usemmapshm="1" + ;; + USE_SHMEM_SHMGET ) + useshmget="1" + ;; + USE_SHMEM_BEOS ) + usebeosarea="1" + ;; + USE_SHMEM_OS2 ) + useos2shm="1" + ;; +esac + +# Do we have any shared memory support? +if test "$usemmaptmp$usemmapshm$usemmapzero$useshmget$usemmapanon$usebeosarea$useos2shm" = "0000000"; then + sharedmem="0" +else + sharedmem="1" +fi + +AC_SUBST(usemmaptmp) +AC_SUBST(usemmapshm) +AC_SUBST(useshmget) +AC_SUBST(usebeosarea) +AC_SUBST(useos2shm) +AC_SUBST(havemmaptmp) +AC_SUBST(havemmapshm) +AC_SUBST(haveshmget) +AC_SUBST(havebeosarea) +AC_SUBST(haveos2shm) +AC_SUBST(sharedmem) + +dnl ----------------------------- Checks for Any required Functions +dnl Checks for library functions. (N.B. poll is further down) +AC_CHECK_FUNCS(alloca calloc strcasecmp stricmp setsid isinf isnan) +AC_CHECK_FUNCS(getenv putenv setenv unsetenv) +AC_CHECK_FUNCS(setrlimit, [ have_setrlimit="1" ], [ have_setrlimit="0" ]) +AC_CHECK_FUNCS(getrlimit, [ have_getrlimit="1" ], [ have_getrlimit="0" ]) +AC_CHECK_FUNCS(writev) +sendfile="0" +AC_CHECK_LIB(sendfile, sendfilev) +AC_CHECK_FUNCS(sendfile send_file sendfilev, [ sendfile="1" ]) +AC_CHECK_FUNCS(utime utimes) + +dnl THIS MUST COME AFTER THE THREAD TESTS - FreeBSD doesn't always have a +dnl threaded poll() and we don't want to use sendfile on early FreeBSD +dnl systems if we are also using threads. + +AC_ARG_WITH(sendfile, [ --with-sendfile Override decision to use sendfile], + [ if test "$withval" = "yes"; then + sendfile="1" + else + sendfile="0" + fi ], [ + orig_sendfile=$sendfile + case $host in + *freebsd*) + # FreeBSD < 4.2 has issues with threads+sendfile + if test $os_version -le "401999"; then + if test "$threads" = "1"; then + sendfile="0" + fi + fi + ;; + *alpha*-dec-osf* ) + sendfile="0" + ;; + s390-*-linux-gnu) + # disable sendfile support for 2.2 on S/390 + if test $os_version -lt 240; then + sendfile="0" + fi + ;; + *aix*) + # compiler-independent check for 64-bit build + AC_CHECK_SIZEOF(void*, 4) + if test "x$ac_cv_sizeof_voidp" = "x8"; then + # sendfile not working for 64-bit build + sendfile="0" + fi + ;; + *darwin*) + # darwin semantics in 9.0.0 appear to be fubar + sendfile="0" + ;; + esac + if test "$orig_sendfile" != "$sendfile"; then + echo "sendfile support disabled to avoid system problem" + fi ] ) +AC_SUBST(sendfile) + +AC_CHECK_FUNCS(sigaction, [ have_sigaction="1" ], [ have_sigaction="0" ]) +AC_DECL_SYS_SIGLIST + +AC_CHECK_FUNCS(fork, [ fork="1" ], [ fork="0" ]) +APR_CHECK_INET_ADDR +APR_CHECK_INET_NETWORK +AC_SUBST(apr_inaddr_none) +AC_CHECK_FUNC(_getch) +AC_CHECK_FUNCS(strerror_r, [ strerror_r="1" ], [ strerror_r="0" ]) +if test "$strerror_r" = "1"; then + APR_CHECK_STRERROR_R_RC +fi +AC_CHECK_FUNCS(crypt_r, [ crypt_r="1" ], [ crypt_r="0" ]) +if test "$crypt_r" = "1"; then + APR_CHECK_CRYPT_R_STYLE +fi +AC_CHECK_FUNCS(mmap, [ mmap="1" ], [ mmap="0" ]) +if test "$native_mmap_emul" = "1"; then + mmap="1" +fi +AC_CHECK_FUNCS(memmove, [ have_memmove="1" ], [have_memmove="0" ]) +AC_CHECK_FUNCS([getpass getpassphrase gmtime_r localtime_r hstrerror mkstemp]) + +AC_SUBST(fork) +AC_SUBST(have_inet_addr) +AC_SUBST(tcp_nodelay_inherited) +AC_SUBST(o_nonblock_inherited) +AC_SUBST(have_inet_network) +AC_SUBST(have_sigaction) +AC_SUBST(have_setrlimit) +AC_SUBST(have_getrlimit) +AC_SUBST(mmap) +AC_SUBST(have_memmove) + +APR_CHECK_SIGWAIT_ONE_ARG +APR_CHECK_DIRENT_INODE +APR_CHECK_DIRENT_TYPE + +dnl ----------------------------- Checks for Any required Headers +AC_HEADER_STDC + +APR_FLAG_HEADERS( + alloca.h \ + ByteOrder.h \ + conio.h \ + crypt.h \ + ctype.h \ + dir.h \ + dirent.h \ + dl.h \ + dlfcn.h \ + errno.h \ + fcntl.h \ + grp.h \ + io.h \ + limits.h \ + mach-o/dyld.h \ + malloc.h \ + memory.h \ + netdb.h \ + osreldate.h \ + poll.h \ + process.h \ + pwd.h \ + semaphore.h \ + signal.h \ + stdarg.h \ + stddef.h \ + stdio.h \ + stdlib.h \ + string.h \ + strings.h \ + sysapi.h \ + sysgtime.h \ + termios.h \ + time.h \ + tpfeq.h \ + tpfio.h \ + unistd.h \ + unix.h \ + arpa/inet.h \ + kernel/OS.h \ + net/errno.h \ + netinet/in.h \ + netinet/sctp.h \ + netinet/sctp_uio.h \ + sys/file.h \ + sys/ioctl.h \ + sys/mman.h \ + sys/poll.h \ + sys/resource.h \ + sys/select.h \ + sys/sem.h \ + sys/sendfile.h \ + sys/signal.h \ + sys/socket.h \ + sys/sockio.h \ + sys/stat.h \ + sys/sysctl.h \ + sys/syslimits.h \ + sys/time.h \ + sys/types.h \ + sys/uio.h \ + sys/un.h \ + sys/wait.h) + +# IRIX 6.5 has a problem in which prevents it from +# being included by itself. Check for manually, +# including another header file first. +AC_CACHE_CHECK([for netinet/tcp.h], [apr_cv_hdr_netinet_tcp_h], +[AC_TRY_CPP( +[#ifdef HAVE_NETINET_IN_H +#include +#endif +#include +], [apr_cv_hdr_netinet_tcp_h=yes], [apr_cv_hdr_netinet_tcp_h=no])]) +if test "$apr_cv_hdr_netinet_tcp_h" = "yes"; then + netinet_tcph=1 + AC_DEFINE([HAVE_NETINET_TCP_H], 1, [Defined if netinet/tcp.h is present]) +else + netinet_tcph=0 +fi + +AC_SUBST(arpa_ineth) +AC_SUBST(conioh) +AC_SUBST(ctypeh) +AC_SUBST(crypth) +AC_SUBST(errnoh) +AC_SUBST(direnth) +AC_SUBST(fcntlh) +AC_SUBST(ioh) +AC_SUBST(limitsh) +AC_SUBST(netdbh) +AC_SUBST(sys_syslimitsh) +AC_SUBST(netinet_inh) +AC_SUBST(netinet_sctph) +AC_SUBST(netinet_sctp_uioh) +AC_SUBST(netinet_tcph) +AC_SUBST(stdargh) +AC_SUBST(stdioh) +AC_SUBST(stdlibh) +AC_SUBST(stringh) +AC_SUBST(stringsh) +AC_SUBST(sys_ioctlh) +AC_SUBST(sys_sendfileh) +AC_SUBST(sys_signalh) +AC_SUBST(sys_socketh) +AC_SUBST(sys_sockioh) +AC_SUBST(sys_typesh) +AC_SUBST(sys_timeh) +AC_SUBST(sys_uioh) +AC_SUBST(sys_unh) +AC_SUBST(timeh) +AC_SUBST(unistdh) +AC_SUBST(signalh) +AC_SUBST(sys_waith) +AC_SUBST(pthreadh) +AC_SUBST(semaphoreh) + +# Checking for h_errno in +if test "$netdbh" = "1"; then + APR_CHECK_H_ERRNO_FLAG + if test "$ac_cv_h_errno_cflags" = "no"; then + AC_MSG_ERROR([can not find h_errno in netdb.h]) + fi +fi + +dnl ----------------------------- Checks for standard typedefs +AC_TYPE_OFF_T +AC_TYPE_PID_T +AC_TYPE_SIZE_T +AC_TYPE_UID_T +AC_CHECK_TYPE(ssize_t, int) +AC_C_INLINE +AC_C_CONST +AC_TYPE_SIZE_T +AC_FUNC_SETPGRP + +APR_CHECK_SOCKLEN_T + +APR_INADDR_NONE + +dnl Checks for pointer size +AC_CHECK_SIZEOF(void*, 4) + +if test "x$ac_cv_sizeof_voidp" != "x"; then + voidp_size=$ac_cv_sizeof_voidp +else + AC_ERROR([Cannot determine size of void*]) +fi + +dnl Checks for integer size +AC_CHECK_SIZEOF(char, 1) +AC_CHECK_SIZEOF(int, 4) +AC_CHECK_SIZEOF(long, 4) +AC_CHECK_SIZEOF(short, 2) +AC_CHECK_SIZEOF(long double, 12) +AC_CHECK_SIZEOF(long long, 8) + +if test "$ac_cv_sizeof_short" = "2"; then + short_value=short +fi +if test "$ac_cv_sizeof_int" = "4"; then + int_value=int +fi +# Now we need to find what apr_int64_t (sizeof == 8) will be. +# The first match is our preference. +if test "$ac_cv_sizeof_int" = "8"; then + int64_literal='#define APR_INT64_C(val) (val)' + int64_t_fmt='#define APR_INT64_T_FMT "d"' + int64_t_fmt_len='#define APR_INT64_T_FMT_LEN 1' + uint64_t_fmt='#define APR_UINT64_T_FMT "u"' + uint64_t_fmt_len='#define APR_UINT64_T_FMT_LEN 1' + uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"' + int64_value="int" + long_value=int + int64_strfn="strtoi" +elif test "$ac_cv_sizeof_long" = "8"; then + int64_literal='#define APR_INT64_C(val) (val##L)' + int64_t_fmt='#define APR_INT64_T_FMT "ld"' + int64_t_fmt_len='#define APR_INT64_T_FMT_LEN 2' + uint64_t_fmt='#define APR_UINT64_T_FMT "lu"' + uint64_t_fmt_len='#define APR_UINT64_T_FMT_LEN 2' + uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"' + int64_value="long" + long_value=long + int64_strfn="strtol" +elif test "$ac_cv_sizeof_long_long" = "8"; then + int64_literal='#define APR_INT64_C(val) (val##LL)' + # Linux, Solaris, FreeBSD all support ll with printf. + # BSD 4.4 originated 'q'. Solaris is more popular and + # doesn't support 'q'. Solaris wins. Exceptions can + # go to the OS-dependent section. + int64_t_fmt='#define APR_INT64_T_FMT "lld"' + int64_t_fmt_len='#define APR_INT64_T_FMT_LEN 3' + uint64_t_fmt='#define APR_UINT64_T_FMT "llu"' + uint64_t_fmt_len='#define APR_UINT64_T_FMT_LEN 3' + uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"' + int64_value="long long" + long_value="long long" + int64_strfn="strtoll" +elif test "$ac_cv_sizeof_long_double" = "8"; then + int64_literal='#define APR_INT64_C(val) (val##LD)' + int64_t_fmt='#define APR_INT64_T_FMT "Ld"' + int64_t_fmt_len='#define APR_INT64_T_FMT_LEN 2' + uint64_t_fmt='#define APR_UINT64_T_FMT "Lu"' + uint64_t_fmt_len='#define APR_UINT64_T_FMT_LEN 2' + uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "Lx"' + int64_value="long double" + long_value="long double" + int64_strfn="strtoll" +elif test "$ac_cv_sizeof_longlong" = "8"; then + int64_literal='#define APR_INT64_C(val) (val##LL)' + int64_t_fmt='#define APR_INT64_T_FMT "qd"' + int64_t_fmt_len='#define APR_INT64_T_FMT_LEN 2' + uint64_t_fmt='#define APR_UINT64_T_FMT "qu"' + uint64_t_fmt_len='#define APR_UINT64_T_FMT_LEN 2' + uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"' + int64_value="__int64" + long_value="__int64" + int64_strfn="strtoll" +else + # int64_literal may be overriden if your compiler thinks you have + # a 64-bit value but APR does not agree. + int64_literal='#error Can not determine the proper size for apr_int64_t' + int64_t_fmt='#error Can not determine the proper size for apr_int64_t' + int64_t_fmt_len='#error Can not determine the proper size for apr_int64_t' + uint64_t_fmt='#error Can not determine the proper size for apr_int64_t' + uint64_t_fmt_len='#error Can not determine the proper size for apr_int64_t' + uint64_t_hex_fmt='#error Can not determine the proper size for apr_uint64_t' +fi + +# If present, allow the C99 macro INT64_C to override our conversion. +# +# HP-UX's ANSI C compiler provides this without any includes, so we +# will first look for INT64_C without adding stdint.h +AC_CACHE_CHECK([for INT64_C], [apr_cv_define_INT64_C], [ +AC_EGREP_CPP(YES_IS_DEFINED, +[#ifdef INT64_C +YES_IS_DEFINED +#endif], [apr_cv_define_INT64_C=yes], [ + # Now check for INT64_C in stdint.h + AC_EGREP_CPP(YES_IS_DEFINED, [#include +#ifdef INT64_C +YES_IS_DEFINED +#endif], [apr_cv_define_INT64_C=yes], [apr_cv_define_INT64_C=no])])]) + +if test "$apr_cv_define_INT64_C" = "yes"; then + int64_literal='#define APR_INT64_C(val) INT64_C(val)' + stdint=1 +else + stdint=0 +fi + +if test "$ac_cv_type_size_t" = "yes"; then + size_t_value="size_t" +else + size_t_value="apr_int32_t" +fi +if test "$ac_cv_type_ssize_t" = "yes"; then + ssize_t_value="ssize_t" +else + ssize_t_value="apr_int32_t" +fi +if test "$ac_cv_socklen_t" = "yes"; then + socklen_t_value="socklen_t" + case $host in + *-hp-hpux*) + if test "$ac_cv_sizeof_long" = "8"; then + # 64-bit HP-UX requires 32-bit socklens in + # kernel, but user-space declarations say + # 64-bit (socklen_t == size_t == long). + # This will result in many compile warnings, + # but we're functionally busted otherwise. + socklen_t_value="int" + fi + ;; + esac +else + socklen_t_value="int" +fi + +APR_CHECK_SIZEOF_EXTENDED([#include ], ssize_t, 8) + +if test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then + ssize_t_fmt='#define APR_SSIZE_T_FMT "d"' +elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then + ssize_t_fmt='#define APR_SSIZE_T_FMT "ld"' +else + ssize_t_fmt='#error Can not determine the proper size for ssize_t' +fi + +APR_CHECK_SIZEOF_EXTENDED([#include ], size_t, 8) + +if test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then + size_t_fmt='#define APR_SIZE_T_FMT "d"' +elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then + size_t_fmt='#define APR_SIZE_T_FMT "ld"' +else + size_t_fmt='#error Can not determine the proper size for size_t' +fi + +if test "$ac_cv_type_off_t" = "yes"; then + APR_CHECK_SIZEOF_EXTENDED([#include ], off_t, 8) + AC_MSG_CHECKING([which type to use for apr_off_t]) + if test "${ac_cv_sizeof_off_t}${ac_cv_sizeof_long}" = "44"; then + # Special case: off_t may change size with _FILE_OFFSET_BITS + # on 32-bit systems with LFS support. To avoid compatibility + # issues when other packages do define _FILE_OFFSET_BITS, + # hard-code apr_off_t to long. + off_t_value=long + off_t_fmt='#define APR_OFF_T_FMT "ld"' + else + off_t_value=off_t + # off_t is more commonly a long than an int; prefer that case + # where int and long are the same size. + if test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long"; then + off_t_fmt='#define APR_OFF_T_FMT "ld"' + elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_int"; then + off_t_fmt='#define APR_OFF_T_FMT "d"' + elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long_long"; then + off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT' + else + AC_ERROR([could not determine the size of off_t]) + fi + fi + AC_MSG_RESULT([$off_t_value]) + + dnl define apr_ino_t in a manner independent of _FILE_OFFSET_BITS setting + dnl default fallback + ino_t_value=ino_t + APR_CHECK_TYPES_COMPATIBLE(ino_t, unsigned long long, ino_t_value="unsigned long long") + APR_CHECK_TYPES_COMPATIBLE(ino_t, unsigned long, ino_t_value="unsigned long") + APR_CHECK_TYPES_COMPATIBLE(ino_t, unsigned int, ino_t_value="unsigned int") + +else + off_t_value='apr_int32_t' + off_t_fmt='#define APR_OFF_T_FMT "d"' +fi + +APR_CHECK_SIZEOF_EXTENDED([#include ], pid_t, 8) + +if test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_short"; then + pid_t_fmt='#define APR_PID_T_FMT "hd"' +elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_int"; then + pid_t_fmt='#define APR_PID_T_FMT "d"' +elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long"; then + pid_t_fmt='#define APR_PID_T_FMT "ld"' +elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long_long"; then + pid_t_fmt='#define APR_PID_T_FMT APR_INT64_T_FMT' +else + pid_t_fmt='#error Can not determine the proper size for pid_t' +fi + +# Basically, we have tried to figure out the correct format strings +# for APR types which vary between platforms, but we don't always get +# it right. If you find that we don't get it right for your platform, +# you can override our decision below. +case $host in + *linux*) + case $host in + s390*) + size_t_fmt='#define APR_SIZE_T_FMT "ld"' + ;; + esac + ;; + *os2_emx) + size_t_fmt='#define APR_SIZE_T_FMT "lu"' + ;; + *-solaris*) + pid_t_fmt='#define APR_PID_T_FMT "ld"' + ;; + *aix4*|*aix5*) + ssize_t_fmt='#define APR_SSIZE_T_FMT "ld"' + size_t_fmt='#define APR_SIZE_T_FMT "lu"' + ;; + *beos*) + ssize_t_fmt='#define APR_SSIZE_T_FMT "ld"' + size_t_fmt='#define APR_SIZE_T_FMT "ld"' + ;; + *apple-darwin*) + osver=`uname -r` + case $osver in + [[0-7]].*) + ssize_t_fmt='#define APR_SSIZE_T_FMT "d"' + ;; + *) + ssize_t_fmt='#define APR_SSIZE_T_FMT "ld"' + ;; + esac + size_t_fmt='#define APR_SIZE_T_FMT "lu"' + ;; +esac + +AC_SUBST(voidp_size) +AC_SUBST(short_value) +AC_SUBST(int_value) +AC_SUBST(long_value) +AC_SUBST(int64_value) +AC_SUBST(off_t_value) +AC_SUBST(size_t_value) +AC_SUBST(ssize_t_value) +AC_SUBST(socklen_t_value) +AC_SUBST(int64_t_fmt) +AC_SUBST(int64_t_fmt_len) +AC_SUBST(uint64_t_fmt) +AC_SUBST(uint64_t_fmt_len) +AC_SUBST(uint64_t_hex_fmt) +AC_SUBST(ssize_t_fmt) +AC_SUBST(size_t_fmt) +AC_SUBST(off_t_fmt) +AC_SUBST(pid_t_fmt) +AC_SUBST(int64_literal) +AC_SUBST(stdint) +AC_SUBST(ino_t_value) + +dnl ----------------------------- Checking for string functions +AC_CHECK_FUNCS(strnicmp, have_strnicmp="1", have_strnicmp="0") +AC_CHECK_FUNCS(strncasecmp, have_strncasecmp="1", have_strncasecmp="0") +AC_CHECK_FUNCS(stricmp, have_stricmp="1", have_stricmp="0") +AC_CHECK_FUNCS(strcasecmp, have_strcasecmp="1", have_strcasecmp="0") +AC_CHECK_FUNCS(strdup, have_strdup="1", have_strdup="0") +AC_CHECK_FUNCS(strstr, have_strstr="1", have_strstr="0") +AC_CHECK_FUNCS(memchr, have_memchr="1", have_memchr="0") +AC_CHECK_FUNCS($int64_strfn, have_int64_strfn="1", have_int64_strfn="0") + +dnl ----------------------------- We have a fallback position +if test "$have_int64_strfn" = "0" && test "$int64_strfn" = "strtoll"; then + int64_strfn="strtoq" + AC_CHECK_FUNCS($int64_strfn, have_int64_strfn="1", have_int64_strfn="0") +fi + +AC_SUBST(have_strnicmp) +AC_SUBST(have_strncasecmp) +AC_SUBST(have_stricmp) +AC_SUBST(have_strcasecmp) +AC_SUBST(have_strdup) +AC_SUBST(have_strstr) +AC_SUBST(have_memchr) +AC_SUBST(have_int64_strfn) +AC_SUBST(int64_strfn) + +dnl ----------------------------- Checking for DSO support +echo "${nl}Checking for DSO..." +AC_ARG_ENABLE(dso, + [ --disable-dso Disable DSO support ], + [ tempdso=$enableval], + [ + AC_CHECK_FUNCS(NSLinkModule, [ tempdso="dyld" ], [ tempdso="no" ]) + if test "$tempdso" = "no"; then + AC_CHECK_LIB(dld, shl_load, [ tempdso="shl" APR_ADDTO(LIBS,-ldld) ], + tempdso="no") + fi + if test "$tempdso" = "no"; then + AC_CHECK_FUNCS(dlopen, [ tempdso="dlfcn" ], [ tempdso="no" ]) + fi + if test "$tempdso" = "no"; then + AC_CHECK_LIB(dl, dlopen, [ tempdso="dlfcn" APR_ADDTO(LIBS,-ldl) ], + tempdso="no") + fi + if test "$tempdso" = "dlfcn"; then + # ReliantUnix has dlopen() in libc but dlsym() in libdl :( + AC_CHECK_FUNCS(dlsym, [ tempdso="dlfcn" ], [ tempdso="no" ]) + if test "$tempdso" = "no"; then + AC_CHECK_LIB(dl, dlsym, [ tempdso="dlfcn" APR_ADDTO(LIBS, -ldl) ], + tempdso="no") + fi + if test "$tempdso" = "no"; then + echo "Weird: dlopen() was found but dlsym() was not found!" + fi + fi + if test "$tempdso" = "no"; then + AC_CHECK_LIB(root, load_image, tempdso="yes", tempdso="no") + fi + if test "$tempdso" = "no"; then + case $host in + *os390|*-os2*|*os400) + tempdso="yes" + ;; + esac + fi + ] ) + +if test "$tempdso" = "no"; then + aprdso="0" +else + case "$tempdso" in + dlfcn) AC_DEFINE(DSO_USE_DLFCN, 1, [Define if DSO support uses dlfcn.h]);; + shl) AC_DEFINE(DSO_USE_SHL, 1, [Define if DSO support uses shl_load]);; + dyld) AC_DEFINE(DSO_USE_DYLD, 1, [Define if DSO support uses dyld.h]);; + esac + aprdso="1" + apr_modules="$apr_modules dso" +fi + +AC_SUBST(aprdso) + +dnl ----------------------------- Checking for Processes +echo "${nl}Checking for Processes..." + +AC_CHECK_FUNCS(waitpid) + +AC_ARG_ENABLE(other-child, + [ --enable-other-child Enable reliable child processes ], + [ if test "$enableval" = "yes"; then + oc="1" + else + oc="0" + fi ], + [ oc=1 ] ) + +AC_SUBST(oc) + +AC_MSG_CHECKING(for Variable Length Arrays) +APR_TRY_COMPILE_NO_WARNING([], +[ + int foo[argc]; + foo[0] = 0; +], vla_msg=yes, vla_msg=no ) +AC_MSG_RESULT([$vla_msg]) +if test "$vla_msg" = "yes"; then + AC_DEFINE(HAVE_VLA, 1, [Define if C compiler supports VLA]) +fi + +AC_CACHE_CHECK(struct rlimit,ac_cv_struct_rlimit,[ +AC_TRY_RUN([ +#include +#include +#include +main() +{ + struct rlimit limit; + limit.rlim_cur = 0; + limit.rlim_max = 0; + exit(0); +}], [ + ac_cv_struct_rlimit=yes ], [ + ac_cv_struct_rlimit=no ], [ + ac_cv_struct_rlimit=no ] ) ] ) +struct_rlimit=0 +test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1 +AC_SUBST(struct_rlimit) + +dnl ----------------------------- Checking for Locking Characteristics +echo "${nl}Checking for Locking..." + +AC_CHECK_FUNCS(semget semctl flock) +AC_CHECK_HEADERS(semaphore.h) +AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait) + +# Some systems return ENOSYS from sem_open. +AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[ +AC_TRY_RUN([ +#include +#include +#include +#include +main() +{ + sem_t *psem; + const char *sem_name = "/apr_autoconf"; + + if (sizeof(int) < sizeof(sem_t *)) + exit(1); + psem = sem_open(sem_name, O_CREAT, 0644, 1); + if (psem == (sem_t *)SEM_FAILED) { + exit(1); + } + sem_close(psem); + sem_unlink(sem_name); + exit(0); +}], [ac_cv_func_sem_open=yes], [ac_cv_func_sem_open=no], +[ac_cv_func_sem_open=no])]) + +# It's stupid, but not all platforms have union semun, even those that need it. +AC_MSG_CHECKING(for union semun in sys/sem.h) +AC_TRY_COMPILE([ +#include +#include +#include +],[ +union semun arg; +semctl(0, 0, 0, arg); +], [have_union_semun="1" union_semun=yes ] +msg=yes, [ +have_union_semun="0" +msg=no ] ) +AC_MSG_RESULT([$msg]) +AC_SUBST(have_union_semun) + +dnl Checks for libraries. +APR_CHECK_DEFINE(LOCK_EX, sys/file.h) +APR_CHECK_DEFINE(F_SETLK, fcntl.h) +APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h) + +# We are assuming that if the platform doesn't have POLLIN, it doesn't have +# any POLL definitions. +APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h) + +if test "$threads" = "1"; then + APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h) + AC_CHECK_FUNCS(pthread_mutexattr_setpshared) + # Some systems have setpshared and define PROCESS_SHARED, but don't + # really support PROCESS_SHARED locks. So, we must validate that we + # can go through the steps without receiving some sort of system error. + # Linux and older versions of AIX have this problem. + APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mutexattr_setpshared, [ + AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_works, [ + AC_TRY_RUN([ +#include +#include + int main() + { + pthread_mutex_t mutex; + pthread_mutexattr_t attr; + if (pthread_mutexattr_init(&attr)) + exit(1); + if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)) + exit(2); + if (pthread_mutex_init(&mutex, &attr)) + exit(3); + if (pthread_mutexattr_destroy(&attr)) + exit(4); + if (pthread_mutex_destroy(&mutex)) + exit(5); + exit(0); + }], [apr_cv_process_shared_works=yes], [apr_cv_process_shared_works=no])]) + # Override detection of pthread_mutexattr_setpshared + ac_cv_func_pthread_mutexattr_setpshared=$apr_cv_process_shared_works]) + + if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then + APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX + fi +fi + +# See which lock mechanisms we can support on this system. +APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl + func:sem_unlink func:sem_post func:sem_wait, + hasposixser="1", hasposixser="0") +APR_IFALLYES(func:semget func:semctl define:SEM_UNDO, hassysvser="1", + hassysvser="0") +APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0") +APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0") +# note: the current APR use of shared mutex requires /dev/zero +APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl + func:pthread_mutexattr_setpshared dnl + file:/dev/zero, + hasprocpthreadser="1", hasprocpthreadser="0") +APR_IFALLYES(struct:pthread_rw, hasrwlockser="1", hasrwlockser="0") + +# See which lock mechanism we'll select by default on this system. +# The last APR_DECIDE to execute sets the default. +# At this stage, we match the ordering in Apache 1.3 +# which is (highest to lowest): sysvsem -> fcntl -> flock. +# POSIX semaphores and cross-process pthread mutexes are not +# used by default since they have less desirable behaviour when +# e.g. a process holding the mutex segfaults. +APR_BEGIN_DECISION([apr_lock implementation method]) +APR_IFALLYES(func:flock define:LOCK_EX, + APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()])) +APR_IFALLYES(header:fcntl.h define:F_SETLK, + APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()])) +APR_IFALLYES(func:semget func:semctl define:SEM_UNDO, + APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()])) +if test "x$apr_lock_method" != "x"; then + APR_DECISION_FORCE($apr_lock_method) +fi +APR_END_DECISION +AC_DEFINE_UNQUOTED($ac_decision) + +flockser="0" +sysvser="0" +posixser="0" +procpthreadser="0" +fcntlser="0" +case $ac_decision in + USE_FLOCK_SERIALIZE ) + flockser="1" + ;; + USE_FCNTL_SERIALIZE ) + fcntlser="1" + ;; + USE_SYSVSEM_SERIALIZE ) + sysvser="1" + ;; + USE_POSIXSEM_SERIALIZE ) + posixser="1" + ;; + USE_PROC_PTHREAD_SERIALIZE ) + procpthreadser="1" + ;; +esac + +AC_SUBST(hasflockser) +AC_SUBST(hassysvser) +AC_SUBST(hasposixser) +AC_SUBST(hasfcntlser) +AC_SUBST(hasprocpthreadser) +AC_SUBST(hasrwlockser) +AC_SUBST(flockser) +AC_SUBST(sysvser) +AC_SUBST(posixser) +AC_SUBST(fcntlser) +AC_SUBST(procpthreadser) +AC_SUBST(pthreadser) + +AC_MSG_CHECKING(if all interprocess locks affect threads) +if test "x$apr_process_lock_is_global" = "xyes"; then + proclockglobal="1" + AC_MSG_RESULT(yes) +else + proclockglobal="0" + AC_MSG_RESULT(no) +fi + +AC_SUBST(proclockglobal) + +AC_MSG_CHECKING(if POSIX sems affect threads in the same process) +if test "x$apr_posixsem_is_global" = "xyes"; then + AC_DEFINE(POSIXSEM_IS_GLOBAL, 1, + [Define if POSIX semaphores affect threads within the process]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +AC_MSG_CHECKING(if SysV sems affect threads in the same process) +if test "x$apr_sysvsem_is_global" = "xyes"; then + AC_DEFINE(SYSVSEM_IS_GLOBAL, 1, + [Define if SysV semaphores affect threads within the process]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +AC_MSG_CHECKING(if fcntl locks affect threads in the same process) +if test "x$apr_fcntl_is_global" = "xyes"; then + AC_DEFINE(FCNTL_IS_GLOBAL, 1, + [Define if fcntl locks affect threads within the process]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +AC_MSG_CHECKING(if flock locks affect threads in the same process) +if test "x$apr_flock_is_global" = "xyes"; then + AC_DEFINE(FLOCK_IS_GLOBAL, 1, + [Define if flock locks affect threads within the process]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +dnl ----------------------------- Checking for /dev/random +AC_MSG_CHECKING(for entropy source) + +AC_ARG_WITH(egd, + [ --with-egd[[=DIR]] use EGD-compatible socket], + [ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported]) + if test "$withval" = "yes"; then + AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-pool","/etc/egd-pool","/etc/entropy"], + [Define to list of paths to EGD sockets]) + else + AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"]) + fi + AC_MSG_RESULT(EGD-compatible daemon) + rand="1" + ]) + +if test "$rand" != "1"; then + AC_ARG_WITH(devrandom, + [ --with-devrandom[[=DEV]] use /dev/random or compatible [[searches by default]]], + [ apr_devrandom="$withval" ], [ apr_devrandom="yes" ]) + + if test "$apr_devrandom" = "yes"; then + # /dev/random on OpenBSD doesn't provide random data, so + # prefer /dev/arandom, which does; see random(4). + for f in /dev/arandom /dev/random /dev/urandom; do + if test -r $f; then + apr_devrandom=$f + rand=1 + break + fi + done + elif test "$apr_devrandom" != "no"; then + if test -r "$apr_devrandom"; then + rand="1" + else + AC_ERROR([$apr_devrandom not found or unreadable.]) + fi + fi + + if test "$rand" = "1"; then + AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device]) + AC_MSG_RESULT([$apr_devrandom]) + fi +fi + +if test "$rand" != "1"; then + case $host in + # we have built in support for OS/2 + *-os2*) + AC_MSG_RESULT([Using OS/2 builtin random]) + rand="1" + ;; + *) + if test "$rand" != "1"; then + if test "$ac_cv_lib_truerand_main" = "yes"; then + AC_DEFINE(HAVE_TRUERAND, 1, [Define if truerand is supported]) + AC_MSG_RESULT(truerand) + rand="1" + else + AC_MSG_RESULT(not found) + rand="0" + fi + fi + ;; + esac +fi + +AC_SUBST(rand) +dnl ----------------------------- Checking for Time Support +echo "${nl}Checking for Time Support..." +AC_CACHE_CHECK([for tm_gmtoff in struct tm], ac_cv_struct_tm_gmtoff, +[AC_TRY_COMPILE([#include +#include ], [struct tm tm; tm.tm_gmtoff;], + ac_cv_struct_tm_gmtoff=yes, ac_cv_struct_tm_gmtoff=no)]) + +if test "$ac_cv_struct_tm_gmtoff" = "yes"; then + AC_DEFINE(HAVE_GMTOFF, 1, [Define if struct tm has a tm_gmtoff field]) +fi + +dnl ----------------------------- Checking for Networking Support +echo "${nl}Checking for Networking support..." +AC_MSG_CHECKING(for in_addr in netinet/in.h) +AC_TRY_COMPILE([ +#include +#include +],[ +struct in_addr arg; +arg.s_addr = htonl(INADDR_ANY); +], [ have_in_addr="1" +msg=yes ] , [ have_in_addr="0" +msg=no ]) +AC_MSG_RESULT([$msg]) + +AC_MSG_CHECKING([if fd == socket on this platform]) +if test "x$file_as_socket" != "x0" ; then + file_as_socket="1"; + echo "yes" +else + echo "no" +fi + +AC_SUBST(have_in_addr) +AC_SUBST(file_as_socket) + +# Check the types only if we have gethostbyname_r +if test "$ac_cv_func_gethostbyname_r" = "yes"; then + APR_CHECK_GETHOSTBYNAME_R_STYLE +fi + +APR_CHECK_TCP_NODELAY_INHERITED +APR_CHECK_O_NONBLOCK_INHERITED + +# Look for a way of corking TCP... +APR_CHECK_DEFINE(TCP_CORK, netinet/tcp.h) +APR_CHECK_DEFINE(TCP_NOPUSH, netinet/tcp.h) +apr_tcp_nopush_flag="0" +have_corkable_tcp="0" +if test "x$ac_cv_define_TCP_CORK" = "xyes"; then + apr_tcp_nopush_flag="TCP_CORK" + have_corkable_tcp="1" +else + case $host in + *linux*) + AC_EGREP_CPP(yes,[ +#include +#ifdef TCP_CORK +yes +#endif + ],[ + apr_tcp_nopush_flag="3" + have_corkable_tcp="1" + ]) + ;; + *) + ;; + esac +fi +if test "x$ac_cv_define_TCP_NOPUSH" = "xyes"; then + apr_tcp_nopush_flag="TCP_NOPUSH" + have_corkable_tcp="1" +fi + +APR_CHECK_DEFINE(SO_ACCEPTFILTER, sys/socket.h) +if test "x$ac_cv_define_SO_ACCEPTFILTER" = "xyes"; then + acceptfilter="1" +else + acceptfilter="0" +fi + +APR_CHECK_SCTP + +AC_SUBST(apr_tcp_nopush_flag) +AC_SUBST(have_corkable_tcp) +AC_SUBST(acceptfilter) +AC_SUBST(have_sctp) + +AC_CHECK_FUNCS(set_h_errno) +APR_CHECK_RESOLV_RETRANS + +echo "${nl}Checking for IPv6 Networking support..." +dnl Start of checking for IPv6 support... + +AC_ARG_ENABLE(ipv6, + [ --disable-ipv6 Disable IPv6 support in APR.], + [ if test "$enableval" = "no"; then + user_disabled_ipv6=1 + fi ], + [ user_disabled_ipv6=0 ] ) + +case $host in + *) + broken_ipv6=0 +esac + +AC_SEARCH_LIBS(getaddrinfo, socket inet6) +AC_SEARCH_LIBS(gai_strerror, socket inet6) +AC_SEARCH_LIBS(getnameinfo, socket inet6) +AC_CHECK_FUNCS(gai_strerror) +APR_CHECK_WORKING_GETADDRINFO +APR_CHECK_NEGATIVE_EAI +APR_CHECK_WORKING_GETNAMEINFO +APR_CHECK_SOCKADDR_IN6 + +have_ipv6="0" +if test "$user_disabled_ipv6" = 1; then + ipv6_result="no -- disabled by user" +else + if test "x$broken_ipv6" = "x0"; then + if test "x$have_sockaddr_in6" = "x1"; then + if test "x$ac_cv_working_getaddrinfo" = "xyes"; then + if test "x$ac_cv_working_getnameinfo" = "xyes"; then + have_ipv6="1" + ipv6_result="yes" + else + ipv6_result="no -- no getnameinfo" + fi + else + ipv6_result="no -- no working getaddrinfo" + fi + else + ipv6_result="no -- no sockaddr_in6" + fi + else + ipv6_result="no -- the platform has known problems supporting IPv6" + fi +fi + +AC_MSG_CHECKING(if APR supports IPv6) +AC_MSG_RESULT($ipv6_result) + +AC_SUBST(have_ipv6) + +dnl Check for langinfo support + +AC_CHECK_HEADERS(langinfo.h) +AC_CHECK_FUNCS(nl_langinfo) + +dnl Random late checks... + +# AC_CHECK_FUNCS is not sufficient since the function may be usable when +# struct stat64 is not exposed (e.g. HP-UX). Note that fstat64 only +# happens to be usable on Linux because -D_GNU_SOURCE is picked up +# by the earlier crypt_r check. +AC_CACHE_CHECK([for usable fstat64], [apr_cv_func_fstat64], + [AC_TRY_COMPILE([#include +#include +#include ], [struct stat64 st; fstat64(0, &st);], + [apr_cv_func_fstat64=yes], [apr_cv_func_fstat64=no])]) +if test $apr_cv_func_fstat64 = yes; then + AC_DEFINE(HAVE_FSTAT64, 1, [Define if fstat64 can be used]) +fi + + +dnl ----------------------------- Finalize the variables + +echo "${nl}Restore user-defined environment settings..." + +APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, EXTRA_) +APR_RESTORE_THE_ENVIRONMENT(CFLAGS, EXTRA_) +APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, EXTRA_) +APR_RESTORE_THE_ENVIRONMENT(LIBS, EXTRA_) +APR_RESTORE_THE_ENVIRONMENT(INCLUDES, EXTRA_) +AC_SUBST(NOTEST_CPPFLAGS) +AC_SUBST(NOTEST_CFLAGS) +AC_SUBST(NOTEST_LDFLAGS) +AC_SUBST(NOTEST_LIBS) +AC_SUBST(NOTEST_INCLUDES) + +dnl ----------------------------- Construct the files + +AC_SUBST(LDLIBS) +AC_SUBST(AR) +AC_SUBST(RM) +AC_SUBST(OSDIR) +AC_SUBST(DEFAULT_OSDIR) +AC_SUBST(EXEEXT) +AC_SUBST(LIBTOOL_LIBS) + +echo "${nl}Construct Makefiles and header files." +MAKEFILE1="Makefile strings/Makefile passwd/Makefile tables/Makefile build/Makefile" +SUBDIRS="strings passwd tables " +for dir in $apr_modules +do + test -d $dir || $MKDIR $dir + if test -f $srcdir/$dir/$OSDIR/Makefile.in; then + MAKEFILE2="$MAKEFILE2 $dir/$OSDIR/Makefile " + SUBDIRS="$SUBDIRS $dir/$OSDIR " + else + MAKEFILE2="$MAKEFILE2 $dir/$DEFAULT_OSDIR/Makefile " + SUBDIRS="$SUBDIRS $dir/$DEFAULT_OSDIR " + fi +done + +if test -d $srcdir/test; then + MAKEFILE3="test/Makefile test/internal/Makefile" +fi +AC_SUBST(SUBDIRS) + +# +# BSD/OS (BSDi) needs to use a different include syntax in the Makefiles +# +case $host in +*bsdi*) + # Check whether they've installed GNU make + if make --version > /dev/null 2>&1; then + INCLUDE_RULES="include $apr_buildout/apr_rules.mk" + else + # BSDi make + INCLUDE_RULES=".include \"$apr_buildout/apr_rules.mk\"" + fi + ;; +*) + INCLUDE_RULES="include $apr_buildout/apr_rules.mk" + ;; +esac +AC_SUBST(INCLUDE_RULES) + +SAVE_FILES="include/apr.h include/arch/unix/apr_private.h" + +for i in $SAVE_FILES; do + test -r $i && mv $i $i.save +done + +dir=include/arch/unix +test -d $dir || $MKDIR $dir + +AC_OUTPUT([ + $MAKEFILE1 $MAKEFILE2 $MAKEFILE3 + include/apr.h + build/apr_rules.mk + build/pkg/pkginfo + apr-config +],[ +for i in $SAVE_FILES; do + if cmp -s $i $i.save 2>/dev/null; then + mv $i.save $i + echo "$i is unchanged" + fi + rm -f $i.save +done +chmod +x apr-config +]) + +dnl ----------------------------- Fixup Makefiles for VPATH support + +changequote({,}) + +if test -n "$USE_VPATH"; then + for makefile in $MAKEFILE1 $MAKEFILE2 $MAKEFILE3; do + cat $makefile | \ + sed \ + -e 's#-I\($(INCDIR[0-9]*)\)#-I\1 -I$(srcdir)/\1#g' \ + -e 's#-I\($(OSDIR[0-9]*)\)#-I\1 -I$(srcdir)/\1#g' \ + -e 's#-I\($(DEFOSDIR[0-9]*)\)#-I\1 -I$(srcdir)/\1#g' \ + > tmp + cp tmp $makefile + done + rm -f tmp +fi + +changequote([,]) -- cgit 1.2.3-korg