Diff for /configure.in between versions 1.2.2.31 and 1.2.2.31.2.9

version 1.2.2.31, 1999/01/19 22:14:38 version 1.2.2.31.2.9, 1999/02/02 03:25:17
Line 10  dnl Line 10  dnl
 dnl Configure.in for OpenLDAP  dnl Configure.in for OpenLDAP
 AC_INIT(include/ldap.h)dnl  AC_INIT(include/ldap.h)dnl
 AC_CONFIG_AUX_DIR(build)dnl  AC_CONFIG_AUX_DIR(build)dnl
 AM_INIT_AUTOMAKE(openldap,[1.1], [no ac_define])dnl  AM_INIT_AUTOMAKE(openldap,[1.2], [no ac_define])dnl
   
 dnl Do not use AutoConf 2.12; it produces a configuration script  dnl Do not use AutoConf 2.12; it produces a configuration script
 dnl that causes an "internal 2K buffer" error on HPUX when run  dnl that causes an "internal 2K buffer" error on HPUX when run
 dnl with /bin/sh.  Autoconf 2.10 seems to be okay.  dnl with /bin/sh.  Autoconf 2.10 seems to be okay.
 AC_PREREQ(2.10)dnl Required Autoconf version  AC_PREREQ(2.13)dnl Required Autoconf version
   
 AC_CONFIG_HEADER(include/portable.h)dnl  AC_CONFIG_HEADER(include/portable.h)dnl
   
