Diff for /aclocal.m4 between versions 1.2 and 1.3

version 1.2, 1998/10/24 23:41:43 version 1.3, 1998/11/22 03:22:29
Line 1 Line 1
   dnl aclocal.m4 generated automatically by aclocal 1.3
   
   dnl Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
   dnl This Makefile.in is free software; the Free Software Foundation
   dnl gives unlimited permission to copy and/or distribute it,
   dnl with or without modifications, as long as this notice is preserved.
   
   dnl This program is distributed in the hope that it will be useful,
   dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
   dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
   dnl PARTICULAR PURPOSE.
   
 dnl  dnl
 dnl OpenLDAP Autoconf Macros  dnl OpenLDAP Autoconf Macros
 dnl  dnl
 dnl --------------------------------------------------------------------  builtin(include, build/openldap.m4)dnl
 dnl Restricted form of AC_ARG_ENABLE that limits user options  
 dnl  # Do all the work for Automake.  This macro actually does too much --
 dnl $1 = option name  # some checks are only needed if your package does certain things.
 dnl $2 = help-string  # But this isn't really a big deal.
 dnl $3 = default value  (auto)  
 dnl $4 = allowed values (auto yes no)  # serial 1
 AC_DEFUN([OL_ARG_ENABLE], [# OpenLDAP --enable-$1  
         AC_ARG_ENABLE($1,[$2 (]ifelse($3,,auto,$3)[)],[  dnl Usage:
         ol_arg=invalid  dnl AM_INIT_AUTOMAKE(package,version, [no-define])
         for ol_val in ifelse($4,,[auto yes no],[$4]) ; do  
                 if test "$enableval" = "$ol_val" ; then  AC_DEFUN(AM_INIT_AUTOMAKE,
                         ol_arg="$ol_val"  [AC_REQUIRE([AM_PROG_INSTALL])
                 fi  PACKAGE=[$1]
         done  AC_SUBST(PACKAGE)
         if test "$ol_arg" = "invalid" ; then  VERSION=[$2]
                 AC_MSG_ERROR(bad value $enableval for --enable-$1)  AC_SUBST(VERSION)
         fi  dnl test to see if srcdir already configured
         ol_enable_$1="$ol_arg"  if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 ],    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
 [       ol_enable_$1=ifelse($3,,"auto","$3")])dnl  fi
 dnl AC_VERBOSE(OpenLDAP -enable-$1 $ol_enable_$1)  ifelse([$3],,
 # end --enable-$1  AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE")
 ])dnl  AC_DEFINE_UNQUOTED(VERSION, "$VERSION"))
 dnl  AC_REQUIRE([AM_SANITY_CHECK])
 dnl --------------------------------------------------------------------  AC_REQUIRE([AC_ARG_PROGRAM])
 dnl Restricted form of AC_ARG_WITH that limits user options  dnl FIXME This is truly gross.
 dnl  missing_dir=`cd $ac_aux_dir && pwd`
 dnl $1 = option name  AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
 dnl $2 = help-string  AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
 dnl $3 = default value (no)  AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
 dnl $4 = allowed values (yes or no)  AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
 AC_DEFUN([OL_ARG_WITH], [# OpenLDAP --with-$1  AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
         AC_ARG_WITH($1,[$2 (]ifelse($3,,yes,$3)[)],[  AC_REQUIRE([AC_PROG_MAKE_SET])])
         ol_arg=invalid  
         for ol_val in ifelse($4,,[yes no],[$4]) ; do  
                 if test "$withval" = "$ol_val" ; then  # serial 1
                         ol_arg="$ol_val"  
                 fi  AC_DEFUN(AM_PROG_INSTALL,
         done  [AC_REQUIRE([AC_PROG_INSTALL])
         if test "$ol_arg" = "invalid" ; then  test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
                 AC_MSG_ERROR(bad value $withval for --with-$1)  AC_SUBST(INSTALL_SCRIPT)dnl
         fi  ])
         ol_with_$1="$ol_arg"  
 ],  #
 [       ol_with_$1=ifelse($3,,"no","$3")])dnl  # Check to make sure that the build environment is sane.
 dnl AC_VERBOSE(OpenLDAP --with-$1 $ol_with_$1)  #
 # end --with-$1  
 ])dnl  AC_DEFUN(AM_SANITY_CHECK,
 dnl  [AC_MSG_CHECKING([whether build environment is sane])
 dnl ====================================================================  # Just in case
 dnl Check if db.h is Berkeley DB2  sleep 1
 dnl  echo timestamp > conftestfile
 dnl defines ol_cv_header_db2 to 'yes' or 'no'  # Do `set' in a subshell so we don't clobber the current shell's
 dnl  # arguments.  Must try -L first in case configure is actually a
 dnl uses:  # symlink; some systems play weird games with the mod time of symlinks
 dnl             AC_CHECK_HEADERS(db.h)  # (eg FreeBSD returns the mod time of the symlink's containing
 dnl  # directory).
 AC_DEFUN([OL_HEADER_BERKELEY_DB2],  if (
 [AC_CHECK_HEADERS(db.h)     set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 if test $ac_cv_header_db_h = yes ; then     if test "[$]*" = "X"; then
         AC_CACHE_CHECK([if db.h is DB2], [ol_cv_header_db2],[        # -L didn't work.
                 AC_EGREP_CPP(__db_version_2,[        set X `ls -t $srcdir/configure conftestfile`
 #                       include <db.h>     fi
                         /* this check could be improved */     if test "[$]*" != "X $srcdir/configure conftestfile" \
 #                       ifdef DB_VERSION_MAJOR        && test "[$]*" != "X conftestfile $srcdir/configure"; then
 #                               if DB_VERSION_MAJOR == 2  
                                         __db_version_2        # If neither matched, then we have a broken ls.  This can happen
 #                               endif        # if, for instance, CONFIG_SHELL is bash and it inherits a
 #                       endif        # broken ls alias from the environment.  This has actually
                 ], ol_cv_header_db2=yes, ol_cv_header_db2=no)])        # happened.  Such a system could not be considered "sane".
         AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
   alias in your environment])
      fi
   
      test "[$]2" = conftestfile
      )
   then
      # Ok.
      :
 else  else
         ol_cv_header_db2=no     AC_MSG_ERROR([newly created file is older than distributed files!
   Check your system clock])
 fi  fi
 ])dnl  rm -f conftest*
 dnl --------------------------------------------------------------------  AC_MSG_RESULT(yes)])
 dnl Check if Berkeley DB2 library exists  
 dnl Check for dbopen in standard libraries or -ldb  dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
 dnl  dnl The program must properly implement --version.
 dnl defines ol_cv_lib_db2 to '-ldb' or 'no'  AC_DEFUN(AM_MISSING_PROG,
 dnl  [AC_MSG_CHECKING(for working $2)
 dnl uses:  # Run test in a subshell; some versions of sh will print an error if
 dnl             AC_CHECK_LIB(db,db_open)  # an executable is not found, even if stderr is redirected.
 dnl  # Redirect stdin to placate older versions of autoconf.  Sigh.
 AC_DEFUN([OL_LIB_BERKELEY_DB2],  if ($2 --version) < /dev/null > /dev/null 2>&1; then
 [AC_CACHE_CHECK([for DB2 library], [ol_cv_lib_db2],     $1=$2
 [       ol_LIBS="$LIBS"     AC_MSG_RESULT(found)
         AC_CHECK_LIB(db,db_open,[ol_cv_lib_db2=-ldb],[ol_cv_lib_db2=no])  else
         LIBS="$ol_LIBS"     $1="$3/missing $2"
      AC_MSG_RESULT(missing)
   fi
   AC_SUBST($1)])
   
   
   # serial 24 AM_PROG_LIBTOOL
   AC_DEFUN(AM_PROG_LIBTOOL,
   [AC_REQUIRE([AM_ENABLE_SHARED])dnl
   AC_REQUIRE([AM_ENABLE_STATIC])dnl
   AC_REQUIRE([AC_CANONICAL_HOST])dnl
   AC_REQUIRE([AC_PROG_RANLIB])dnl
   AC_REQUIRE([AC_PROG_CC])dnl
   AC_REQUIRE([AM_PROG_LD])dnl
   AC_REQUIRE([AM_PROG_NM])dnl
   AC_REQUIRE([AC_PROG_LN_S])dnl
   dnl
   # Always use our own libtool.
   LIBTOOL='$(SHELL) $(top_builddir)/libtool'
   AC_SUBST(LIBTOOL)dnl
   
   # Check for any special flags to pass to ltconfig.
   libtool_flags=
   test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
   test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
   test "$silent" = yes && libtool_flags="$libtool_flags --silent"
   test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
   test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
   
   # Some flags need to be propagated to the compiler or linker for good
   # libtool support.
   case "$host" in
   *-*-irix6*)
     # Find out which ABI we are using.
     echo '[#]line __oline__ "configure"' > conftest.$ac_ext
     if AC_TRY_EVAL(ac_compile); then
       case "`/usr/bin/file conftest.o`" in
       *32-bit*)
         LD="${LD-ld} -32"
         ;;
       *N32*)
         LD="${LD-ld} -n32"
         ;;
       *64-bit*)
         LD="${LD-ld} -64"
         ;;
       esac
     fi
     rm -rf conftest*
     ;;
   
   *-*-sco3.2v5*)
     # On SCO OpenServer 5, we need -belf to get full-featured binaries.
     CFLAGS="$CFLAGS -belf"
     ;;
   esac
   
   # Actually configure libtool.  ac_aux_dir is where install-sh is found.
   CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
   LD="$LD" NM="$NM" RANLIB="$RANLIB" LN_S="$LN_S" \
   ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig \
   $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
   || AC_MSG_ERROR([libtool configure failed])
   ])
   
   # AM_ENABLE_SHARED - implement the --enable-shared flag
   # Usage: AM_ENABLE_SHARED[(DEFAULT)]
   #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to
   #   `yes'.
   AC_DEFUN(AM_ENABLE_SHARED,
   [define([AM_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
   AC_ARG_ENABLE(shared,
   changequote(<<, >>)dnl
   <<  --enable-shared         build shared libraries [default=>>AM_ENABLE_SHARED_DEFAULT]
   changequote([, ])dnl
   [  --enable-shared=PKGS    only build shared libraries if the current package
                             appears as an element in the PKGS list],
   [p=${PACKAGE-default}
   case "$enableval" in
   yes) enable_shared=yes ;;
   no) enable_shared=no ;;
   *)
     enable_shared=no
     # Look at the argument we got.  We use all the common list separators.
     IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
     for pkg in $enableval; do
       if test "X$pkg" = "X$p"; then
         enable_shared=yes
       fi
     done
     IFS="$ac_save_ifs"
     ;;
   esac],
   enable_shared=AM_ENABLE_SHARED_DEFAULT)dnl
   ])
   
   # AM_DISABLE_SHARED - set the default shared flag to --disable-shared
   AC_DEFUN(AM_DISABLE_SHARED,
   [AM_ENABLE_SHARED(no)])
   
   # AM_DISABLE_STATIC - set the default static flag to --disable-static
   AC_DEFUN(AM_DISABLE_STATIC,
   [AM_ENABLE_STATIC(no)])
   
   # AM_ENABLE_STATIC - implement the --enable-static flag
   # Usage: AM_ENABLE_STATIC[(DEFAULT)]
   #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to
   #   `yes'.
   AC_DEFUN(AM_ENABLE_STATIC,
   [define([AM_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl
   AC_ARG_ENABLE(static,
   changequote(<<, >>)dnl
   <<  --enable-static         build static libraries [default=>>AM_ENABLE_STATIC_DEFAULT]
   changequote([, ])dnl
   [  --enable-static=PKGS    only build shared libraries if the current package
                             appears as an element in the PKGS list],
   [p=${PACKAGE-default}
   case "$enableval" in
   yes) enable_static=yes ;;
   no) enable_static=no ;;
   *)
     enable_static=no
     # Look at the argument we got.  We use all the common list separators.
     IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
     for pkg in $enableval; do
       if test "X$pkg" = "X$p"; then
         enable_static=yes
       fi
     done
     IFS="$ac_save_ifs"
     ;;
   esac],
   enable_static=AM_ENABLE_STATIC_DEFAULT)dnl
 ])  ])
 ])dnl  
 dnl  
 dnl --------------------------------------------------------------------  
 dnl Check if Berkeley db2 exists  
 dnl  
 dnl defines ol_cv_berkeley_db2 to 'yes' or 'no'  
 dnl   
 dnl uses:  
 dnl             OL_LIB_BERKELEY_DB2  
 dnl             OL_HEADER_BERKELEY_DB2  
 dnl  
 AC_DEFUN([OL_BERKELEY_DB2],  
 [AC_REQUIRE([OL_LIB_BERKELEY_DB2])  
  AC_REQUIRE([OL_HEADER_BERKELEY_DB2])  
  AC_CACHE_CHECK([for Berkeley DB2], [ol_cv_berkeley_db2], [  
         if test $ol_cv_lib_db2 = no -o $ol_cv_header_db2 = no ; then  
                 ol_cv_berkeley_db2=no  
         else  
                 ol_cv_berkeley_db2=yes  
         fi  
 ])  
  if test $ol_cv_berkeley_db2 = yes ; then  
         AC_DEFINE(HAVE_BERKELEY_DB2,1)  
  fi  
 ])dnl  
 dnl  
 dnl ====================================================================  
 dnl Check for db.h/db_185.h is Berkeley DB  
 dnl  
 dnl defines ol_cv_header_db to 'yes' or 'no'  
 dnl  
 dnl uses:  
 dnl             OL_HEADER_BERKELEY_DB2  
 dnl             AC_CHECK_HEADERS(db_185.h)  
 dnl  
 AC_DEFUN([OL_HEADER_BERKELEY_DB],  
 [AC_REQUIRE([OL_HEADER_BERKELEY_DB2])  
 AC_CHECK_HEADERS(db_185.h)  
 if test $ol_cv_header_db2 = yes ; then  
         dnl db.h is db2!   
   
         ol_cv_header_db=$ac_cv_header_db_185_h  
   # AM_PROG_LD - find the path to the GNU or non-GNU linker
   AC_DEFUN(AM_PROG_LD,
   [AC_ARG_WITH(gnu-ld,
   [  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
   test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
   AC_REQUIRE([AC_PROG_CC])
   ac_prog=ld
   if test "$ac_cv_prog_gcc" = yes; then
     # Check if gcc -print-prog-name=ld gives a path.
     AC_MSG_CHECKING([for ld used by GCC])
     ac_prog=`($CC -print-prog-name=ld) 2>&5`
     case "$ac_prog" in
     # Accept absolute paths.
     /* | [A-Za-z]:\\*)
       test -z "$LD" && LD="$ac_prog"
       ;;
     "")
       # If it fails, then pretend we aren't using GCC.
       ac_prog=ld
       ;;
     *)
       # If it is relative, then search for the first ld in PATH.
       with_gnu_ld=unknown
       ;;
     esac
   elif test "$with_gnu_ld" = yes; then
     AC_MSG_CHECKING([for GNU ld])
 else  else
         ol_cv_header_db=$ac_cv_header_db_h    AC_MSG_CHECKING([for non-GNU ld])
 fi  fi
 ])dnl  AC_CACHE_VAL(ac_cv_path_LD,
 dnl  [if test -z "$LD"; then
 dnl --------------------------------------------------------------------    IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
 dnl Check if Berkeley DB library exists    for ac_dir in $PATH; do
 dnl Check for dbopen in standard libraries or -ldb      test -z "$ac_dir" && ac_dir=.
 dnl      if test -f "$ac_dir/$ac_prog"; then
 dnl defines ol_cv_lib_db to 'yes' or '-ldb' or 'no'        ac_cv_path_LD="$ac_dir/$ac_prog"
 dnl             'yes' implies dbopen is in $LIBS        # Check to see if the program is GNU ld.  I'd rather use --version,
 dnl        # but apparently some GNU ld's only accept -v.
 dnl uses:        # Break only if it was the GNU/non-GNU ld that we prefer.
 dnl             AC_CHECK_FUNC(dbopen)        if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
 dnl             AC_CHECK_LIB(db,dbopen)          test "$with_gnu_ld" != no && break
 dnl        else
 AC_DEFUN([OL_LIB_BERKELEY_DB],          test "$with_gnu_ld" != yes && break
 [AC_CACHE_CHECK([for Berkeley DB library], [ol_cv_lib_db],        fi
 [       ol_LIBS="$LIBS"      fi
         AC_CHECK_FUNC(dbopen,[ol_cv_lib_db=yes], [    done
                 AC_CHECK_LIB(db,dbopen,[ol_cv_lib_db=-ldb],[ol_cv_lib_db=no])    IFS="$ac_save_ifs"
         ])  else
         LIBS="$ol_LIBS"    ac_cv_path_LD="$LD" # Let the user override the test with a path.
   fi])
   LD="$ac_cv_path_LD"
   if test -n "$LD"; then
     AC_MSG_RESULT($LD)
   else
     AC_MSG_RESULT(no)
   fi
   test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
   AC_SUBST(LD)
   AM_PROG_LD_GNU
 ])  ])
 ])dnl  
 dnl  AC_DEFUN(AM_PROG_LD_GNU,
 dnl --------------------------------------------------------------------  [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld,
 dnl Check if Berkeley DB exists  [# I'd rather use --version here, but apparently some GNU ld's only accept -v.
 dnl  if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
 dnl defines ol_cv_berkeley_db to 'yes' or 'no'    ac_cv_prog_gnu_ld=yes
 dnl   else
 dnl uses:    ac_cv_prog_gnu_ld=no
 dnl             OL_LIB_BERKELEY_DB  fi])
 dnl             OL_HEADER_BERKELEY_DB  
 dnl  
 AC_DEFUN([OL_BERKELEY_DB],  
 [AC_REQUIRE([OL_LIB_BERKELEY_DB])  
  AC_REQUIRE([OL_HEADER_BERKELEY_DB])  
  AC_CACHE_CHECK([for Berkeley DB], [ol_cv_berkeley_db], [  
         if test $ol_cv_lib_db = no -o $ol_cv_header_db = no ; then  
                 ol_cv_berkeley_db=no  
         else  
                 ol_cv_berkeley_db=yes  
         fi  
 ])  
  if test $ol_cv_berkeley_db = yes ; then  
         AC_DEFINE(HAVE_BERKELEY_DB,1)  
  fi  
 ])dnl  
 dnl  
 dnl ====================================================================  
 dnl Check if GDBM library exists  
 dnl Check for gdbm_open in standard libraries or -lgdbm  
 dnl  
 dnl defines ol_cv_lib_gdbm to 'yes' or '-lgdbm' or 'no'  
 dnl             'yes' implies gdbm_open is in $LIBS  
 dnl  
 dnl uses:  
 dnl             AC_CHECK_FUNC(gdbm_open)  
 dnl             AC_CHECK_LIB(gdbm,gdbm_open)  
 dnl  
 AC_DEFUN([OL_LIB_GDBM],  
 [AC_CACHE_CHECK(for GDBM library, [ol_cv_lib_gdbm],  
 [       ol_LIBS="$LIBS"  
         AC_CHECK_FUNC(gdbm_open,[ol_cv_lib_gdbm=yes], [  
                 AC_CHECK_LIB(gdbm,gdbm_open,[ol_cv_lib_gdbm=-lgdbm],[ol_cv_lib_gdbm=no])  
         ])  
         LIBS="$ol_LIBS"  
 ])  ])
 ])dnl  
 dnl  # AM_PROG_NM - find the path to a BSD-compatible name lister
 dnl --------------------------------------------------------------------  AC_DEFUN(AM_PROG_NM,
 dnl Check if GDBM exists  [AC_MSG_CHECKING([for BSD-compatible nm])
 dnl  AC_CACHE_VAL(ac_cv_path_NM,
 dnl defines ol_cv_gdbm to 'yes' or 'no'  [case "$NM" in
 dnl   /* | [A-Za-z]:\\*)
 dnl uses:    ac_cv_path_NM="$NM" # Let the user override the test with a path.
 dnl             OL_LIB_GDBM    ;;
 dnl             AC_CHECK_HEADERS(gdbm.h)  *)
 dnl    IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
 AC_DEFUN([OL_GDBM],    for ac_dir in /usr/ucb /usr/ccs/bin $PATH /bin; do
 [AC_REQUIRE([OL_LIB_GDBM])      test -z "$ac_dir" && ac_dir=.
  AC_CHECK_HEADERS(gdbm.h)      if test -f $ac_dir/nm; then
  AC_CACHE_CHECK(for db, [ol_cv_gdbm], [        # Check to see if the nm accepts a BSD-compat flag.
         if test $ol_cv_lib_gdbm = no -o $ac_cv_header_gdbm_h = no ; then        # Adding the `sed 1q' prevents false positives on HP-UX, which says:
                 ol_cv_gdbm=no        #   nm: unknown option "B" ignored
         else        if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
                 ol_cv_gdbm=yes          ac_cv_path_NM="$ac_dir/nm -B"
         fi        elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
 ])          ac_cv_path_NM="$ac_dir/nm -p"
  if test $ol_cv_gdbm = yes ; then        else
         AC_DEFINE(HAVE_GDBM,1)          ac_cv_path_NM="$ac_dir/nm"
  fi        fi
 ])dnl        break
 dnl      fi
 dnl ====================================================================    done
 dnl Check if NDBM library exists    IFS="$ac_save_ifs"
 dnl Check for dbm_open in standard libraries or -lndbm or -ldbm    test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
 dnl    ;;
 dnl defines ol_cv_lib_ndbm to 'yes' or '-lndbm' or -ldbm or 'no'  esac])
 dnl             'yes' implies ndbm_open is in $LIBS  NM="$ac_cv_path_NM"
 dnl  AC_MSG_RESULT([$NM])
 dnl uses:  AC_SUBST(NM)
 dnl             AC_CHECK_FUNC(dbm_open)  
 dnl             AC_CHECK_LIB(ndbm,dbm_open)  
 dnl             AC_CHECK_LIB(dbm,dbm_open)  
 dnl  
 dnl restrictions:  
 dnl             should also check SVR4 case: dbm_open() in -lucb but that  
 dnl             would requiring dealing with -L/usr/ucblib  
 dnl  
 AC_DEFUN([OL_LIB_NDBM],  
 [AC_CACHE_CHECK(for NDBM library, [ol_cv_lib_ndbm],  
 [       ol_LIBS="$LIBS"  
         AC_CHECK_FUNC(dbm_open,[ol_cv_lib_ndbm=yes], [  
                 AC_CHECK_LIB(ndbm,dbm_open,[ol_cv_lib_ndbm=-lndbm], [  
                         AC_CHECK_LIB(dbm,dbm_open,[ol_cv_lib_ndbm=-ldbm],  
                                 [ol_cv_lib_ndbm=no])dnl  
                 ])  
         ])  
         LIBS="$ol_LIBS"  
 ])  ])
 ])dnl  
 dnl  
 dnl --------------------------------------------------------------------  # serial 1
 dnl Check if NDBM exists  
 dnl  # @defmac AC_PROG_CC_STDC
 dnl defines ol_cv_ndbm to 'yes' or 'no'  # @maindex PROG_CC_STDC
 dnl   # @ovindex CC
 dnl uses:  # If the C compiler in not in ANSI C mode by default, try to add an option
 dnl             OL_LIB_NDBM  # to output variable @code{CC} to make it so.  This macro tries various
 dnl             AC_CHECK_HEADERS(ndbm.h)  # options that select ANSI C on some system or another.  It considers the
 dnl  # compiler to be in ANSI C mode if it handles function prototypes correctly.
 dnl restrictions:  #
 dnl             Doesn't handle SVR4 case (see above)  # If you use this macro, you should check after calling it whether the C
 dnl  # compiler has been set to accept ANSI C; if not, the shell variable
 AC_DEFUN([OL_NDBM],  # @code{am_cv_prog_cc_stdc} is set to @samp{no}.  If you wrote your source
 [AC_REQUIRE([OL_LIB_NDBM])  # code in ANSI C, you can make an un-ANSIfied copy of it by using the
  AC_CHECK_HEADERS(ndbm.h)  # program @code{ansi2knr}, which comes with Ghostscript.
  AC_CACHE_CHECK(for db, [ol_cv_ndbm], [  # @end defmac
         if test $ol_cv_lib_ndbm = no -o $ac_cv_header_ndbm_h = no ; then  
                 ol_cv_ndbm=no  AC_DEFUN(AM_PROG_CC_STDC,
         else  [AC_REQUIRE([AC_PROG_CC])
                 ol_cv_ndbm=yes  AC_BEFORE([$0], [AC_C_INLINE])
         fi  AC_BEFORE([$0], [AC_C_CONST])
 ])  dnl Force this before AC_PROG_CPP.  Some cpp's, eg on HPUX, require
  if test $ol_cv_ndbm = yes ; then  dnl a magic option to avoid problems with ANSI preprocessor commands
         AC_DEFINE(HAVE_NDBM,1)  dnl like #elif.
  fi  dnl FIXME: can't do this because then AC_AIX won't work due to a
 ])dnl  dnl circular dependency.
 dnl  dnl AC_BEFORE([$0], [AC_PROG_CPP])
 dnl ====================================================================  AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C)
 dnl Check POSIX Thread version   AC_CACHE_VAL(am_cv_prog_cc_stdc,
 dnl  [am_cv_prog_cc_stdc=no
 dnl defines ol_cv_posix_version to 'final' or 'draft' or 'unknown'  ac_save_CC="$CC"
 dnl     'unknown' implies that the version could not be detected  # Don't try gcc -ansi; that turns off useful extensions and
 dnl             or that pthreads.h does exist.  Existance of pthreads.h  # breaks some systems' header files.
 dnl             should be tested separately.  # AIX                   -qlanglvl=ansi
 dnl  # Ultrix and OSF/1      -std1
 AC_DEFUN([OL_POSIX_THREAD_VERSION],  # HP-UX                 -Aa -D_HPUX_SOURCE
 [AC_CACHE_CHECK([POSIX thread version],[ol_cv_pthread_version],[  # SVR4                  -Xc -D__EXTENSIONS__
         AC_EGREP_CPP(final,[  for ac_arg in "" -qlanglvl=ansi -std1 "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
 #               include <pthread.h>  do
                 /* this check could be improved */    CC="$ac_save_CC $ac_arg"
 #               ifdef PTHREAD_ONCE_INIT    AC_TRY_COMPILE(
                         final  [#include <stdarg.h>
 #               endif  #include <stdio.h>
         ], ol_pthread_final=yes, ol_pthread_final=no)  #include <sys/types.h>
   #include <sys/stat.h>
         AC_EGREP_CPP(draft4,[  /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
 #               include <pthread.h>  struct buf { int x; };
                 /* this check could be improved */  FILE * (*rcsopen) (struct buf *, struct stat *, int);
 #               ifdef pthread_once_init  static char *e (p, i)
                         draft4       char **p;
 #               endif       int i;
         ], ol_pthread_draft4=yes, ol_pthread_draft4=no)  {
     return p[i];
         if test $ol_pthread_final = yes -a $ol_pthread_draft4 = no; then  }
                 ol_cv_pthread_version=final  static char *f (char * (*g) (char **, int), char **p, ...)
         elif test $ol_pthread_final = no -a $ol_pthread_draft4 = yes; then  {
                 ol_cv_pthread_version=draft4    char *s;
         else    va_list v;
                 ol_cv_pthread_version=unknown    va_start (v,p);
         fi    s = g (p, va_arg (v,int));
     va_end (v);
     return s;
   }
   int test (int i, double x);
   struct s1 {int (*f) (int a);};
   struct s2 {int (*f) (double a);};
   int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
   int argc;
   char **argv;
   ], [
   return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
   ],
   [am_cv_prog_cc_stdc="$ac_arg"; break])
   done
   CC="$ac_save_CC"
 ])  ])
 ])dnl  if test -z "$am_cv_prog_cc_stdc"; then
 dnl    AC_MSG_RESULT([none needed])
 dnl --------------------------------------------------------------------  else
 dnl Check LinuxThread    AC_MSG_RESULT($am_cv_prog_cc_stdc)
 dnl  fi
 dnl defines ol_cv_linux_threads to 'yes' or 'no'  case "x$am_cv_prog_cc_stdc" in
 dnl             'no' implies pthreads.h is not LinuxThreads or pthreads.h    x|xno) ;;
 dnl             doesn't exists.  Existance of pthread.h should separately    *) CC="$CC $am_cv_prog_cc_stdc" ;;
 dnl             checked.  esac
 dnl   
 AC_DEFUN([OL_LINUX_THREADS],  
 [  
 AC_CACHE_CHECK([for LinuxThreads], [ol_cv_linux_threads], [  
         res=`grep Linuxthreads /usr/include/pthread.h 2>/dev/null | wc -l`  
         if test "$res" -gt 0 ; then  
                 ol_cv_linux_threads=yes  
         else  
                 ol_cv_linux_threads=no  
         fi  
 ])  ])
 ])dnl  
 dnl  dnl From Jim Meyering.
 dnl ====================================================================  
 dnl Check if toupper() requires islower() to be called first  # serial 1
 AC_DEFUN([OL_C_UPPER_LOWER],  
 [  AC_DEFUN(AM_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL,
 AC_MSG_CHECKING([if toupper() requires islower()])  [AC_REQUIRE([AM_SYS_POSIX_TERMIOS])
 AC_CACHE_VAL(ol_cv_c_upper_lower,[   AC_CACHE_CHECK([whether use of TIOCGWINSZ requires sys/ioctl.h],
         AC_TRY_RUN([                  am_cv_sys_tiocgwinsz_needs_sys_ioctl_h,
 #include <ctype.h>    [am_cv_sys_tiocgwinsz_needs_sys_ioctl_h=no
   
     gwinsz_in_termios_h=no
     if test $am_cv_sys_posix_termios = yes; then
       AC_EGREP_CPP([yes],
       [#include <sys/types.h>
   #     include <termios.h>
   #     ifdef TIOCGWINSZ
           yes
   #     endif
       ], gwinsz_in_termios_h=yes)
     fi
   
     if test $gwinsz_in_termios_h = no; then
       AC_EGREP_CPP([yes],
       [#include <sys/types.h>
   #     include <sys/ioctl.h>
   #     ifdef TIOCGWINSZ
           yes
   #     endif
       ], am_cv_sys_tiocgwinsz_needs_sys_ioctl_h=yes)
     fi
     ])
     if test $am_cv_sys_tiocgwinsz_needs_sys_ioctl_h = yes; then
       AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
     fi
   ])
   
   dnl From Jim Meyering.
   
   # serial 1
   
   AC_DEFUN(AM_SYS_POSIX_TERMIOS,
   [AC_CACHE_CHECK([POSIX termios], am_cv_sys_posix_termios,
     [AC_TRY_LINK([#include <sys/types.h>
   #include <unistd.h>
   #include <termios.h>],
     [/* SunOS 4.0.3 has termios.h but not the library calls.  */
      tcgetattr(0, 0);],
     am_cv_sys_posix_termios=yes,
     am_cv_sys_posix_termios=no)])
   ])
   
   # From Ulrich Drepper.
   
   # serial 1
   
   AC_DEFUN(AM_TYPE_PTRDIFF_T,
     [AC_CACHE_CHECK([for ptrdiff_t], am_cv_type_ptrdiff_t,
        [AC_TRY_COMPILE([#include <stddef.h>], [ptrdiff_t p],
                        am_cv_type_ptrdiff_t=yes, am_cv_type_ptrdiff_t=no)])
      if test $am_cv_type_ptrdiff_t = yes; then
        AC_DEFINE(HAVE_PTRDIFF_T)
      fi
   ])
   
   #serial 4
   
   dnl From Jim Meyering.
   dnl FIXME: this should migrate into libit.
   
   AC_DEFUN(AM_FUNC_MKTIME,
   [AC_REQUIRE([AC_HEADER_TIME])dnl
    AC_CHECK_HEADERS(sys/time.h unistd.h)
    AC_CHECK_FUNCS(alarm)
    AC_CACHE_CHECK([for working mktime], am_cv_func_working_mktime,
     [AC_TRY_RUN(
   changequote(<<, >>)dnl
   <</* Test program from Paul Eggert (eggert@twinsun.com)
      and Tony Leneis (tony@plaza.ds.adp.com).  */
   #if TIME_WITH_SYS_TIME
   # include <sys/time.h>
   # include <time.h>
   #else
   # if HAVE_SYS_TIME_H
   #  include <sys/time.h>
   # else
   #  include <time.h>
   # endif
   #endif
   
   #if HAVE_UNISTD_H
   # include <unistd.h>
   #endif
   
   #if !HAVE_ALARM
   # define alarm(X) /* empty */
   #endif
   
   /* Work around redefinition to rpl_putenv by other config tests.  */
   #undef putenv
   
   static time_t time_t_max;
   
   /* Values we'll use to set the TZ environment variable.  */
   static const char *const tz_strings[] = {
     (const char *) 0, "GMT0", "JST-9",
     "EST+3EDT+2,M10.1.0/00:00:00,M2.3.0/00:00:00"
   };
   #define N_STRINGS (sizeof (tz_strings) / sizeof (tz_strings[0]))
   
   static void
   mktime_test (now)
        time_t now;
   {
     struct tm *lt;
     if ((lt = localtime (&now)) && mktime (lt) != now)
       exit (1);
     now = time_t_max - now;
     if ((lt = localtime (&now)) && mktime (lt) != now)
       exit (1);
   }
   
   static void
   irix_6_4_bug ()
   {
     /* Based on code from Ariel Faigon.  */
     struct tm tm;
     tm.tm_year = 96;
     tm.tm_mon = 3;
     tm.tm_mday = 0;
     tm.tm_hour = 0;
     tm.tm_min = 0;
     tm.tm_sec = 0;
     tm.tm_isdst = -1;
     mktime (&tm);
     if (tm.tm_mon != 2 || tm.tm_mday != 31)
       exit (1);
   }
   
   static void
   bigtime_test (j)
        int j;
   {
     struct tm tm;
     time_t now;
     tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = j;
     /* This test makes some buggy mktime implementations loop.
        Give up after 10 seconds.  */
     alarm (10);
     now = mktime (&tm);
     alarm (0);
     if (now != (time_t) -1)
       {
         struct tm *lt = localtime (&now);
         if (! (lt
                && lt->tm_year == tm.tm_year
                && lt->tm_mon == tm.tm_mon
                && lt->tm_mday == tm.tm_mday
                && lt->tm_hour == tm.tm_hour
                && lt->tm_min == tm.tm_min
                && lt->tm_sec == tm.tm_sec
                && lt->tm_yday == tm.tm_yday
                && lt->tm_wday == tm.tm_wday
                && ((lt->tm_isdst < 0 ? -1 : 0 < lt->tm_isdst)
                     == (tm.tm_isdst < 0 ? -1 : 0 < tm.tm_isdst))))
           exit (1);
       }
   }
   
   int
   main ()
   {
     time_t t, delta;
     int i, j;
   
     for (time_t_max = 1; 0 < time_t_max; time_t_max *= 2)
       continue;
     time_t_max--;
     delta = time_t_max / 997; /* a suitable prime number */
     for (i = 0; i < N_STRINGS; i++)
       {
         if (tz_strings[i])
           putenv (tz_strings[i]);
   
         for (t = 0; t <= time_t_max - delta; t += delta)
           mktime_test (t);
         mktime_test ((time_t) 60 * 60);
         mktime_test ((time_t) 60 * 60 * 24);
   
         for (j = 1; 0 < j; j *= 2)
           bigtime_test (j);
         bigtime_test (j - 1);
       }
     irix_6_4_bug ();
     exit (0);
   }
                 >>,
   changequote([, ])dnl
                am_cv_func_working_mktime=yes, am_cv_func_working_mktime=no,
                dnl When crosscompiling, assume mktime is missing or broken.
                am_cv_func_working_mktime=no)
     ])
     if test $am_cv_func_working_mktime = no; then
       LIBOBJS="$LIBOBJS mktime.o"
     fi
   ])
   
   
   
   
   
   
   
   
   AC_DEFUN(AM_FUNC_STRTOD,
   [AC_CACHE_CHECK(for working strtod, am_cv_func_strtod,
   [AC_TRY_RUN([
   double strtod ();
   int
 main()  main()
 {  {
         if ('C' == toupper('C'))    {
                 exit(0);      /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
         else      char *string = " +69";
                 exit(1);      char *term;
 }],      double value;
         [ol_cv_c_upper_lower=no],      value = strtod (string, &term);
         [ol_cv_c_upper_lower=yes],      if (value != 69 || term != (string + 4))
         [ol_cv_c_upper_lower=safe])])        exit (1);
 AC_MSG_RESULT($ol_cv_c_upper_lower)    }
 if test $ol_cv_c_upper_lower != no ; then  
         AC_DEFINE(C_UPPER_LOWER,1)    {
       /* Under Solaris 2.4, strtod returns the wrong value for the
          terminating character under some conditions.  */
       char *string = "NaN";
       char *term;
       strtod (string, &term);
       if (term != string && *(term - 1) == 0)
         exit (1);
     }
     exit (0);
   }
   ], am_cv_func_strtod=yes, am_cv_func_strtod=no, am_cv_func_strtod=no)])
   test $am_cv_func_strtod = no && LIBOBJS="$LIBOBJS strtod.o"
   AC_SUBST(LIBOBJS)dnl
   am_cv_func_strtod_needs_libm=no
   if test $am_cv_func_strtod = no; then
     AC_CHECK_FUNCS(pow)
     if test $ac_cv_func_pow = no; then
       AC_CHECK_LIB(m, pow, [am_cv_func_strtod_needs_libm=yes],
                    [AC_MSG_WARN(can't find library containing definition of pow)])
     fi
 fi  fi
 ])  ])
   
 dnl ====================================================================  
 dnl Check for declaration of sys_errlist in one of stdio.h and errno.h.  
 dnl Declaration of sys_errlist on BSD4.4 interferes with our declaration.  
 dnl Reported by Keith Bostic.  
 AC_DEFUN([OL_SYS_ERRLIST],  
 [  
 AC_MSG_CHECKING([declaration of sys_errlist])  
 AC_CACHE_VAL(ol_cv_dcl_sys_errlist,[  
         AC_TRY_COMPILE([  
 #include <stdio.h>  
 #include <sys/types.h>  
 #include <errno.h> ],  
         [char *c = (char *) *sys_errlist],  
         [ol_cv_dcl_sys_errlist=yes],  
         [ol_cv_dcl_sys_errlist=no])])  
 AC_MSG_RESULT($ol_cv_dcl_sys_errlist)  
   
 # It's possible (for near-UNIX clones) that sys_errlist doesn't exist  
 if test $ol_cv_dcl_sys_errlist = no ; then  
         AC_DEFINE(DECL_SYS_ERRLIST,1)  
         AC_MSG_CHECKING([existence of sys_errlist])  
         AC_CACHE_VAL(ol_cv_have_sys_errlist,[  
                 AC_TRY_LINK([#include <errno.h>],  
                         [char *c = (char *) *sys_errlist],  
                         [ol_cv_have_sys_errlist=yes],  
                         [ol_cv_have_sys_errlist=no])])  
         AC_MSG_RESULT($ol_cv_have_sys_errlist)  
 fi  
 ])dnl  

Removed from v.1.2  
changed lines
  Added in v.1.3


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org