Line 40  AC_ARG_WITH(subdir, [  --with-subdir=DIR Line 40  AC_ARG_WITH(subdir, [  --with-subdir=DIR
 AC_SUBST(ldap_subdir)dnl  AC_SUBST(ldap_subdir)dnl
   
 OL_ARG_ENABLE(debug,[  --enable-debug   enable debugging], yes)dnl  OL_ARG_ENABLE(debug,[  --enable-debug   enable debugging], yes)dnl
 dnl OL_ARG_ENABLE(syslog,[  --enable-syslog     enable syslog support], auto)dnl  
 OL_ARG_ENABLE(proctitle,[  --enable-proctitle   enable proctitle support], yes)dnl  OL_ARG_ENABLE(proctitle,[  --enable-proctitle   enable proctitle support], yes)dnl
 OL_ARG_ENABLE(libui,[  --enable-libui   enable library user interface], yes)dnl  OL_ARG_ENABLE(libui,[  --enable-libui   enable library user interface], yes)dnl
 OL_ARG_ENABLE(cache,[  --enable-cache   enable caching], yes)dnl  OL_ARG_ENABLE(cache,[  --enable-cache   enable caching], yes)dnl
Line 51  OL_ARG_ENABLE(x_compile,[  --enable-x-co Line 50  OL_ARG_ENABLE(x_compile,[  --enable-x-co
         no, [yes no])dnl          no, [yes no])dnl
   
 dnl General "with" options  dnl General "with" options
   OL_ARG_ENABLE(dmalloc,[  --enable-dmalloc       enable debug malloc support], no)dnl
   
 OL_ARG_WITH(kerberos,[  --with-kerberos use Kerberos],  OL_ARG_WITH(kerberos,[  --with-kerberos use Kerberos],
         auto, [auto k5 k4 afs yes no])          auto, [auto k5 k4 afs yes no])
 OL_ARG_WITH(threads,[  --with-threads   use threads],  OL_ARG_WITH(threads,[  --with-threads   use threads],
Line 95  dnl AM_ENABLE_SHARED Line 96  dnl AM_ENABLE_SHARED
   
 dnl General "enable" options  dnl General "enable" options
 # validate options  # validate options
 if test $ol_enable_referrals = no ; then  if test $ol_enable_dns = yes ; then
         if test $ol_enable_dns = yes ; then          if test $ol_enable_referrals = no ; then
                 AC_MSG_WARN([dns disabled, ignoring --enable-dns argument])                  AC_MSG_ERROR([DNS requires --enable-referrals])
           fi
           if test $ol_enable_referrals = auto ; then
                   AC_MSG_WARN([DNS requires referrals, adding --enable-referrals])
                   ol_enable_referrals=yes
         fi          fi
         ol_enable_dns=no  
 fi  fi
   
 if test $ol_enable_slapd = no ; then  if test $ol_enable_slapd = no ; then
Line 388  if test $ol_with_threads = auto -o $ol_w Line 392  if test $ol_with_threads = auto -o $ol_w
                         AC_DEFINE(HAVE_LINUX_THREADS,1)                          AC_DEFINE(HAVE_LINUX_THREADS,1)
                 fi                  fi
   
                 dnl Now the hard part, how to link                  dnl Now the hard part, how to link?
                   dnl
                   dnl currently supported checks:
                   dnl
                   dnl 0)  pthread_create() in $LIBS
                   dnl
                   dnl Check special pthread (final) flags
                   dnl 1)  pthread_create() with -kthread (FreeBSD)
                   dnl 2)  pthread_create() with -pthread (FreeBSD)
                   dnl 3)  pthread_create() with -pthreads (OSF/1)
                   dnl 4)  pthread_create() with -thread (?)
                   dnl
                   dnl Check pthread (final) libraries
                   dnl 5)  pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1)
                   dnl 6)  pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1)
                   dnl 7)  pthread_mutex_trylock() in -lpthread -lexc (OSF/1)
                   dnl 8)  pthread_create() in -lpthread (many)
                   dnl 9)  pthread_create() in -lc_r (FreeBSD)
                   dnl 10) pthread_create() in -lpthreads (many)
                   dnl 11) pthread_join() -Wl,-woff,85 -lpthreads (IRIX)
                   dnl 12) pthread_create() in HP-UX -lpthread (HP-UX 11)
                   dnl
                   dnl Check pthread (draft4) flags (to be depreciated)
                   dnl 13) pthread_create() with -threads (OSF/1)
                   dnl
                   dnl Check pthread (final) libraries (to be depreciated)
                   dnl 14) pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1)
                   dnl 14) pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1)
                   dnl 14) pthread_mutex_trylock() in -lpthreads -lexc (OSF/1)
                   dnl
   
                 dnl Check for pthread support in current $LIBS                  dnl pthread_create in $LIBS
                 AC_CHECK_FUNC(pthread_create,[ol_link_threads=yes])                  AC_CHECK_FUNC(pthread_create,[ol_link_threads=yes])
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                           dnl try -kthread
                           AC_CACHE_CHECK([for pthread_create with -kthread],
                                   [ol_cv_kthread_flag], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="-kthread $LIBS"
                                   AC_TRY_LINK([char pthread();],[
                                           pthread_create();
                                           ], ol_cv_kthread_flag=yes, ol_cv_kthread_flag=no)
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_kthread_flag = yes ; then
                                   LTHREAD_LIBS="$LTHREAD_LIBS -kthread"
                                   ol_link_threads=posix
                           fi
                   fi
   
                   if test $ol_link_threads = no ; then
                         dnl try -pthread                          dnl try -pthread
                         AC_CACHE_CHECK([for pthread_create with -pthread],                          AC_CACHE_CHECK([for pthread_create with -pthread],
                                 [ol_cv_pthread_flag], [                                  [ol_cv_pthread_flag], [
Line 454  if test $ol_with_threads = auto -o $ol_w Line 507  if test $ol_with_threads = auto -o $ol_w
                 fi                  fi
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                         dnl try DEC Threads -lpthread -lexc                          dnl try DEC Threads -lpthread -lmach -lexc -lc_r
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthread, pthread_mutex_unlock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc -lc_r"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc -lc_r])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthread -lmach -lexc
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthread, pthread_mutex_lock, [                          AC_CHECK_LIB(pthread, pthread_mutex_lock, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lexc"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc"
                                 if test $ol_with_yielding_select = auto ; then                                  if test $ol_with_yielding_select = auto ; then
                                         ol_with_yielding_select=yes                                          ol_with_yielding_select=yes
                                 fi                                  fi
                                 ],,[-lexc])                                  ],:,[-lmach -lexc])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                         dnl try DEC Threads -lpthreads -lmach -lexc -lc_r                          dnl try DEC Threads -lpthread -lexc
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthreads, pthread_mutex_unlock, [                          AC_CHECK_LIB(pthread, pthread_mutex_trylock, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc -lc_r"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lexc"
                                 if test $ol_with_yielding_select = auto ; then                                  if test $ol_with_yielding_select = auto ; then
                                         ol_with_yielding_select=yes                                          ol_with_yielding_select=yes
                                 fi                                  fi
                                 ],,[-lmach -lexc -lc_r])                                  ],:,[-lexc])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 484  if test $ol_with_threads = auto -o $ol_w Line 550  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthread, pthread_create, [                          AC_CHECK_LIB(pthread, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 493  if test $ol_with_threads = auto -o $ol_w Line 559  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(c_r, pthread_create, [                          AC_CHECK_LIB(c_r, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lc_r"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lc_r"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 502  if test $ol_with_threads = auto -o $ol_w Line 568  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthreads, pthread_create, [                          AC_CHECK_LIB(pthreads, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 513  if test $ol_with_threads = auto -o $ol_w Line 579  if test $ol_with_threads = auto -o $ol_w
                         AC_CHECK_LIB(pthreads, pthread_join, [                          AC_CHECK_LIB(pthreads, pthread_join, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"
                                 ],[-Wl,-woff,85])                                  ],:,[-Wl,-woff,85])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 548  if test $ol_with_threads = auto -o $ol_w Line 614  if test $ol_with_threads = auto -o $ol_w
                         fi                          fi
                 fi                  fi
   
                   if test $ol_link_threads = no ; then
                           dnl try -threads
                           AC_CACHE_CHECK([for pthread_create with -threads],
                                   [ol_cv_thread_flag], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="-threads $LIBS"
                                   AC_TRY_LINK([char pthread();],[
                                           pthread_create();
                                           ], ol_cv_thread_flag=yes, ol_cv_thread_flag=no)
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_thread_flag = yes ; then
                                   LTHREAD_LIBS="$LTHREAD_LIBS -threads"
                                   ol_link_threads=posix
                           fi
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lmach -lexc -lc_r
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_unlock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc -lc_r"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc -lc_r])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lmach -lexc
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_lock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lexc
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_trylock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lexc"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lexc])
                           LIBS="$save_LIBS"
                   fi
   
                 if test $ol_link_threads != no ; then                  if test $ol_link_threads != no ; then
                         AC_DEFINE(HAVE_PTHREADS)                          AC_DEFINE(HAVE_PTHREADS)
   
Line 573  if test $ol_with_threads = auto -o $ol_w Line 698  if test $ol_with_threads = auto -o $ol_w
                         if test $ac_cv_func_sched_yield = no -a \                          if test $ac_cv_func_sched_yield = no -a \
                                 $ac_cv_func_pthread_yield = no ; then                                  $ac_cv_func_pthread_yield = no ; then
                                 dnl Solaris has sched_yield() in -lposix4                                  dnl Solaris has sched_yield() in -lposix4
                                 AC_CHECK_LIB(posix4, sched_yield,                                  dnl but we'll use thr_yield instead.
                                         [LTHREAD_LIBS="$LTHREAD_LIBS -lposix4"                                  AC_CHECK_FUNCS(thr_yield)
                                         AC_DEFINE(HAVE_SCHED_YIELD,1)  
                                         ac_cv_func_sched_yield=yes],  
                                         [ac_cv_func_sched_yield=no])  
                         fi                          fi
                         if test $ac_cv_func_sched_yield = no -a \                          if test $ac_cv_func_sched_yield = no -a \
                                 $ac_cv_func_pthread_yield = no ; then                                  $ac_cv_func_pthread_yield = no -a \
                                   "$ac_cv_func_thr_yield" = no ; then
                                 AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])                                  AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])
                         fi                          fi
   
                         dnl Check functions for compatibility                          dnl Check functions for compatibility
                         AC_CHECK_FUNCS(pthread_kill pthread_detach)                          AC_CHECK_FUNCS(pthread_kill pthread_detach)
   
                         AC_CHECK_FUNCS( \                          if test $ac_cv_func_pthread_detach = no ; then
                                 pthread_attr_create pthread_attr_init \                                  AC_MSG_ERROR([could not locate pthread_detach()])
                                 pthread_attr_destroy pthread_attr_delete \                          fi
                                 pthread_attr_setdetachstate pthread_attr_setdetach_np \  
                         )  
   
                         dnl Check for setconcurreny functions                          dnl Check for setconcurreny functions
                         AC_CHECK_FUNCS( \                          AC_CHECK_FUNCS( \
                                 pthread_setconcurrency \                                  pthread_setconcurrency \
                                   pthread_getconcurrency \
                                 thr_setconcurrency \                                  thr_setconcurrency \
                                   thr_getconcurrency \
                         )                          )
   
                         AC_MSG_CHECKING([if pthread_create() works])                          AC_MSG_CHECKING([if pthread_create() works])
Line 789  if test $ol_with_threads = auto -o $ol_w Line 912  if test $ol_with_threads = auto -o $ol_w
                                 ol_with_yielding_select=yes                                  ol_with_yielding_select=yes
                         fi                          fi
   
                         AC_CACHE_CHECK([for misplaced posix thread in headers],                          dnl Check for setconcurreny functions
                                 [ol_cv_header_misplaced_pthreads], [                          AC_CHECK_FUNCS( \
                                 AC_TRY_COMPILE([                                  thr_setconcurrency \
 #include <sys/types.h>                                  thr_getconcurrency \
 typedef double pthread_t;                          )
                                 ], [  
                                 pthread_t thread = 0.0;  
                                 ],  
                                 [ol_cv_header_misplaced_pthreads=no],  
                                 [ol_cv_header_misplaced_pthreads=yes])  
                         ])  
   
                         if test "$ol_cv_header_misplaced_pthreads" = yes ; then  
                                 AC_MSG_ERROR([pthread types are misplaced, use --with-threads=posix]);  
                         fi  
                 fi                  fi
         fi          fi
   
Line 886  if test $ol_link_threads = no ; then Line 999  if test $ol_link_threads = no ; then
                 ol_with_threads=no                  ol_with_threads=no
         fi          fi
   
         AC_CACHE_CHECK([for misplaced posix thread in headers],  
                 [ol_cv_header_misplaced_pthreads], [  
                 AC_TRY_COMPILE([  
 #include <sys/types.h>  
 typedef double pthread_t;  
                         ], [  
                                 pthread_t thread = 0.0;  
                         ],  
                         [ol_cv_header_misplaced_pthreads=no],  
                         [ol_cv_header_misplaced_pthreads=yes])  
         ])  
   
         if test "$ol_cv_header_misplaced_pthreads" = yes ; then  
                 AC_MSG_ERROR([pthread types are misplaced, use --with-threads=posix]);  
         fi  
   
         AC_DEFINE(NO_THREADS,1)          AC_DEFINE(NO_THREADS,1)
         LTHREAD_LIBS=""          LTHREAD_LIBS=""
 fi  fi
Line 1001  if test $ol_link_ldbm = no -a $ol_enable Line 1098  if test $ol_link_ldbm = no -a $ol_enable
         ol_enable_ldbm=no          ol_enable_ldbm=no
 fi  fi
   
 if test $ol_enable_wrappers = yes ; then  if test $ol_enable_wrappers != no ; then
         AC_CHECK_LIB(wrap, main,          AC_CHECK_HEADERS(tcpd.h)
                 [have_wrappers=yes], [have_wrappers=no])  
           if test $ac_cv_header_tcpd_h != yes ; then
                   have_wrappers=no
           else
                   AC_CHECK_LIB(wrap, main,
                           [have_wrappers=yes], [have_wrappers=no])
           fi
   
         if test $have_wrappers = yes ; then          if test $have_wrappers = yes ; then
                 AC_DEFINE(HAVE_TCPD)                  AC_DEFINE(HAVE_TCPD)
Line 1017  if test $ol_enable_wrappers = yes ; then Line 1120  if test $ol_enable_wrappers = yes ; then
                 AC_MSG_WARN(disabling wrappers support)                  AC_MSG_WARN(disabling wrappers support)
                 ol_enable_wrappers=no                  ol_enable_wrappers=no
         fi          fi
   fi
   
   if test $ol_enable_dmalloc != no ; then
           AC_CHECK_HEADERS(dmalloc.h)
           AC_CHECK_LIB(dmalloc, dmalloc_shutdown)
 fi  fi
   
 # ud needs termcap (should insert check here)  # ud needs termcap (should insert check here)
Line 1166  if test $ac_cv_func_vprintf = yes ; then Line 1273  if test $ac_cv_func_vprintf = yes ; then
         AC_CHECK_FUNCS(vsnprintf vsprintf)          AC_CHECK_FUNCS(vsnprintf vsprintf)
 fi  fi
   
 AC_FUNC_WAIT3  
   
 AC_CHECK_FUNCS(         \  AC_CHECK_FUNCS(         \
         bcopy                   \          bcopy                   \
         flock                   \          flock                   \
Line 1211  dnl Sort out defines Line 1316  dnl Sort out defines
 if test "$ol_enable_debug" != no ; then  if test "$ol_enable_debug" != no ; then
         AC_DEFINE(LDAP_DEBUG,1)          AC_DEFINE(LDAP_DEBUG,1)
 fi  fi
 dnl     if test "$ol_enable_syslog" != no ; then  
 dnl             AC_DEFINE(LDAP_SYSLOG,1)  
 dnl     fi  
 if test "$ol_enable_libui" = yes ; then  if test "$ol_enable_libui" = yes ; then
         AC_DEFINE(LDAP_LIBUI,1)          AC_DEFINE(LDAP_LIBUI,1)
 fi  fi

Removed from v.1.2.2.31  
changed lines
  Added in v.1.2.2.31.2.9


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