configure.in

   1 dnl Process this file with autoconf 2.0 or later to make a configure script.
   2
   3 # Set VERSION so we only need to edit in one place (i.e., here)
   4 m4_define(PYTHON_VERSION, 2.5)
   5
   6 AC_REVISION($Revision$)
   7 AC_PREREQ(2.59)
   8 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
   9 AC_CONFIG_SRCDIR([Include/object.h])
  10 AC_CONFIG_HEADER(pyconfig.h)
  11
  12 dnl This is for stuff that absolutely must end up in pyconfig.h.
  13 dnl Please use pyport.h instead, if possible.
  14 AH_TOP([
  15 #ifndef Py_PYCONFIG_H
  16 #define Py_PYCONFIG_H
  17 ])
  18 AH_BOTTOM([
  19 /* Define the macros needed if on a UnixWare 7.x system. */
  20 #if defined(__USLC__) && defined(__SCO_VERSION__)
  21 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
  22 #endif
  23
  24 #endif /*Py_PYCONFIG_H*/
  25 ])
  26
  27 # We don't use PACKAGE_ variables, and they cause conflicts
  28 # with other autoconf-based packages that include Python.h
  29 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
  30 rm confdefs.h
  31 mv confdefs.h.new confdefs.h
  32
  33 AC_SUBST(VERSION)
  34 VERSION=PYTHON_VERSION
  35
  36 AC_SUBST(SOVERSION)
  37 SOVERSION=1.0
  38
  39 # The later defininition of _XOPEN_SOURCE disables certain features
  40 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
  41 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
  42
  43 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
  44 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
  45 # them.
  46 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
  47
  48 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
  49 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
  50 # them.
  51 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
  52
  53 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
  54 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
  55 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
  56
  57 define_xopen_source=yes
  58
  59 # Arguments passed to configure.
  60 AC_SUBST(CONFIG_ARGS)
  61 CONFIG_ARGS="$ac_configure_args"
  62
  63 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
  64 AC_ARG_ENABLE(framework,
  65               AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
  66 [
  67         case $enableval in
  68         yes)
  69                 enableval=/Library/Frameworks
  70         esac
  71         case $enableval in
  72         no)
  73                 PYTHONFRAMEWORK=
  74                 PYTHONFRAMEWORKDIR=no-framework
  75                 PYTHONFRAMEWORKPREFIX=
  76                 PYTHONFRAMEWORKINSTALLDIR=
  77                 enable_framework=
  78                 ;;
  79         *)
  80                 PYTHONFRAMEWORK=Python
  81                 PYTHONFRAMEWORKDIR=Python.framework
  82                 PYTHONFRAMEWORKPREFIX=$enableval
  83                 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
  84                 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
  85         esac
  86         ],[
  87         PYTHONFRAMEWORK=
  88         PYTHONFRAMEWORKDIR=no-framework
  89         PYTHONFRAMEWORKPREFIX=
  90         PYTHONFRAMEWORKINSTALLDIR=
  91         enable_framework=
  92 ])
  93 AC_SUBST(PYTHONFRAMEWORK)
  94 AC_SUBST(PYTHONFRAMEWORKDIR)
  95 AC_SUBST(PYTHONFRAMEWORKPREFIX)
  96 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
  97
  98 ##AC_ARG_WITH(dyld,
  99 ##            AC_HELP_STRING(--with-dyld,
 100 ##                           Use (OpenStep|Rhapsody) dynamic linker))
 101 ##
 102 # Set name for machine-dependent library files
 103 AC_SUBST(MACHDEP)
 104 AC_MSG_CHECKING(MACHDEP)
 105 if test -z "$MACHDEP"
 106 then
 107         ac_sys_system=`uname -s`
 108         if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
 109         -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
 110                 ac_sys_release=`uname -v`
 111         else
 112                 ac_sys_release=`uname -r`
 113         fi
 114         ac_md_system=`echo $ac_sys_system |
 115                            tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
 116         ac_md_release=`echo $ac_sys_release |
 117                            tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
 118         MACHDEP="$ac_md_system$ac_md_release"
 119
 120         case $MACHDEP in
 121         cygwin*) MACHDEP="cygwin";;
 122         darwin*) MACHDEP="darwin";;
 123         atheos*) MACHDEP="atheos";;
 124         irix646) MACHDEP="irix6";;
 125         '')     MACHDEP="unknown";;
 126         esac
 127 fi
 128
 129 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
 130 # disable features if it is defined, without any means to access these
 131 # features as extensions. For these systems, we skip the definition of
 132 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
 133 # some feature, make sure there is no alternative way to access this
 134 # feature. Also, when using wildcards, make sure you have verified the
 135 # need for not defining _XOPEN_SOURCE on all systems matching the
 136 # wildcard, and that the wildcard does not include future systems
 137 # (which may remove their limitations).
 138 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
 139 case $ac_sys_system/$ac_sys_release in
 140   # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
 141   # even though select is a POSIX function. Reported by J. Ribbens.
 142   # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
 143   OpenBSD/2.* | OpenBSD/3.@<:@012345678@:>@)
 144     define_xopen_source=no;;
 145   # On Solaris 2.6, sys/wait.h is inconsistent in the usage
 146   # of union __?sigval. Reported by Stuart Bishop.
 147   SunOS/5.6)
 148     define_xopen_source=no;;
 149   # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
 150   # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
 151   # Reconfirmed for 7.1.4 by Martin v. Loewis.
 152   OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
 153     define_xopen_source=no;;
 154   # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
 155   # but used in struct sockaddr.sa_family. Reported by Tim Rice.
 156   SCO_SV/3.2)
 157     define_xopen_source=no;;
 158   # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
 159   # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
 160   # this is fixed in 10.3, which identifies itself as Darwin/7.*
 161   # This should hopefully be fixed in FreeBSD 4.9
 162   FreeBSD/4.8* | Darwin/6* )
 163     define_xopen_source=no;;
 164   # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
 165   # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
 166   # or has another value. By not (re)defining it, the defaults come in place.
 167   AIX/4)
 168     define_xopen_source=no;;
 169   AIX/5)
 170     if test `uname -r` -eq 1; then
 171       define_xopen_source=no
 172     fi
 173     ;;
 174   # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
 175   # disables platform specific features beyond repair.
 176   # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
 177   # has no effect, don't bother defineing them
 178   Darwin/[78].*)
 179     define_xopen_source=no
 180     ;;
 181
 182 esac
 183
 184 if test $define_xopen_source = yes
 185 then
 186   # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
 187   # defined precisely as g++ defines it
 188   # Furthermore, on Solaris 10, XPG6 requires the use of a C99
 189   # compiler
 190   case $ac_sys_system/$ac_sys_release in
 191     SunOS/5.8|SunOS/5.9|SunOS/5.10)
 192       AC_DEFINE(_XOPEN_SOURCE, 500,
 193                 Define to the level of X/Open that your system supports)
 194       ;;
 195     *)
 196       AC_DEFINE(_XOPEN_SOURCE, 600,
 197                 Define to the level of X/Open that your system supports)
 198       ;;
 199   esac
 200
 201   # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
 202   # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
 203   # several APIs are not declared. Since this is also needed in some
 204   # cases for HP-UX, we define it globally.
 205   # except for Solaris 10, where it must not be defined,
 206   # as it implies XPG4.2
 207   case $ac_sys_system/$ac_sys_release in
 208     SunOS/5.10)
 209       ;;
 210     *)
 211       AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
 212                 Define to activate Unix95-and-earlier features)
 213       ;;
 214   esac
 215
 216   AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
 217
 218 fi
 219
 220 #
 221 # SGI compilers allow the specification of the both the ABI and the
 222 # ISA on the command line.  Depending on the values of these switches,
 223 # different and often incompatable code will be generated.
 224 #
 225 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
 226 # thus supply support for various ABI/ISA combinations.  The MACHDEP
 227 # variable is also adjusted.
 228 #
 229 AC_SUBST(SGI_ABI)
 230 if test ! -z "$SGI_ABI"
 231 then
 232         CC="cc $SGI_ABI"
 233         LDFLAGS="$SGI_ABI $LDFLAGS"
 234         MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
 235 fi
 236 AC_MSG_RESULT($MACHDEP)
 237
 238 # And add extra plat-mac for darwin
 239 AC_SUBST(EXTRAPLATDIR)
 240 AC_SUBST(EXTRAMACHDEPPATH)
 241 AC_MSG_CHECKING(EXTRAPLATDIR)
 242 if test -z "$EXTRAPLATDIR"
 243 then
 244         case $MACHDEP in
 245         darwin)
 246                 EXTRAPLATDIR="\$(PLATMACDIRS)"
 247                 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
 248                 ;;
 249         *)
 250                 EXTRAPLATDIR=""
 251                 EXTRAMACHDEPPATH=""
 252                 ;;
 253         esac
 254 fi
 255 AC_MSG_RESULT($EXTRAPLATDIR)
 256
 257 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
 258 # it may influence the way we can build extensions, so distutils
 259 # needs to check it
 260 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
 261 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
 262
 263 # checks for alternative programs
 264
 265 # compiler flags are generated in two sets, BASECFLAGS and OPT.  OPT is just
 266 # for debug/optimization stuff.  BASECFLAGS is for flags that are required
 267 # just to get things to compile and link.  Users are free to override OPT
 268 # when running configure or make.  The build should not break if they do.
 269 # BASECFLAGS should generally not be messed with, however.
 270
 271 # XXX shouldn't some/most/all of this code be merged with the stuff later
 272 # on that fiddles with OPT and BASECFLAGS?
 273 AC_MSG_CHECKING(for --without-gcc)
 274 AC_ARG_WITH(gcc,
 275             AC_HELP_STRING(--without-gcc,never use gcc),
 276 [
 277         case $withval in
 278         no)     CC=cc
 279                 without_gcc=yes;;
 280         yes)    CC=gcc
 281                 without_gcc=no;;
 282         *)      CC=$withval
 283                 without_gcc=$withval;;
 284         esac], [
 285         case $ac_sys_system in
 286         AIX*)   CC=cc_r
 287                 without_gcc=;;
 288         BeOS*)
 289                 case $BE_HOST_CPU in
 290                 ppc)
 291                         CC=mwcc
 292                         without_gcc=yes
 293                         BASECFLAGS="$BASECFLAGS -export pragma"
 294                         OPT="$OPT -O"
 295                         LDFLAGS="$LDFLAGS -nodup"
 296                         ;;
 297                 x86)
 298                         CC=gcc
 299                         without_gcc=no
 300                         OPT="$OPT -O"
 301                         ;;
 302                 *)
 303                         AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
 304                         ;;
 305                 esac
 306                 AR="\$(srcdir)/Modules/ar_beos"
 307                 RANLIB=:
 308                 ;;
 309     Monterey*)
 310         RANLIB=:
 311         without_gcc=;;
 312         *)      without_gcc=no;;
 313         esac])
 314 AC_MSG_RESULT($without_gcc)
 315
 316 AC_SUBST(CXX)
 317 AC_SUBST(MAINOBJ)
 318 MAINOBJ=python.o
 319 AC_MSG_CHECKING(for --with-cxx=<compiler>)
 320 AC_ARG_WITH(cxx,
 321             AC_HELP_STRING(--with-cxx=<compiler>, enable C++ support),
 322 [
 323         check_cxx=no
 324         case $withval in
 325         no)     CXX=
 326                 with_cxx=no;;
 327         *)      CXX=$withval
 328                 MAINOBJ=ccpython.o
 329                 with_cxx=$withval;;
 330         esac], [
 331         with_cxx=no
 332         check_cxx=yes
 333 ])
 334 AC_MSG_RESULT($with_cxx)
 335
 336 if test "$with_cxx" = "yes"
 337 then
 338         AC_MSG_ERROR([must supply a compiler when using --with-cxx])
 339 fi
 340
 341 dnl The following fragment works similar to AC_PROG_CXX.
 342 dnl It does not fail if CXX is not found, and it is not executed if
 343 dnl --without-cxx was given.
 344 dnl Finally, it does not test whether CXX is g++.
 345
 346 dnl Autoconf 2.5x does not have AC_PROG_CXX_WORKS anymore
 347 ifdef([AC_PROG_CXX_WORKS],[],
 348       [AC_DEFUN([AC_PROG_CXX_WORKS],
 349       [AC_LANG_PUSH(C++)dnl
 350        _AC_COMPILER_EXEEXT
 351        AC_LANG_POP()
 352       ]
 353 )])
 354
 355 if test "$check_cxx" = "yes"
 356 then
 357         AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
 358         if test "$CXX" = "notfound"
 359         then
 360                 CXX=
 361         else
 362                 AC_PROG_CXX_WORKS
 363         fi
 364 fi
 365
 366 # If the user switches compilers, we can't believe the cache
 367 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
 368 then
 369   AC_MSG_ERROR([cached CC is different -- throw away $cache_file
 370 (it is also a good idea to do 'make clean' before compiling)])
 371 fi
 372
 373 AC_PROG_CC
 374
 375 # checks for UNIX variants that set C preprocessor variables
 376 AC_AIX
 377
 378 # Check for unsupported systems
 379 case $ac_sys_system/$ac_sys_release in
 380 Linux*/1*)
 381    echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
 382    echo See README for details.
 383    exit 1;;
 384 esac
 385
 386 AC_EXEEXT
 387 AC_MSG_CHECKING(for --with-suffix)
 388 AC_ARG_WITH(suffix,
 389             AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
 390 [
 391         case $withval in
 392         no)     EXEEXT=;;
 393         yes)    EXEEXT=.exe;;
 394         *)      EXEEXT=$withval;;
 395         esac])
 396 AC_MSG_RESULT($EXEEXT)
 397
 398 # Test whether we're running on a non-case-sensitive system, in which
 399 # case we give a warning if no ext is given
 400 AC_SUBST(BUILDEXEEXT)
 401 AC_MSG_CHECKING(for case-insensitive build directory)
 402 if test ! -d CaseSensitiveTestDir; then
 403 mkdir CaseSensitiveTestDir
 404 fi
 405
 406 if test -d casesensitivetestdir
 407 then
 408     AC_MSG_RESULT(yes)
 409     BUILDEXEEXT=.exe
 410 else
 411         AC_MSG_RESULT(no)
 412         BUILDEXEEXT=$EXEEXT
 413 fi
 414 rmdir CaseSensitiveTestDir
 415
 416 case $MACHDEP in
 417 bsdos*)
 418     case $CC in
 419     gcc) CC="$CC -D_HAVE_BSDI";;
 420     esac;;
 421 esac
 422
 423 case $ac_sys_system in
 424 hp*|HP*)
 425     case $CC in
 426     cc|*/cc) CC="$CC -Ae";;
 427     esac;;
 428 Monterey*)
 429     case $CC in
 430     cc) CC="$CC -Wl,-Bexport";;
 431     esac;;
 432 SunOS*)
 433     # Some functions have a prototype only with that define, e.g. confstr
 434     AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
 435     ;;
 436 esac
 437
 438
 439 AC_SUBST(LIBRARY)
 440 AC_MSG_CHECKING(LIBRARY)
 441 if test -z "$LIBRARY"
 442 then
 443         LIBRARY='libpython$(VERSION).a'
 444 fi
 445 AC_MSG_RESULT($LIBRARY)
 446
 447 # LDLIBRARY is the name of the library to link against (as opposed to the
 448 # name of the library into which to insert object files). BLDLIBRARY is also
 449 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
 450 # is blank as the main program is not linked directly against LDLIBRARY.
 451 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
 452 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
 453 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
 454 # DLLLIBRARY is the shared (i.e., DLL) library.
 455 #
 456 # RUNSHARED is used to run shared python without installed libraries
 457 #
 458 # INSTSONAME is the name of the shared library that will be use to install
 459 # on the system - some systems like version suffix, others don't
 460 AC_SUBST(LDLIBRARY)
 461 AC_SUBST(DLLLIBRARY)
 462 AC_SUBST(BLDLIBRARY)
 463 AC_SUBST(LDLIBRARYDIR)
 464 AC_SUBST(INSTSONAME)
 465 AC_SUBST(RUNSHARED)
 466 LDLIBRARY="$LIBRARY"
 467 BLDLIBRARY='$(LDLIBRARY)'
 468 INSTSONAME='$(LDLIBRARY)'
 469 DLLLIBRARY=''
 470 LDLIBRARYDIR=''
 471 RUNSHARED=''
 472
 473 # LINKCC is the command that links the python executable -- default is $(CC).
 474 # If CXX is set, and if it is needed to link a main function that was
 475 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
 476 # python might then depend on the C++ runtime
 477 # This is altered for AIX in order to build the export list before
 478 # linking.
 479 AC_SUBST(LINKCC)
 480 AC_MSG_CHECKING(LINKCC)
 481 if test -z "$LINKCC"
 482 then
 483         if test -z "$CXX"; then
 484               LINKCC="\$(PURIFY) \$(CC)"
 485         else
 486               echo 'extern "C" void foo();int main(){foo();}' > conftest_a.cc
 487               $CXX -c conftest_a.cc # 2>&5
 488               echo 'void foo(){}' > conftest_b.$ac_ext
 489               $CC -c conftest_b.$ac_ext # 2>&5
 490               if $CC -o conftest$ac_exeext conftest_a.$ac_objext conftest_b.$ac_objext 2>&5 \
 491                  && test -s conftest$ac_exeext && ./conftest$ac_exeext
 492               then
 493                  LINKCC="\$(PURIFY) \$(CC)"
 494               else
 495                  LINKCC="\$(PURIFY) \$(CXX)"
 496               fi
 497               rm -fr conftest*
 498         fi
 499         case $ac_sys_system in
 500         AIX*)
 501            exp_extra="\"\""
 502            if test $ac_sys_release -ge 5 -o \
 503                    $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
 504                exp_extra="."
 505            fi
 506            LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
 507         Monterey64*)
 508            LINKCC="$LINKCC -L/usr/lib/ia64l64";;
 509         esac
 510 fi
 511 AC_MSG_RESULT($LINKCC)
 512
 513 AC_MSG_CHECKING(for --enable-shared)
 514 AC_ARG_ENABLE(shared,
 515               AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
 516
 517 if test -z "$enable_shared"
 518 then
 519   case $ac_sys_system in
 520   CYGWIN* | atheos*)
 521     enable_shared="yes";;
 522   *)
 523     enable_shared="no";;
 524   esac
 525 fi
 526 AC_MSG_RESULT($enable_shared)
 527
 528 AC_MSG_CHECKING(for --enable-profiling)
 529 AC_ARG_ENABLE(profiling,
 530               AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
 531 [ac_save_cc="$CC"
 532  CC="$CC -pg"
 533  AC_TRY_RUN([int main() { return 0; }],
 534    ac_enable_profiling="yes",
 535    ac_enable_profiling="no",
 536    ac_enable_profiling="no")
 537  CC="$ac_save_cc"])
 538 AC_MSG_RESULT($ac_enable_profiling)
 539
 540 case "$ac_enable_profiling" in
 541     "yes")
 542         BASECFLAGS="-pg $BASECFLAGS"
 543         LDFLAGS="-pg $LDFLAGS"
 544     ;;
 545 esac
 546
 547 AC_MSG_CHECKING(LDLIBRARY)
 548
 549 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
 550 # library that we build, but we do not want to link against it (we
 551 # will find it with a -framework option). For this reason there is an
 552 # extra variable BLDLIBRARY against which Python and the extension
 553 # modules are linked, BLDLIBRARY. This is normally the same as
 554 # LDLIBRARY, but empty for MacOSX framework builds.
 555 if test "$enable_framework"
 556 then
 557   LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
 558   RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
 559   BLDLIBRARY=''
 560 else
 561   BLDLIBRARY='$(LDLIBRARY)'
 562 fi
 563
 564 # Other platforms follow
 565 if test $enable_shared = "yes"; then
 566   AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
 567   case $ac_sys_system in
 568     BeOS*)
 569           LDLIBRARY='libpython$(VERSION).so'
 570           ;;
 571     CYGWIN*)
 572           LDLIBRARY='libpython$(VERSION).dll.a'
 573           DLLLIBRARY='libpython$(VERSION).dll'
 574           ;;
 575     SunOS*)
 576           LDLIBRARY='libpython$(VERSION).so'
 577           BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
 578           RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
 579           INSTSONAME="$LDLIBRARY".$SOVERSION
 580           ;;
 581     Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
 582           LDLIBRARY='libpython$(VERSION).so'
 583           BLDLIBRARY='-L. -lpython$(VERSION)'
 584           RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
 585           case $ac_sys_system in
 586               FreeBSD*)
 587                 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
 588                 ;;
 589           esac
 590           INSTSONAME="$LDLIBRARY".$SOVERSION
 591           ;;
 592     hp*|HP*)
 593           LDLIBRARY='libpython$(VERSION).sl'
 594           BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
 595           RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
 596           ;;
 597     OSF*)
 598           LDLIBRARY='libpython$(VERSION).so'
 599           BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
 600           RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
 601           ;;
 602     atheos*)
 603           LDLIBRARY='libpython$(VERSION).so'
 604           BLDLIBRARY='-L. -lpython$(VERSION)'
 605           RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
 606           ;;
 607   esac
 608 else # shared is disabled
 609   case $ac_sys_system in
 610     CYGWIN*)
 611           BLDLIBRARY='$(LIBRARY)'
 612           LDLIBRARY='libpython$(VERSION).dll.a'
 613           ;;
 614   esac
 615 fi
 616
 617 AC_MSG_RESULT($LDLIBRARY)
 618
 619 AC_PROG_RANLIB
 620 AC_SUBST(AR)
 621 AC_CHECK_PROGS(AR, ar aal, ar)
 622
 623 AC_SUBST(SVNVERSION)
 624 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
 625 if test $SVNVERSION = found
 626 then
 627         SVNVERSION="svnversion \$(srcdir)"
 628 else
 629         SVNVERSION="echo exported"
 630 fi
 631
 632 case $MACHDEP in
 633 bsdos*|hp*|HP*)
 634         # install -d does not work on BSDI or HP-UX
 635         if test -z "$INSTALL"
 636         then
 637                 INSTALL="${srcdir}/install-sh -c"
 638         fi
 639 esac
 640 AC_PROG_INSTALL
 641
 642 # Not every filesystem supports hard links
 643 AC_SUBST(LN)
 644 if test -z "$LN" ; then
 645         case $ac_sys_system in
 646                 BeOS*) LN="ln -s";;
 647                 CYGWIN*) LN="ln -s";;
 648                 atheos*) LN="ln -s";;
 649                 *) LN=ln;;
 650         esac
 651 fi
 652
 653 # Check for --with-pydebug
 654 AC_MSG_CHECKING(for --with-pydebug)
 655 AC_ARG_WITH(pydebug,
 656             AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
 657 [
 658 if test "$withval" != no
 659 then
 660   AC_DEFINE(Py_DEBUG, 1,
 661   [Define if you want to build an interpreter with many run-time checks.])
 662   AC_MSG_RESULT(yes);
 663   Py_DEBUG='true'
 664 else AC_MSG_RESULT(no); Py_DEBUG='false'
 665 fi],
 666 [AC_MSG_RESULT(no)])
 667
 668 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
 669 # merged with this chunk of code?
 670
 671 # Optimizer/debugger flags
 672 # ------------------------
 673 # (The following bit of code is complicated enough - please keep things
 674 # indented properly.  Just pretend you're editing Python code. ;-)
 675
 676 # There are two parallel sets of case statements below, one that checks to
 677 # see if OPT was set and one that does BASECFLAGS setting based upon
 678 # compiler and platform.  BASECFLAGS tweaks need to be made even if the
 679 # user set OPT.
 680
 681 # tweak OPT based on compiler and platform, only if the user didn't set
 682 # it on the command line
 683 AC_SUBST(OPT)
 684 if test -z "$OPT"
 685 then
 686     case $GCC in
 687     yes)
 688         case $ac_cv_prog_cc_g in
 689         yes)
 690             if test "$Py_DEBUG" = 'true' ; then
 691                 # Optimization messes up debuggers, so turn it off for
 692                 # debug builds.
 693                 OPT="-g -Wall -Wstrict-prototypes"
 694             else
 695                 OPT="-g -O3 -Wall -Wstrict-prototypes"
 696             fi
 697             ;;
 698         *)
 699             OPT="-O3 -Wall -Wstrict-prototypes"
 700             ;;
 701         esac
 702         case $ac_sys_system in
 703             SCO_SV*) OPT="$OPT -m486 -DSCO5"
 704             ;;
 705         esac
 706         ;;
 707
 708     *)
 709         OPT="-O"
 710         ;;
 711     esac
 712
 713     # The current (beta) Monterey compiler dies with optimizations
 714     # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
 715     case $ac_sys_system in
 716         Monterey*)
 717             OPT=""
 718             ;;
 719     esac
 720
 721 fi
 722
 723 AC_SUBST(BASECFLAGS)
 724 # tweak BASECFLAGS based on compiler and platform
 725 case $GCC in
 726 yes)
 727     # Python violates C99 rules, by casting between incompatible
 728     # pointer types. GCC may generate bad code as a result of that,
 729     # so use -fno-strict-aliasing if supported.
 730     AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
 731      ac_save_cc="$CC"
 732      CC="$CC -fno-strict-aliasing"
 733      AC_TRY_RUN([int main() { return 0; }],
 734      ac_cv_no_strict_aliasing_ok=yes,
 735      ac_cv_no_strict_aliasing_ok=no,
 736      ac_cv_no_strict_aliasing_ok=no)
 737      CC="$ac_save_cc"
 738     AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
 739     if test $ac_cv_no_strict_aliasing_ok = yes
 740     then
 741       BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
 742     fi
 743     case $ac_sys_system in
 744         SCO_SV*)
 745             BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
 746             ;;
 747         # is there any other compiler on Darwin besides gcc?
 748         Darwin*)
 749             BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
 750             ;;
 751         OSF*)
 752             BASECFLAGS="$BASECFLAGS -mieee"
 753             ;;
 754     esac
 755     ;;
 756
 757 *)
 758     case $ac_sys_system in
 759     OpenUNIX*|UnixWare*)
 760         BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
 761         ;;
 762     OSF*)
 763         BASECFLAGS="$BASECFLAGS -ieee -std"
 764         ;;
 765     SCO_SV*)
 766         BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
 767         ;;
 768     esac
 769     ;;
 770 esac
 771
 772 if test "$Py_DEBUG" = 'true'; then
 773   :
 774 else
 775   OPT="-DNDEBUG $OPT"
 776 fi
 777
 778 if test "$ac_arch_flags"
 779 then
 780         BASECFLAGS="$BASECFLAGS $ac_arch_flags"
 781 fi
 782
 783 # disable check for icc since it seems to pass, but generates a warning
 784 if test "$CC" = icc
 785 then
 786   ac_cv_opt_olimit_ok=no
 787 fi
 788
 789 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
 790 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
 791 [ac_save_cc="$CC"
 792 CC="$CC -OPT:Olimit=0"
 793 AC_TRY_RUN([int main() { return 0; }],
 794   ac_cv_opt_olimit_ok=yes,
 795   ac_cv_opt_olimit_ok=no,
 796   ac_cv_opt_olimit_ok=no)
 797 CC="$ac_save_cc"])
 798 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
 799 if test $ac_cv_opt_olimit_ok = yes; then
 800     case $ac_sys_system in
 801         # XXX is this branch needed? On MacOSX 10.2.2 the result of the
 802         # olimit_ok test is "no".  Is it "yes" in some other Darwin-esque
 803         # environment?
 804         Darwin*)
 805             ;;
 806         *)
 807             BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
 808             ;;
 809     esac
 810 else
 811   AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
 812   AC_CACHE_VAL(ac_cv_olimit_ok,
 813   [ac_save_cc="$CC"
 814   CC="$CC -Olimit 1500"
 815   AC_TRY_RUN([int main() { return 0; }],
 816     ac_cv_olimit_ok=yes,
 817     ac_cv_olimit_ok=no,
 818     ac_cv_olimit_ok=no)
 819   CC="$ac_save_cc"])
 820   AC_MSG_RESULT($ac_cv_olimit_ok)
 821   if test $ac_cv_olimit_ok = yes; then
 822     BASECFLAGS="$BASECFLAGS -Olimit 1500"
 823   fi
 824 fi
 825
 826 # On some compilers, pthreads are available without further options
 827 # (e.g. MacOS X). On some of these systems, the compiler will not
 828 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
 829 # So we have to see first whether pthreads are available without
 830 # options before we can check whether -Kpthread improves anything.
 831 AC_MSG_CHECKING(whether pthreads are available without options)
 832 AC_CACHE_VAL(ac_cv_pthread_is_default,
 833 [AC_TRY_RUN([
 834 #include <pthread.h>
 835
 836 void* routine(void* p){return NULL;}
 837
 838 int main(){
 839   pthread_t p;
 840   if(pthread_create(&p,NULL,routine,NULL)!=0)
 841     return 1;
 842   (void)pthread_detach(p);
 843   return 0;
 844 }
 845 ],
 846 [
 847   ac_cv_pthread_is_default=yes
 848   ac_cv_kthread=no
 849   ac_cv_pthread=no
 850 ],
 851   ac_cv_pthread_is_default=no,
 852   ac_cv_pthread_is_default=no)
 853 ])
 854 AC_MSG_RESULT($ac_cv_pthread_is_default)
 855
 856
 857 if test $ac_cv_pthread_is_default = yes
 858 then
 859   ac_cv_kpthread=no
 860 else
 861 # -Kpthread, if available, provides the right #defines
 862 # and linker options to make pthread_create available
 863 # Some compilers won't report that they do not support -Kpthread,
 864 # so we need to run a program to see whether it really made the
 865 # function available.
 866 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
 867 AC_CACHE_VAL(ac_cv_kpthread,
 868 [ac_save_cc="$CC"
 869 CC="$CC -Kpthread"
 870 AC_TRY_RUN([
 871 #include <pthread.h>
 872
 873 void* routine(void* p){return NULL;}
 874
 875 int main(){
 876   pthread_t p;
 877   if(pthread_create(&p,NULL,routine,NULL)!=0)
 878     return 1;
 879   (void)pthread_detach(p);
 880   return 0;
 881 }
 882 ],
 883   ac_cv_kpthread=yes,
 884   ac_cv_kpthread=no,
 885   ac_cv_kpthread=no)
 886 CC="$ac_save_cc"])
 887 AC_MSG_RESULT($ac_cv_kpthread)
 888 fi
 889
 890 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
 891 then
 892 # -Kthread, if available, provides the right #defines
 893 # and linker options to make pthread_create available
 894 # Some compilers won't report that they do not support -Kthread,
 895 # so we need to run a program to see whether it really made the
 896 # function available.
 897 AC_MSG_CHECKING(whether $CC accepts -Kthread)
 898 AC_CACHE_VAL(ac_cv_kthread,
 899 [ac_save_cc="$CC"
 900 CC="$CC -Kthread"
 901 AC_TRY_RUN([
 902 #include <pthread.h>
 903
 904 void* routine(void* p){return NULL;}
 905
 906 int main(){
 907   pthread_t p;
 908   if(pthread_create(&p,NULL,routine,NULL)!=0)
 909     return 1;
 910   (void)pthread_detach(p);
 911   return 0;
 912 }
 913 ],
 914   ac_cv_kthread=yes,
 915   ac_cv_kthread=no,
 916   ac_cv_kthread=no)
 917 CC="$ac_save_cc"])
 918 AC_MSG_RESULT($ac_cv_kthread)
 919 fi
 920
 921 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
 922 then
 923 # -pthread, if available, provides the right #defines
 924 # and linker options to make pthread_create available
 925 # Some compilers won't report that they do not support -pthread,
 926 # so we need to run a program to see whether it really made the
 927 # function available.
 928 AC_MSG_CHECKING(whether $CC accepts -pthread)
 929 AC_CACHE_VAL(ac_cv_thread,
 930 [ac_save_cc="$CC"
 931 CC="$CC -pthread"
 932 AC_TRY_RUN([
 933 #include <pthread.h>
 934
 935 void* routine(void* p){return NULL;}
 936
 937 int main(){
 938   pthread_t p;
 939   if(pthread_create(&p,NULL,routine,NULL)!=0)
 940     return 1;
 941   (void)pthread_detach(p);
 942   return 0;
 943 }
 944 ],
 945   ac_cv_pthread=yes,
 946   ac_cv_pthread=no,
 947   ac_cv_pthread=no)
 948 CC="$ac_save_cc"])
 949 AC_MSG_RESULT($ac_cv_pthread)
 950 fi
 951
 952 # If we have set a CC compiler flag for thread support then
 953 # check if it works for CXX, too.
 954 ac_cv_cxx_thread=no
 955 if test ! -z "$CXX"
 956 then
 957 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
 958 ac_save_cxx="$CXX"
 959
 960 if test "$ac_cv_kpthread" = "yes"
 961 then
 962   CXX="$CXX -Kpthread"
 963   ac_cv_cxx_thread=yes
 964 elif test "$ac_cv_kthread" = "yes"
 965 then
 966   CXX="$CXX -Kthread"
 967   ac_cv_cxx_thread=yes
 968 elif test "$ac_cv_pthread" = "yes"
 969 then
 970   CXX="$CXX -pthread"
 971   ac_cv_cxx_thread=yes
 972 fi
 973
 974 if test $ac_cv_cxx_thread = yes
 975 then
 976   echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
 977   $CXX -c conftest.$ac_ext 2>&5
 978   if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
 979      && test -s conftest$ac_exeext && ./conftest$ac_exeext
 980   then
 981     ac_cv_cxx_thread=yes
 982   else
 983     ac_cv_cxx_thread=no
 984   fi
 985   rm -fr conftest*
 986 fi
 987 AC_MSG_RESULT($ac_cv_cxx_thread)
 988 fi
 989 CXX="$ac_save_cxx"
 990
 991 dnl # check for ANSI or K&R ("traditional") preprocessor
 992 dnl AC_MSG_CHECKING(for C preprocessor type)
 993 dnl AC_TRY_COMPILE([
 994 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
 995 dnl int foo;
 996 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
 997 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
 998 dnl AC_MSG_RESULT($cpp_type)
 999
1000 # checks for header files
1001 AC_HEADER_STDC
1002 AC_CHECK_HEADERS(asm/types.h curses.h dlfcn.h fcntl.h grp.h \
1003 shadow.h langinfo.h libintl.h ncurses.h poll.h pthread.h \
1004 stropts.h termios.h thread.h \
1005 unistd.h utime.h \
1006 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1007 sys/modem.h \
1008 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/time.h sys/times.h \
1009 sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1010 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1011 bluetooth/bluetooth.h)
1012 AC_HEADER_DIRENT
1013 AC_HEADER_MAJOR
1014
1015 # On Solaris, term.h requires curses.h
1016 AC_CHECK_HEADERS(term.h,,,[
1017 #ifdef HAVE_CURSES_H
1018 #include <curses.h>
1019 #endif
1020 ])
1021
1022 # On Linux, netlink.h requires asm/types.h
1023 AC_CHECK_HEADERS(linux/netlink.h,,,[
1024 #ifdef HAVE_ASM_TYPES_H
1025 #include <asm/types.h>
1026 #endif
1027 #ifdef HAVE_SYS_SOCKET_H
1028 #include <sys/socket.h>
1029 #endif
1030 ])
1031
1032 # checks for typedefs
1033 was_it_defined=no
1034 AC_MSG_CHECKING(for clock_t in time.h)
1035 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1036     AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1037 ])
1038 AC_MSG_RESULT($was_it_defined)
1039
1040 # Check whether using makedev requires defining _OSF_SOURCE
1041 AC_MSG_CHECKING(for makedev)
1042 AC_TRY_LINK([#include <sys/types.h> ],
1043             [ makedev(0, 0) ],
1044             ac_cv_has_makedev=yes,
1045             ac_cv_has_makedev=no)
1046 if test "$ac_cv_has_makedev" = "no"; then
1047     # we didn't link, try if _OSF_SOURCE will allow us to link
1048     AC_TRY_LINK([
1049 #define _OSF_SOURCE 1
1050 #include <sys/types.h>
1051     ],
1052     [ makedev(0, 0) ],
1053     ac_cv_has_makedev=yes,
1054     ac_cv_has_makedev=no)
1055     if test "$ac_cv_has_makedev" = "yes"; then
1056         AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1057     fi
1058 fi
1059 AC_MSG_RESULT($ac_cv_has_makedev)
1060 if test "$ac_cv_has_makedev" = "yes"; then
1061     AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1062 fi
1063
1064 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1065 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1066 # defined, but the compiler does not support pragma redefine_extname,
1067 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1068 # structures (such as rlimit64) without declaring them. As a
1069 # work-around, disable LFS on such configurations
1070
1071 use_lfs=yes
1072 AC_MSG_CHECKING(Solaris LFS bug)
1073 AC_TRY_COMPILE([
1074 #define _LARGEFILE_SOURCE 1
1075 #define _FILE_OFFSET_BITS 64
1076 #include <sys/resource.h>
1077 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1078 AC_MSG_RESULT($sol_lfs_bug)
1079 if test "$sol_lfs_bug" = "yes"; then
1080   use_lfs=no
1081 fi
1082
1083 if test "$use_lfs" = "yes"; then
1084 # Two defines needed to enable largefile support on various platforms
1085 # These may affect some typedefs
1086 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1087 [This must be defined on some systems to enable large file support.])
1088 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1089 [This must be set to 64 on some systems to enable large file support.])
1090 fi
1091
1092 # Add some code to confdefs.h so that the test for off_t works on SCO
1093 cat >> confdefs.h <<\EOF
1094 #if defined(SCO_DS)
1095 #undef _OFF_T
1096 #endif
1097 EOF
1098
1099 # Type availability checks
1100 AC_TYPE_MODE_T
1101 AC_TYPE_OFF_T
1102 AC_TYPE_PID_T
1103 AC_TYPE_SIGNAL
1104 AC_TYPE_SIZE_T
1105 AC_TYPE_UID_T
1106 AC_CHECK_TYPE(ssize_t,
1107   AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1108
1109 # Sizes of various common basic types
1110 # ANSI C requires sizeof(char) == 1, so no need to check it
1111 AC_CHECK_SIZEOF(int, 4)
1112 AC_CHECK_SIZEOF(long, 4)
1113 AC_CHECK_SIZEOF(void *, 4)
1114 AC_CHECK_SIZEOF(short, 2)
1115 AC_CHECK_SIZEOF(float, 4)
1116 AC_CHECK_SIZEOF(double, 8)
1117 AC_CHECK_SIZEOF(fpos_t, 4)
1118 AC_CHECK_SIZEOF(size_t, 4)
1119
1120 AC_MSG_CHECKING(for long long support)
1121 have_long_long=no
1122 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1123   AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1124   have_long_long=yes
1125 ])
1126 AC_MSG_RESULT($have_long_long)
1127 if test "$have_long_long" = yes ; then
1128 AC_CHECK_SIZEOF(long long, 8)
1129 fi
1130
1131 AC_MSG_CHECKING(for uintptr_t support)
1132 have_uintptr_t=no
1133 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1134   AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1135   have_uintptr_t=yes
1136 ])
1137 AC_MSG_RESULT($have_uintptr_t)
1138 if test "$have_uintptr_t" = yes ; then
1139 AC_CHECK_SIZEOF(uintptr_t, 4)
1140 fi
1141
1142 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1143 AC_MSG_CHECKING(size of off_t)
1144 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1145 [AC_TRY_RUN([#include <stdio.h>
1146 #include <sys/types.h>
1147 main()
1148 {
1149   FILE *f=fopen("conftestval", "w");
1150   if (!f) exit(1);
1151   fprintf(f, "%d\n", sizeof(off_t));
1152   exit(0);
1153 }],
1154 ac_cv_sizeof_off_t=`cat conftestval`,
1155 ac_cv_sizeof_off_t=0,
1156 ac_cv_sizeof_off_t=4)
1157 ])
1158 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1159 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1160 [The number of bytes in an off_t.])
1161
1162 AC_MSG_CHECKING(whether to enable large file support)
1163 if test "$have_long_long" = yes -a \
1164         "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1165         "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1166   AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1167   [Defined to enable large file support when an off_t is bigger than a long
1168    and long long is available and at least as big as an off_t. You may need
1169    to add some flags for configuration and compilation to enable this mode.
1170    (For Solaris and Linux, the necessary defines are already defined.)])
1171   AC_MSG_RESULT(yes)
1172 else
1173   AC_MSG_RESULT(no)
1174 fi
1175
1176 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1177 AC_MSG_CHECKING(size of time_t)
1178 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1179 [AC_TRY_RUN([#include <stdio.h>
1180 #include <time.h>
1181 main()
1182 {
1183   FILE *f=fopen("conftestval", "w");
1184   if (!f) exit(1);
1185   fprintf(f, "%d\n", sizeof(time_t));
1186   exit(0);
1187 }],
1188 ac_cv_sizeof_time_t=`cat conftestval`,
1189 ac_cv_sizeof_time_t=0,
1190 ac_cv_sizeof_time_t=4)
1191 ])
1192 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1193 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1194 [The number of bytes in a time_t.])
1195
1196
1197 # if have pthread_t then define SIZEOF_PTHREAD_T
1198 ac_save_cc="$CC"
1199 if test "$ac_cv_kpthread" = "yes"
1200 then CC="$CC -Kpthread"
1201 elif test "$ac_cv_kthread" = "yes"
1202 then CC="$CC -Kthread"
1203 elif test "$ac_cv_pthread" = "yes"
1204 then CC="$CC -pthread"
1205 fi
1206 AC_MSG_CHECKING(for pthread_t)
1207 have_pthread_t=no
1208 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1209 AC_MSG_RESULT($have_pthread_t)
1210 if test "$have_pthread_t" = yes ; then
1211   # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1212   AC_MSG_CHECKING(size of pthread_t)
1213   AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1214   [AC_TRY_RUN([#include <stdio.h>
1215 #include <pthread.h>
1216   main()
1217   {
1218     FILE *f=fopen("conftestval", "w");
1219     if (!f) exit(1);
1220     fprintf(f, "%d\n", sizeof(pthread_t));
1221     exit(0);
1222   }],
1223   ac_cv_sizeof_pthread_t=`cat conftestval`,
1224   ac_cv_sizeof_pthread_t=0,
1225   ac_cv_sizeof_pthread_t=4)
1226   ])
1227   AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1228   AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1229    [The number of bytes in a pthread_t.])
1230 fi
1231 CC="$ac_save_cc"
1232
1233 AC_MSG_CHECKING(for --enable-toolbox-glue)
1234 AC_ARG_ENABLE(toolbox-glue,
1235               AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1236
1237 if test -z "$enable_toolbox_glue"
1238 then
1239         case $ac_sys_system/$ac_sys_release in
1240         Darwin/*)
1241                 enable_toolbox_glue="yes";;
1242         *)
1243                 enable_toolbox_glue="no";;
1244         esac
1245 fi
1246 case "$enable_toolbox_glue" in
1247 yes)
1248         extra_machdep_objs="Python/mactoolboxglue.o"
1249         extra_undefs="-u _PyMac_Error"
1250         AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1251          [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1252         ;;
1253 *)
1254         extra_machdep_objs=""
1255         extra_undefs=""
1256         ;;
1257 esac
1258 AC_MSG_RESULT($enable_toolbox_glue)
1259
1260 AC_SUBST(OTHER_LIBTOOL_OPT)
1261 case $ac_sys_system/$ac_sys_release in
1262   Darwin/@<:@01234567@:>@.*)
1263     OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1264     ;;
1265   Darwin/*)
1266     OTHER_LIBTOOL_OPT=""
1267     ;;
1268 esac
1269
1270 AC_SUBST(LIBTOOL_CRUFT)
1271 case $ac_sys_system/$ac_sys_release in
1272   Darwin/@<:@01234567@:>@.*)
1273     LIBTOOL_CRUFT="-framework System -lcc_dynamic -arch_only `arch`"
1274     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1275     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1276   Darwin/*)
1277     gcc_version=`gcc -v 2>&1 |  grep version | cut -d\  -f3`
1278     if test ${gcc_version} '<' 4.0
1279         then
1280             LIBTOOL_CRUFT="-lcc_dynamic"
1281         else
1282             LIBTOOL_CRUFT=""
1283     fi
1284     LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1285     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1286     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1287 esac
1288
1289 AC_MSG_CHECKING(for --enable-framework)
1290 if test "$enable_framework"
1291 then
1292         BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1293         # -F. is needed to allow linking to the framework while
1294         # in the build location.
1295         AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1296          [Define if you want to produce an OpenStep/Rhapsody framework
1297          (shared library plus accessory files).])
1298         AC_MSG_RESULT(yes)
1299 else
1300         AC_MSG_RESULT(no)
1301 fi
1302
1303 AC_MSG_CHECKING(for dyld)
1304 case $ac_sys_system/$ac_sys_release in
1305   Darwin/*)
1306         AC_DEFINE(WITH_DYLD, 1,
1307         [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1308          dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1309          linker (rld). Dyld is necessary to support frameworks.])
1310         AC_MSG_RESULT(always on for Darwin)
1311         ;;
1312   *)
1313         AC_MSG_RESULT(no)
1314         ;;
1315 esac
1316
1317 # Set info about shared libraries.
1318 AC_SUBST(SO)
1319 AC_SUBST(LDSHARED)
1320 AC_SUBST(BLDSHARED)
1321 AC_SUBST(CCSHARED)
1322 AC_SUBST(LINKFORSHARED)
1323 # SO is the extension of shared libraries `(including the dot!)
1324 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1325 AC_MSG_CHECKING(SO)
1326 if test -z "$SO"
1327 then
1328         case $ac_sys_system in
1329         hp*|HP*)   SO=.sl;;
1330         CYGWIN*)   SO=.dll;;
1331         *)         SO=.so;;
1332         esac
1333 else
1334         # this might also be a termcap variable, see #610332
1335         echo
1336         echo '====================================================================='
1337         echo '+                                                                   +'
1338         echo '+ WARNING: You have set SO in your environment.                     +'
1339         echo '+ Do you really mean to change the extension for shared libraries?  +'
1340         echo '+ Continuing in 10 seconds to let you to ponder.                    +'
1341         echo '+                                                                   +'
1342         echo '====================================================================='
1343         sleep 10
1344 fi
1345 AC_MSG_RESULT($SO)
1346 # LDSHARED is the ld *command* used to create shared library
1347 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1348 # (Shared libraries in this instance are shared modules to be loaded into
1349 # Python, as opposed to building Python itself as a shared library.)
1350 AC_MSG_CHECKING(LDSHARED)
1351 if test -z "$LDSHARED"
1352 then
1353         case $ac_sys_system/$ac_sys_release in
1354         AIX*)
1355                 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1356                 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1357                 ;;
1358         BeOS*)
1359                 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1360                 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1361                 ;;
1362         IRIX/5*) LDSHARED="ld -shared";;
1363         IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1364         SunOS/5*)
1365                 if test "$GCC" = "yes"
1366                 then LDSHARED='$(CC) -shared'
1367                 else LDSHARED='$(CC) -G';
1368                 fi ;;
1369         hp*|HP*) LDSHARED="ld -b";;
1370         OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1371         Darwin/1.3*)
1372                 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1373                 if test "$enable_framework" ; then
1374                         # Link against the framework. All externals should be defined.
1375                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1376                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1377                 else
1378                         # No framework. Ignore undefined symbols, assuming they come from Python
1379                         LDSHARED="$LDSHARED -undefined suppress"
1380                 fi ;;
1381         Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1382                 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1383                 if test "$enable_framework" ; then
1384                         # Link against the framework. All externals should be defined.
1385                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1386                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1387                 else
1388                         # No framework, use the Python app as bundle-loader
1389                         BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1390                         LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1391                 fi ;;
1392         Darwin/*)
1393                 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1394                 # This allows an extension to be used in any Python
1395                 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1396                 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1397                 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1398                 then
1399                         LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1400                         BLDSHARED="$LDSHARED"
1401                 else
1402                         LDSHARED='$(CC) $(LDFLAGS) -bundle'
1403                         if test "$enable_framework" ; then
1404                                 # Link against the framework. All externals should be defined.
1405                                 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1406                                 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1407                         else
1408                                 # No framework, use the Python app as bundle-loader
1409                                 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1410                                 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1411                         fi
1412                 fi
1413                 ;;
1414         Linux*|GNU*) LDSHARED='$(CC) -shared';;
1415         BSD/OS*/4*) LDSHARED="gcc -shared";;
1416         OpenBSD*|FreeBSD*)
1417                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1418                 then
1419                         LDSHARED="$CC -shared ${LDFLAGS}"
1420                 else
1421                         LDSHARED="ld -Bshareable ${LDFLAGS}"
1422                 fi;;
1423         NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1424         OpenUNIX*|UnixWare*)
1425                 if test "$GCC" = "yes"
1426                 then LDSHARED='$(CC) -shared'
1427                 else LDSHARED='$(CC) -G'
1428                 fi;;
1429         SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1430         Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1431         CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1432         atheos*) LDSHARED="gcc -shared";;
1433         *)      LDSHARED="ld";;
1434         esac
1435 fi
1436 AC_MSG_RESULT($LDSHARED)
1437 BLDSHARED=${BLDSHARED-$LDSHARED}
1438 # CCSHARED are the C *flags* used to create objects to go into a shared
1439 # library (module) -- this is only needed for a few systems
1440 AC_MSG_CHECKING(CCSHARED)
1441 if test -z "$CCSHARED"
1442 then
1443         case $ac_sys_system/$ac_sys_release in
1444         SunOS*) if test "$GCC" = yes;
1445                 then CCSHARED="-fPIC";
1446                 else CCSHARED="-xcode=pic32";
1447                 fi;;
1448         hp*|HP*) if test "$GCC" = yes;
1449                  then CCSHARED="-fPIC";
1450                  else CCSHARED="+z";
1451                  fi;;
1452         Linux*|GNU*) CCSHARED="-fPIC";;
1453         BSD/OS*/4*) CCSHARED="-fpic";;
1454         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1455         OpenUNIX*|UnixWare*)
1456                 if test "$GCC" = "yes"
1457                 then CCSHARED="-fPIC"
1458                 else CCSHARED="-KPIC"
1459                 fi;;
1460         SCO_SV*)
1461                 if test "$GCC" = "yes"
1462                 then CCSHARED="-fPIC"
1463                 else CCSHARED="-Kpic -belf"
1464                 fi;;
1465         Monterey*) CCSHARED="-G";;
1466         IRIX*/6*)  case $CC in
1467                    *gcc*) CCSHARED="-shared";;
1468                    *) CCSHARED="";;
1469                    esac;;
1470         atheos*) CCSHARED="-fPIC";;
1471         esac
1472 fi
1473 AC_MSG_RESULT($CCSHARED)
1474 # LINKFORSHARED are the flags passed to the $(CC) command that links
1475 # the python executable -- this is only needed for a few systems
1476 AC_MSG_CHECKING(LINKFORSHARED)
1477 if test -z "$LINKFORSHARED"
1478 then
1479         case $ac_sys_system/$ac_sys_release in
1480         AIX*)   LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1481         hp*|HP*)
1482             LINKFORSHARED="-Wl,-E -Wl,+s";;
1483 #           LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1484         BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1485         Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1486         # -u libsys_s pulls in all symbols in libsys
1487         Darwin/*)
1488                 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1489                 # which is
1490                 # not used by the core itself but which needs to be in the core so
1491                 # that dynamically loaded extension modules have access to it.
1492                 # -prebind is no longer used, because it actually seems to give a
1493                 # slowdown in stead of a speedup, maybe due to the large number of
1494                 # dynamic loads Python does.
1495
1496                 LINKFORSHARED="$extra_undefs"
1497                 if test "$enable_framework"
1498                 then
1499                         LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1500                 fi
1501                 LINKFORSHARED="$LINKFORSHARED";;
1502         OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1503         SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1504         ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1505         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1506                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1507                 then
1508                         LINKFORSHARED="-Wl,--export-dynamic"
1509                 fi;;
1510         SunOS/5*) case $CC in
1511                   *gcc*)
1512                     if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1513                     then
1514                         LINKFORSHARED="-Xlinker --export-dynamic"
1515                     fi;;
1516                   esac;;
1517         CYGWIN*)
1518                 if test $enable_shared = "no"
1519                 then
1520                         LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1521                 fi;;
1522         esac
1523 fi
1524 AC_MSG_RESULT($LINKFORSHARED)
1525
1526 AC_SUBST(CFLAGSFORSHARED)
1527 AC_MSG_CHECKING(CFLAGSFORSHARED)
1528 if test ! "$LIBRARY" = "$LDLIBRARY"
1529 then
1530         case $ac_sys_system in
1531         CYGWIN*)
1532                 # Cygwin needs CCSHARED when building extension DLLs
1533                 # but not when building the interpreter DLL.
1534                 CFLAGSFORSHARED='';;
1535         *)
1536                 CFLAGSFORSHARED='$(CCSHARED)'
1537         esac
1538 fi
1539 AC_MSG_RESULT($CFLAGSFORSHARED)
1540
1541 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1542 # library (with --enable-shared).
1543 # For platforms on which shared libraries are not allowed to have unresolved
1544 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1545 # if it is not required, since it creates a dependency of the shared library
1546 # to LIBS. This, in turn, means that applications linking the shared libpython
1547 # don't need to link LIBS explicitly. The default should be only changed
1548 # on systems where this approach causes problems.
1549 AC_SUBST(SHLIBS)
1550 AC_MSG_CHECKING(SHLIBS)
1551 case "$ac_sys_system" in
1552         *)
1553                 SHLIBS='$(LIBS)';;
1554 esac
1555 AC_MSG_RESULT($SHLIBS)
1556
1557
1558 # checks for libraries
1559 AC_CHECK_LIB(dl, dlopen)        # Dynamic linking for SunOS/Solaris and SYSV
1560 AC_CHECK_LIB(dld, shl_load)     # Dynamic linking for HP-UX
1561
1562 # only check for sem_ini if thread support is requested
1563 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1564     AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1565                                                 # posix4 on Solaris 2.6
1566                                                 # pthread (first!) on Linux
1567 fi
1568
1569 # check if we need libintl for locale functions
1570 AC_CHECK_LIB(intl, textdomain,
1571         AC_DEFINE(WITH_LIBINTL, 1,
1572         [Define to 1 if libintl is needed for locale functions.]))
1573
1574 # checks for system dependent C++ extensions support
1575 case "$ac_sys_system" in
1576         AIX*)   AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1577                 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1578                             [loadAndInit("", 0, "")],
1579                             [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1580                       [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1581                        and you want support for AIX C++ shared extension modules.])
1582                              AC_MSG_RESULT(yes)],
1583                             [AC_MSG_RESULT(no)]);;
1584         *) ;;
1585 esac
1586
1587 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1588 # BeOS' sockets are stashed in libnet.
1589 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1590 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1591
1592 case "$ac_sys_system" in
1593 BeOS*)
1594 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1595 ;;
1596 esac
1597
1598 AC_MSG_CHECKING(for --with-libs)
1599 AC_ARG_WITH(libs,
1600             AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1601 [
1602 AC_MSG_RESULT($withval)
1603 LIBS="$withval $LIBS"
1604 ],
1605 [AC_MSG_RESULT(no)])
1606
1607 # Determine if signalmodule should be used.
1608 AC_SUBST(USE_SIGNAL_MODULE)
1609 AC_SUBST(SIGNAL_OBJS)
1610 AC_MSG_CHECKING(for --with-signal-module)
1611 AC_ARG_WITH(signal-module,
1612             AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1613
1614 if test -z "$with_signal_module"
1615 then with_signal_module="yes"
1616 fi
1617 AC_MSG_RESULT($with_signal_module)
1618
1619 if test "${with_signal_module}" = "yes"; then
1620         USE_SIGNAL_MODULE=""
1621         SIGNAL_OBJS=""
1622 else
1623         USE_SIGNAL_MODULE="#"
1624         SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1625 fi
1626
1627 # This is used to generate Setup.config
1628 AC_SUBST(USE_THREAD_MODULE)
1629 USE_THREAD_MODULE=""
1630
1631 AC_MSG_CHECKING(for --with-dec-threads)
1632 AC_SUBST(LDLAST)
1633 AC_ARG_WITH(dec-threads,
1634             AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1635 [
1636 AC_MSG_RESULT($withval)
1637 LDLAST=-threads
1638 if test "${with_thread+set}" != set; then
1639    with_thread="$withval";
1640 fi],
1641 [AC_MSG_RESULT(no)])
1642
1643 # Templates for things AC_DEFINEd more than once.
1644 # For a single AC_DEFINE, no template is needed.
1645 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1646 AH_TEMPLATE(_REENTRANT,
1647   [Define to force use of thread-safe errno, h_errno, and other functions])
1648 AH_TEMPLATE(WITH_THREAD,
1649   [Define if you want to compile in rudimentary thread support])
1650
1651 AC_MSG_CHECKING(for --with-threads)
1652 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1653 AC_ARG_WITH(threads,
1654             AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1655
1656 # --with-thread is deprecated, but check for it anyway
1657 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1658 AC_ARG_WITH(thread,
1659             AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1660             [with_threads=$with_thread])
1661
1662 if test -z "$with_threads"
1663 then with_threads="yes"
1664 fi
1665 AC_MSG_RESULT($with_threads)
1666
1667 AC_SUBST(THREADOBJ)
1668 if test "$with_threads" = "no"
1669 then
1670     USE_THREAD_MODULE="#"
1671 elif test "$ac_cv_pthread_is_default" = yes
1672 then
1673     AC_DEFINE(WITH_THREAD)
1674     # Defining _REENTRANT on system with POSIX threads should not hurt.
1675     AC_DEFINE(_REENTRANT)
1676     posix_threads=yes
1677     THREADOBJ="Python/thread.o"
1678 elif test "$ac_cv_kpthread" = "yes"
1679 then
1680     CC="$CC -Kpthread"
1681     if test "$ac_cv_cxx_thread" = "yes"; then
1682         CXX="$CXX -Kpthread"
1683     fi
1684     AC_DEFINE(WITH_THREAD)
1685     posix_threads=yes
1686     THREADOBJ="Python/thread.o"
1687 elif test "$ac_cv_kthread" = "yes"
1688 then
1689     CC="$CC -Kthread"
1690     if test "$ac_cv_cxx_thread" = "yes"; then
1691         CXX="$CXX -Kthread"
1692     fi
1693     AC_DEFINE(WITH_THREAD)
1694     posix_threads=yes
1695     THREADOBJ="Python/thread.o"
1696 elif test "$ac_cv_pthread" = "yes"
1697 then
1698     CC="$CC -pthread"
1699     if test "$ac_cv_cxx_thread" = "yes"; then
1700         CXX="$CXX -pthread"
1701     fi
1702     AC_DEFINE(WITH_THREAD)
1703     posix_threads=yes
1704     THREADOBJ="Python/thread.o"
1705 else
1706     if test ! -z "$with_threads" -a -d "$with_threads"
1707     then LDFLAGS="$LDFLAGS -L$with_threads"
1708     fi
1709     if test ! -z "$withval" -a -d "$withval"
1710     then LDFLAGS="$LDFLAGS -L$withval"
1711     fi
1712
1713     # According to the POSIX spec, a pthreads implementation must
1714     # define _POSIX_THREADS in unistd.h. Some apparently don't
1715     # (e.g. gnu pth with pthread emulation)
1716     AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1717     AC_EGREP_CPP(yes,
1718     [
1719 #include <unistd.h>
1720 #ifdef _POSIX_THREADS
1721 yes
1722 #endif
1723     ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1724     AC_MSG_RESULT($unistd_defines_pthreads)
1725
1726     AC_DEFINE(_REENTRANT)
1727     AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1728     AC_DEFINE(C_THREADS)
1729     AC_DEFINE(HURD_C_THREADS, 1,
1730     [Define if you are using Mach cthreads directly under /include])
1731     LIBS="$LIBS -lthreads"
1732     THREADOBJ="Python/thread.o"],[
1733     AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1734     AC_DEFINE(C_THREADS)
1735     AC_DEFINE(MACH_C_THREADS, 1,
1736     [Define if you are using Mach cthreads under mach /])
1737     THREADOBJ="Python/thread.o"],[
1738     AC_MSG_CHECKING(for --with-pth)
1739     AC_ARG_WITH([pth],
1740                 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1741                 [AC_MSG_RESULT($withval)
1742                   AC_DEFINE([WITH_THREAD])
1743                   AC_DEFINE([HAVE_PTH], 1,
1744                             [Define if you have GNU PTH threads.])
1745                   LIBS="-lpth $LIBS"
1746                   THREADOBJ="Python/thread.o"],
1747                 [AC_MSG_RESULT(no)
1748
1749     # Just looking for pthread_create in libpthread is not enough:
1750     # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1751     # So we really have to include pthread.h, and then link.
1752     _libs=$LIBS
1753     LIBS="$LIBS -lpthread"
1754     AC_MSG_CHECKING([for pthread_create in -lpthread])
1755     AC_TRY_LINK([#include <pthread.h>
1756
1757 void * start_routine (void *arg) { exit (0); }], [
1758 pthread_create (NULL, NULL, start_routine, NULL)], [
1759     AC_MSG_RESULT(yes)
1760     AC_DEFINE(WITH_THREAD)
1761     posix_threads=yes
1762     THREADOBJ="Python/thread.o"],[
1763     LIBS=$_libs
1764     AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1765     posix_threads=yes
1766     THREADOBJ="Python/thread.o"],[
1767     AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1768     AC_DEFINE(ATHEOS_THREADS, 1,
1769     [Define this if you have AtheOS threads.])
1770     THREADOBJ="Python/thread.o"],[
1771     AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1772     AC_DEFINE(BEOS_THREADS, 1,
1773     [Define this if you have BeOS threads.])
1774     THREADOBJ="Python/thread.o"],[
1775     AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1776     posix_threads=yes
1777     LIBS="$LIBS -lpthreads"
1778     THREADOBJ="Python/thread.o"], [
1779     AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1780     posix_threads=yes
1781     LIBS="$LIBS -lc_r"
1782     THREADOBJ="Python/thread.o"], [
1783     AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1784     posix_threads=yes
1785     LIBS="$LIBS -lpthread"
1786     THREADOBJ="Python/thread.o"], [
1787     AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1788     posix_threads=yes
1789     LIBS="$LIBS -lcma"
1790     THREADOBJ="Python/thread.o"],[
1791     USE_THREAD_MODULE="#"])
1792     ])])])])])])])])])])
1793
1794     AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1795     LIBS="$LIBS -lmpc"
1796     THREADOBJ="Python/thread.o"
1797     USE_THREAD_MODULE=""])
1798
1799     if test "$posix_threads" != "yes"; then
1800       AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1801       LIBS="$LIBS -lthread"
1802       THREADOBJ="Python/thread.o"
1803       USE_THREAD_MODULE=""])
1804     fi
1805
1806     if test "$USE_THREAD_MODULE" != "#"
1807     then
1808         # If the above checks didn't disable threads, (at least) OSF1
1809         # needs this '-threads' argument during linking.
1810         case $ac_sys_system in
1811         OSF1) LDLAST=-threads;;
1812         esac
1813     fi
1814 fi
1815
1816 if test "$posix_threads" = "yes"; then
1817       if test "$unistd_defines_pthreads" = "no"; then
1818          AC_DEFINE(_POSIX_THREADS, 1,
1819          [Define if you have POSIX threads,
1820           and your system does not define that.])
1821       fi
1822
1823       # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1824       case  $ac_sys_system/$ac_sys_release in
1825   SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1826                        Defined for Solaris 2.6 bug in pthread header.)
1827                        ;;
1828       SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1829                        Define if the Posix semaphores do not work on your system)
1830                        ;;
1831       esac
1832
1833       AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1834       AC_CACHE_VAL(ac_cv_pthread_system_supported,
1835       [AC_TRY_RUN([#include <pthread.h>
1836       void *foo(void *parm) {
1837         return NULL;
1838       }
1839       main() {
1840         pthread_attr_t attr;
1841         pthread_t id;
1842         if (pthread_attr_init(&attr)) exit(-1);
1843         if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1844         if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1845         exit(0);
1846       }],
1847       ac_cv_pthread_system_supported=yes,
1848       ac_cv_pthread_system_supported=no,
1849       ac_cv_pthread_system_supported=no)
1850       ])
1851       AC_MSG_RESULT($ac_cv_pthread_system_supported)
1852       if test "$ac_cv_pthread_system_supported" = "yes"; then
1853         AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1854       fi
1855       AC_CHECK_FUNCS(pthread_sigmask,
1856         [case $ac_sys_system in
1857         CYGWIN*)
1858           AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1859             [Define if pthread_sigmask() does not work on your system.])
1860             ;;
1861         esac])
1862 fi
1863
1864
1865 # Check for enable-ipv6
1866 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1867 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1868 AC_ARG_ENABLE(ipv6,
1869 [  --enable-ipv6           Enable ipv6 (with ipv4) support
1870   --disable-ipv6          Disable ipv6 support],
1871 [ case "$enableval" in
1872   no)
1873        AC_MSG_RESULT(no)
1874        ipv6=no
1875        ;;
1876   *)   AC_MSG_RESULT(yes)
1877        AC_DEFINE(ENABLE_IPV6)
1878        ipv6=yes
1879        ;;
1880   esac ],
1881
1882 [
1883 dnl the check does not work on cross compilation case...
1884   AC_TRY_RUN([ /* AF_INET6 available check */
1885 #include <sys/types.h>
1886 #include <sys/socket.h>
1887 main()
1888 {
1889  if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
1890    exit(1);
1891  else
1892    exit(0);
1893 }
1894 ],
1895   AC_MSG_RESULT(yes)
1896   ipv6=yes,
1897   AC_MSG_RESULT(no)
1898   ipv6=no,
1899   AC_MSG_RESULT(no)
1900   ipv6=no
1901 )
1902
1903 if test "$ipv6" = "yes"; then
1904         AC_MSG_CHECKING(if RFC2553 API is available)
1905         AC_TRY_COMPILE([#include <sys/types.h>
1906 #include <netinet/in.h>],
1907         [struct sockaddr_in6 x;
1908 x.sin6_scope_id;],
1909                 AC_MSG_RESULT(yes)
1910                 ipv6=yes,
1911                 AC_MSG_RESULT(no, IPv6 disabled)
1912                 ipv6=no)
1913 fi
1914
1915 if test "$ipv6" = "yes"; then
1916         AC_DEFINE(ENABLE_IPV6)
1917 fi
1918 ])
1919
1920 ipv6type=unknown
1921 ipv6lib=none
1922 ipv6trylibc=no
1923
1924 if test "$ipv6" = "yes"; then
1925         AC_MSG_CHECKING([ipv6 stack type])
1926         for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
1927         do
1928                 case $i in
1929                 inria)
1930                         dnl http://www.kame.net/
1931                         AC_EGREP_CPP(yes, [
1932 #include <netinet/in.h>
1933 #ifdef IPV6_INRIA_VERSION
1934 yes
1935 #endif],
1936                                 [ipv6type=$i])
1937                         ;;
1938                 kame)
1939                         dnl http://www.kame.net/
1940                         AC_EGREP_CPP(yes, [
1941 #include <netinet/in.h>
1942 #ifdef __KAME__
1943 yes
1944 #endif],
1945                                 [ipv6type=$i;
1946                                 ipv6lib=inet6
1947                                 ipv6libdir=/usr/local/v6/lib
1948                                 ipv6trylibc=yes])
1949                         ;;
1950                 linux-glibc)
1951                         dnl http://www.v6.linux.or.jp/
1952                         AC_EGREP_CPP(yes, [
1953 #include <features.h>
1954 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
1955 yes
1956 #endif],
1957                                 [ipv6type=$i;
1958                                 ipv6trylibc=yes])
1959                         ;;
1960                 linux-inet6)
1961                         dnl http://www.v6.linux.or.jp/
1962                         if test -d /usr/inet6; then
1963                                 ipv6type=$i
1964                                 ipv6lib=inet6
1965                                 ipv6libdir=/usr/inet6/lib
1966                                 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
1967                         fi
1968                         ;;
1969                 solaris)
1970                         if test -f /etc/netconfig; then
1971                           if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
1972                                 ipv6type=$i
1973                                 ipv6trylibc=yes
1974                           fi
1975                         fi
1976                         ;;
1977                 toshiba)
1978                         AC_EGREP_CPP(yes, [
1979 #include <sys/param.h>
1980 #ifdef _TOSHIBA_INET6
1981 yes
1982 #endif],
1983                                 [ipv6type=$i;
1984                                 ipv6lib=inet6;
1985                                 ipv6libdir=/usr/local/v6/lib])
1986                         ;;
1987                 v6d)
1988                         AC_EGREP_CPP(yes, [
1989 #include </usr/local/v6/include/sys/v6config.h>
1990 #ifdef __V6D__
1991 yes
1992 #endif],
1993                                 [ipv6type=$i;
1994                                 ipv6lib=v6;
1995                                 ipv6libdir=/usr/local/v6/lib;
1996                                 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
1997                         ;;
1998                 zeta)
1999                         AC_EGREP_CPP(yes, [
2000 #include <sys/param.h>
2001 #ifdef _ZETA_MINAMI_INET6
2002 yes
2003 #endif],
2004                                 [ipv6type=$i;
2005                                 ipv6lib=inet6;
2006                                 ipv6libdir=/usr/local/v6/lib])
2007                         ;;
2008                 esac
2009                 if test "$ipv6type" != "unknown"; then
2010                         break
2011                 fi
2012         done
2013         AC_MSG_RESULT($ipv6type)
2014 fi
2015
2016 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2017         if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2018                 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2019                 echo "using lib$ipv6lib"
2020         else
2021                 if test $ipv6trylibc = "yes"; then
2022                         echo "using libc"
2023                 else
2024                         echo 'Fatal: no $ipv6lib library found.  cannot continue.'
2025                         echo "You need to fetch lib$ipv6lib.a from appropriate"
2026                         echo 'ipv6 kit and compile beforehand.'
2027                         exit 1
2028                 fi
2029         fi
2030 fi
2031
2032 # Check for --with-doc-strings
2033 AC_MSG_CHECKING(for --with-doc-strings)
2034 AC_ARG_WITH(doc-strings,
2035             AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2036
2037 if test -z "$with_doc_strings"
2038 then with_doc_strings="yes"
2039 fi
2040 if test "$with_doc_strings" != "no"
2041 then
2042     AC_DEFINE(WITH_DOC_STRINGS, 1,
2043       [Define if you want documentation strings in extension modules])
2044 fi
2045 AC_MSG_RESULT($with_doc_strings)
2046
2047 # Check for Python-specific malloc support
2048 AC_MSG_CHECKING(for --with-tsc)
2049 AC_ARG_WITH(tsc,
2050 [  --with(out)-tsc         enable/disable timestamp counter profile], [
2051 if test "$withval" != no
2052 then
2053   AC_DEFINE(WITH_TSC, 1,
2054     [Define to profile with the Pentium timestamp counter])
2055     AC_MSG_RESULT(yes)
2056 else AC_MSG_RESULT(no)
2057 fi],
2058 [AC_MSG_RESULT(no)])
2059
2060 # Check for Python-specific malloc support
2061 AC_MSG_CHECKING(for --with-pymalloc)
2062 AC_ARG_WITH(pymalloc,
2063             AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2064
2065 if test -z "$with_pymalloc"
2066 then with_pymalloc="yes"
2067 fi
2068 if test "$with_pymalloc" != "no"
2069 then
2070     AC_DEFINE(WITH_PYMALLOC, 1,
2071      [Define if you want to compile in Python-specific mallocs])
2072 fi
2073 AC_MSG_RESULT($with_pymalloc)
2074
2075 # Check for --with-wctype-functions
2076 AC_MSG_CHECKING(for --with-wctype-functions)
2077 AC_ARG_WITH(wctype-functions,
2078             AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2079 [
2080 if test "$withval" != no
2081 then
2082   AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2083   [Define if you want wctype.h functions to be used instead of the
2084    one supplied by Python itself. (see Include/unicodectype.h).])
2085   AC_MSG_RESULT(yes)
2086 else AC_MSG_RESULT(no)
2087 fi],
2088 [AC_MSG_RESULT(no)])
2089
2090 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2091 AC_SUBST(DLINCLDIR)
2092 DLINCLDIR=.
2093
2094 # the dlopen() function means we might want to use dynload_shlib.o. some
2095 # platforms, such as AIX, have dlopen(), but don't want to use it.
2096 AC_CHECK_FUNCS(dlopen)
2097
2098 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2099 # loading of modules.
2100 AC_SUBST(DYNLOADFILE)
2101 AC_MSG_CHECKING(DYNLOADFILE)
2102 if test -z "$DYNLOADFILE"
2103 then
2104         case $ac_sys_system/$ac_sys_release in
2105         AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2106         if test "$ac_cv_func_dlopen" = yes
2107         then DYNLOADFILE="dynload_shlib.o"
2108         else DYNLOADFILE="dynload_aix.o"
2109         fi
2110         ;;
2111         BeOS*) DYNLOADFILE="dynload_beos.o";;
2112         hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2113         Darwin/*) DYNLOADFILE="dynload_next.o";;
2114         atheos*) DYNLOADFILE="dynload_atheos.o";;
2115         *)
2116         # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2117         # out any dynamic loading
2118         if test "$ac_cv_func_dlopen" = yes
2119         then DYNLOADFILE="dynload_shlib.o"
2120         else DYNLOADFILE="dynload_stub.o"
2121         fi
2122         ;;
2123         esac
2124 fi
2125 AC_MSG_RESULT($DYNLOADFILE)
2126 if test "$DYNLOADFILE" != "dynload_stub.o"
2127 then
2128         AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2129         [Defined when any dynamic module loading is enabled.])
2130 fi
2131
2132 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2133
2134 AC_SUBST(MACHDEP_OBJS)
2135 AC_MSG_CHECKING(MACHDEP_OBJS)
2136 if test -z "$MACHDEP_OBJS"
2137 then
2138         MACHDEP_OBJS=$extra_machdep_objs
2139 else
2140         MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2141 fi
2142 AC_MSG_RESULT(MACHDEP_OBJS)
2143
2144 # checks for library functions
2145 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2146  execv fork fpathconf ftime ftruncate \
2147  gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2148  getpriority getpwent getspnam getspent getsid getwd \
2149  kill killpg lchown lstat mkfifo mknod mktime \
2150  mremap nice pathconf pause plock poll pthread_init \
2151  putenv readlink realpath \
2152  select setegid seteuid setgid \
2153  setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2154  sigaction siginterrupt sigrelse strftime \
2155  sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2156  truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2157
2158 # For some functions, having a definition is not sufficient, since
2159 # we want to take their address.
2160 AC_MSG_CHECKING(for chroot)
2161 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2162   AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2163   AC_MSG_RESULT(yes),
2164   AC_MSG_RESULT(no)
2165 )
2166 AC_MSG_CHECKING(for link)
2167 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2168   AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2169   AC_MSG_RESULT(yes),
2170   AC_MSG_RESULT(no)
2171 )
2172 AC_MSG_CHECKING(for symlink)
2173 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2174   AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2175   AC_MSG_RESULT(yes),
2176   AC_MSG_RESULT(no)
2177 )
2178 AC_MSG_CHECKING(for fchdir)
2179 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2180   AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2181   AC_MSG_RESULT(yes),
2182   AC_MSG_RESULT(no)
2183 )
2184 AC_MSG_CHECKING(for fsync)
2185 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2186   AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2187   AC_MSG_RESULT(yes),
2188   AC_MSG_RESULT(no)
2189 )
2190 AC_MSG_CHECKING(for fdatasync)
2191 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2192   AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2193   AC_MSG_RESULT(yes),
2194   AC_MSG_RESULT(no)
2195 )
2196
2197 # On some systems (eg. FreeBSD 5), we would find a definition of the
2198 # functions ctermid_r, setgroups in the library, but no prototype
2199 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2200 # address to avoid compiler warnings and potential miscompilations
2201 # because of the missing prototypes.
2202
2203 AC_MSG_CHECKING(for ctermid_r)
2204 AC_TRY_COMPILE([
2205 #include "confdefs.h"
2206 #include <stdio.h>
2207 ], void* p = ctermid_r,
2208   AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2209   AC_MSG_RESULT(yes),
2210   AC_MSG_RESULT(no)
2211 )
2212
2213 AC_MSG_CHECKING(for flock)
2214 AC_TRY_COMPILE([
2215 #include "confdefs.h"
2216 #include <sys/file.h>
2217 ], void* p = flock,
2218   AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2219   AC_MSG_RESULT(yes),
2220   AC_MSG_RESULT(no)
2221 )
2222
2223 AC_MSG_CHECKING(for getpagesize)
2224 AC_TRY_COMPILE([
2225 #include "confdefs.h"
2226 #include <unistd.h>
2227 ], void* p = getpagesize,
2228   AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2229   AC_MSG_RESULT(yes),
2230   AC_MSG_RESULT(no)
2231 )
2232
2233 dnl check for true
2234 AC_CHECK_PROGS(TRUE, true, /bin/true)
2235
2236 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2237 dnl On others, they are in the C library, so we to take no action
2238 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2239   AC_CHECK_LIB(resolv, inet_aton)
2240 )
2241
2242 AC_MSG_CHECKING(for hstrerror)
2243 AC_TRY_LINK([
2244 #include "confdefs.h"
2245 #include <netdb.h>
2246 ], void* p = hstrerror; hstrerror(0),
2247   AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2248   AC_MSG_RESULT(yes),
2249   AC_MSG_RESULT(no)
2250 )
2251
2252 AC_MSG_CHECKING(for inet_aton)
2253 AC_TRY_LINK([
2254 #include "confdefs.h"
2255 #include <sys/types.h>
2256 #include <sys/socket.h>
2257 #include <netinet/in.h>
2258 #include <arpa/inet.h>
2259 ], void* p = inet_aton;inet_aton(0,0),
2260   AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2261   AC_MSG_RESULT(yes),
2262   AC_MSG_RESULT(no)
2263 )
2264
2265 AC_MSG_CHECKING(for inet_pton)
2266 AC_TRY_COMPILE([
2267 #include "confdefs.h"
2268 #include <sys/types.h>
2269 #include <sys/socket.h>
2270 #include <netinet/in.h>
2271 #include <arpa/inet.h>
2272 ], void* p = inet_pton,
2273   AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2274   AC_MSG_RESULT(yes),
2275   AC_MSG_RESULT(no)
2276 )
2277
2278 # On some systems, setgroups is in unistd.h, on others, in grp.h
2279 AC_MSG_CHECKING(for setgroups)
2280 AC_TRY_COMPILE([
2281 #include "confdefs.h"
2282 #include <unistd.h>
2283 #ifdef HAVE_GRP_H
2284 #include <grp.h>
2285 #endif
2286 ],
2287 void* p = setgroups,
2288   AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2289   AC_MSG_RESULT(yes),
2290   AC_MSG_RESULT(no)
2291 )
2292
2293 # check for openpty and forkpty
2294
2295 AC_CHECK_FUNCS(openpty,,
2296    AC_CHECK_LIB(util,openpty,
2297      [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2298      AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2299    )
2300 )
2301 AC_CHECK_FUNCS(forkpty,,
2302    AC_CHECK_LIB(util,forkpty,
2303      [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2304      AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2305    )
2306 )
2307
2308 # check for long file support functions
2309 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2310
2311 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2312 AC_CHECK_FUNCS(getpgrp,
2313   AC_TRY_COMPILE([#include <unistd.h>],
2314    [getpgrp(0);],
2315    AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2316    [Define if getpgrp() must be called as getpgrp(0).])
2317  )
2318 )
2319 AC_CHECK_FUNCS(setpgrp,
2320   AC_TRY_COMPILE([#include <unistd.h>],
2321     [setpgrp(0,0);],
2322     AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2323     [Define if setpgrp() must be called as setpgrp(0, 0).])
2324   )
2325 )
2326 AC_CHECK_FUNCS(gettimeofday,
2327   AC_TRY_COMPILE([#include <sys/time.h>],
2328     [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2329     AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2330     [Define if gettimeofday() does not have second (timezone) argument
2331      This is the case on Motorola V4 (R40V4.2)])
2332   )
2333 )
2334
2335 AC_MSG_CHECKING(for major, minor, and makedev)
2336 AC_TRY_LINK([
2337 #if defined(MAJOR_IN_MKDEV)
2338 #include <sys/mkdev.h>
2339 #elif defined(MAJOR_IN_SYSMACROS)
2340 #include <sys/sysmacros.h>
2341 #else
2342 #include <sys/types.h>
2343 #endif
2344 ],[
2345   makedev(major(0),minor(0));
2346 ],[
2347   AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2348             [Define to 1 if you have the device macros.])
2349   AC_MSG_RESULT(yes)
2350 ],[
2351   AC_MSG_RESULT(no)
2352 ])
2353
2354 # On OSF/1 V5.1, getaddrinfo is available, but a define
2355 # for [no]getaddrinfo in netdb.h.
2356 AC_MSG_CHECKING(for getaddrinfo)
2357 AC_TRY_LINK([
2358 #include <sys/types.h>
2359 #include <sys/socket.h>
2360 #include <netdb.h>
2361 #include <stdio.h>
2362 ],[
2363 getaddrinfo(NULL, NULL, NULL, NULL);
2364 ], [
2365 AC_MSG_RESULT(yes)
2366 AC_MSG_CHECKING(getaddrinfo bug)
2367 AC_TRY_RUN([
2368 #include <sys/types.h>
2369 #include <netdb.h>
2370 #include <string.h>
2371 #include <sys/socket.h>
2372 #include <netinet/in.h>
2373
2374 main()
2375 {
2376   int passive, gaierr, inet4 = 0, inet6 = 0;
2377   struct addrinfo hints, *ai, *aitop;
2378   char straddr[INET6_ADDRSTRLEN], strport[16];
2379
2380   for (passive = 0; passive <= 1; passive++) {
2381     memset(&hints, 0, sizeof(hints));
2382     hints.ai_family = AF_UNSPEC;
2383     hints.ai_flags = passive ? AI_PASSIVE : 0;
2384     hints.ai_socktype = SOCK_STREAM;
2385     hints.ai_protocol = IPPROTO_TCP;
2386     if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2387       (void)gai_strerror(gaierr);
2388       goto bad;
2389     }
2390     for (ai = aitop; ai; ai = ai->ai_next) {
2391       if (ai->ai_addr == NULL ||
2392           ai->ai_addrlen == 0 ||
2393           getnameinfo(ai->ai_addr, ai->ai_addrlen,
2394                       straddr, sizeof(straddr), strport, sizeof(strport),
2395                       NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2396         goto bad;
2397       }
2398       switch (ai->ai_family) {
2399       case AF_INET:
2400         if (strcmp(strport, "54321") != 0) {
2401           goto bad;
2402         }
2403         if (passive) {
2404           if (strcmp(straddr, "0.0.0.0") != 0) {
2405             goto bad;
2406           }
2407         } else {
2408           if (strcmp(straddr, "127.0.0.1") != 0) {
2409             goto bad;
2410           }
2411         }
2412         inet4++;
2413         break;
2414       case AF_INET6:
2415         if (strcmp(strport, "54321") != 0) {
2416           goto bad;
2417         }
2418         if (passive) {
2419           if (strcmp(straddr, "::") != 0) {
2420             goto bad;
2421           }
2422         } else {
2423           if (strcmp(straddr, "::1") != 0) {
2424             goto bad;
2425           }
2426         }
2427         inet6++;
2428         break;
2429       case AF_UNSPEC:
2430         goto bad;
2431         break;
2432       default:
2433         /* another family support? */
2434         break;
2435       }
2436     }
2437   }
2438
2439   if (!(inet4 == 0 || inet4 == 2))
2440     goto bad;
2441   if (!(inet6 == 0 || inet6 == 2))
2442     goto bad;
2443
2444   if (aitop)
2445     freeaddrinfo(aitop);
2446   exit(0);
2447
2448  bad:
2449   if (aitop)
2450     freeaddrinfo(aitop);
2451   exit(1);
2452 }
2453 ],
2454 AC_MSG_RESULT(good)
2455 buggygetaddrinfo=no,
2456 AC_MSG_RESULT(buggy)
2457 buggygetaddrinfo=yes,
2458 AC_MSG_RESULT(buggy)
2459 buggygetaddrinfo=yes)], [
2460 AC_MSG_RESULT(no)
2461 buggygetaddrinfo=yes
2462 ])
2463
2464 if test "$buggygetaddrinfo" = "yes"; then
2465         if test "$ipv6" = "yes"; then
2466                 echo 'Fatal: You must get working getaddrinfo() function.'
2467                 echo '       or you can specify "--disable-ipv6"'.
2468                 exit 1
2469         fi
2470 else
2471         AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2472 fi
2473 AC_CHECK_FUNCS(getnameinfo)
2474
2475 # checks for structures
2476 AC_HEADER_TIME
2477 AC_STRUCT_TM
2478 AC_STRUCT_TIMEZONE
2479 AC_CHECK_MEMBERS([struct stat.st_rdev])
2480 AC_CHECK_MEMBERS([struct stat.st_blksize])
2481 AC_CHECK_MEMBERS([struct stat.st_flags])
2482 AC_CHECK_MEMBERS([struct stat.st_gen])
2483 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2484 AC_STRUCT_ST_BLOCKS
2485
2486 AC_MSG_CHECKING(for time.h that defines altzone)
2487 AC_CACHE_VAL(ac_cv_header_time_altzone,
2488 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2489   ac_cv_header_time_altzone=yes,
2490   ac_cv_header_time_altzone=no)])
2491 AC_MSG_RESULT($ac_cv_header_time_altzone)
2492 if test $ac_cv_header_time_altzone = yes; then
2493   AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2494 fi
2495
2496 was_it_defined=no
2497 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2498 AC_TRY_COMPILE([
2499 #include <sys/types.h>
2500 #include <sys/select.h>
2501 #include <sys/time.h>
2502 ], [;], [
2503   AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2504   [Define if  you can safely include both <sys/select.h> and <sys/time.h>
2505    (which you can't on SCO ODT 3.0).])
2506   was_it_defined=yes
2507 ])
2508 AC_MSG_RESULT($was_it_defined)
2509
2510 AC_MSG_CHECKING(for addrinfo)
2511 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2512 AC_TRY_COMPILE([
2513 #               include <netdb.h>],
2514         [struct addrinfo a],
2515         ac_cv_struct_addrinfo=yes,
2516         ac_cv_struct_addrinfo=no))
2517 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2518 if test $ac_cv_struct_addrinfo = yes; then
2519         AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2520 fi
2521
2522 AC_MSG_CHECKING(for sockaddr_storage)
2523 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2524 AC_TRY_COMPILE([
2525 #               include <sys/types.h>
2526 #               include <sys/socket.h>],
2527         [struct sockaddr_storage s],
2528         ac_cv_struct_sockaddr_storage=yes,
2529         ac_cv_struct_sockaddr_storage=no))
2530 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2531 if test $ac_cv_struct_sockaddr_storage = yes; then
2532         AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2533 fi
2534
2535 # checks for compiler characteristics
2536
2537 AC_C_CHAR_UNSIGNED
2538 AC_C_CONST
2539
2540 works=no
2541 AC_MSG_CHECKING(for working volatile)
2542 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2543   AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2544 )
2545 AC_MSG_RESULT($works)
2546
2547 works=no
2548 AC_MSG_CHECKING(for working signed char)
2549 AC_TRY_COMPILE([], [signed char c;], works=yes,
2550   AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2551 )
2552 AC_MSG_RESULT($works)
2553
2554 have_prototypes=no
2555 AC_MSG_CHECKING(for prototypes)
2556 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2557   AC_DEFINE(HAVE_PROTOTYPES, 1,
2558    [Define if your compiler supports function prototype])
2559   have_prototypes=yes
2560 ])
2561 AC_MSG_RESULT($have_prototypes)
2562
2563 works=no
2564 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2565 AC_TRY_COMPILE([
2566 #include <stdarg.h>
2567 int foo(int x, ...) {
2568         va_list va;
2569         va_start(va, x);
2570         va_arg(va, int);
2571         va_arg(va, char *);
2572         va_arg(va, double);
2573         return 0;
2574 }
2575 ], [return foo(10, "", 3.14);], [
2576   AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2577    [Define if your compiler supports variable length function prototypes
2578    (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2579   works=yes
2580 ])
2581 AC_MSG_RESULT($works)
2582
2583 # check for socketpair
2584 AC_MSG_CHECKING(for socketpair)
2585 AC_TRY_COMPILE([
2586 #include <sys/types.h>
2587 #include <sys/socket.h>
2588 ], void *x=socketpair,
2589   AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2590   AC_MSG_RESULT(yes),
2591   AC_MSG_RESULT(no)
2592 )
2593
2594 # check if sockaddr has sa_len member
2595 AC_MSG_CHECKING(if sockaddr has sa_len member)
2596 AC_TRY_COMPILE([#include <sys/types.h>
2597 #include <sys/socket.h>],
2598 [struct sockaddr x;
2599 x.sa_len = 0;],
2600         AC_MSG_RESULT(yes)
2601         AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2602         AC_MSG_RESULT(no))
2603
2604 va_list_is_array=no
2605 AC_MSG_CHECKING(whether va_list is an array)
2606 AC_TRY_COMPILE([
2607 #ifdef HAVE_STDARG_PROTOTYPES
2608 #include <stdarg.h>
2609 #else
2610 #include <varargs.h>
2611 #endif
2612 ], [va_list list1, list2; list1 = list2;], , [
2613  AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2614  va_list_is_array=yes
2615 ])
2616 AC_MSG_RESULT($va_list_is_array)
2617
2618 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2619 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2620   [Define this if you have some version of gethostbyname_r()])
2621
2622 AC_CHECK_FUNC(gethostbyname_r, [
2623   AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2624   AC_MSG_CHECKING([gethostbyname_r with 6 args])
2625   OLD_CFLAGS=$CFLAGS
2626   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2627   AC_TRY_COMPILE([
2628 #   include <netdb.h>
2629   ], [
2630     char *name;
2631     struct hostent *he, *res;
2632     char buffer[2048];
2633     int buflen = 2048;
2634     int h_errnop;
2635
2636     (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2637   ], [
2638     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2639     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2640     [Define this if you have the 6-arg version of gethostbyname_r().])
2641     AC_MSG_RESULT(yes)
2642   ], [
2643     AC_MSG_RESULT(no)
2644     AC_MSG_CHECKING([gethostbyname_r with 5 args])
2645     AC_TRY_COMPILE([
2646 #     include <netdb.h>
2647     ], [
2648       char *name;
2649       struct hostent *he;
2650       char buffer[2048];
2651       int buflen = 2048;
2652       int h_errnop;
2653
2654       (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2655     ], [
2656       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2657       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2658       [Define this if you have the 5-arg version of gethostbyname_r().])
2659       AC_MSG_RESULT(yes)
2660     ], [
2661       AC_MSG_RESULT(no)
2662       AC_MSG_CHECKING([gethostbyname_r with 3 args])
2663       AC_TRY_COMPILE([
2664 #       include <netdb.h>
2665       ], [
2666         char *name;
2667         struct hostent *he;
2668         struct hostent_data data;
2669
2670         (void) gethostbyname_r(name, he, &data);
2671       ], [
2672         AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2673         AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2674         [Define this if you have the 3-arg version of gethostbyname_r().])
2675         AC_MSG_RESULT(yes)
2676       ], [
2677         AC_MSG_RESULT(no)
2678       ])
2679     ])
2680   ])
2681   CFLAGS=$OLD_CFLAGS
2682 ], [
2683   AC_CHECK_FUNCS(gethostbyname)
2684 ])
2685 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2686 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2687 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2688 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2689 AC_SUBST(HAVE_GETHOSTBYNAME)
2690
2691 # checks for system services
2692 # (none yet)
2693
2694 # Linux requires this for correct f.p. operations
2695 AC_CHECK_FUNC(__fpu_control,
2696   [],
2697   [AC_CHECK_LIB(ieee, __fpu_control)
2698 ])
2699
2700 # Check for --with-fpectl
2701 AC_MSG_CHECKING(for --with-fpectl)
2702 AC_ARG_WITH(fpectl,
2703             AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2704 [
2705 if test "$withval" != no
2706 then
2707   AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2708   [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2709   AC_MSG_RESULT(yes)
2710 else AC_MSG_RESULT(no)
2711 fi],
2712 [AC_MSG_RESULT(no)])
2713
2714 # check for --with-libm=...
2715 AC_SUBST(LIBM)
2716 case $ac_sys_system in
2717 Darwin) ;;
2718 BeOS) ;;
2719 *) LIBM=-lm
2720 esac
2721 AC_MSG_CHECKING(for --with-libm=STRING)
2722 AC_ARG_WITH(libm,
2723             AC_HELP_STRING(--with-libm=STRING, math library),
2724 [
2725 if test "$withval" = no
2726 then LIBM=
2727      AC_MSG_RESULT(force LIBM empty)
2728 elif test "$withval" != yes
2729 then LIBM=$withval
2730      AC_MSG_RESULT(set LIBM="$withval")
2731 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2732 fi],
2733 [AC_MSG_RESULT(default LIBM="$LIBM")])
2734
2735 # check for --with-libc=...
2736 AC_SUBST(LIBC)
2737 AC_MSG_CHECKING(for --with-libc=STRING)
2738 AC_ARG_WITH(libc,
2739             AC_HELP_STRING(--with-libc=STRING, C library),
2740 [
2741 if test "$withval" = no
2742 then LIBC=
2743      AC_MSG_RESULT(force LIBC empty)
2744 elif test "$withval" != yes
2745 then LIBC=$withval
2746      AC_MSG_RESULT(set LIBC="$withval")
2747 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2748 fi],
2749 [AC_MSG_RESULT(default LIBC="$LIBC")])
2750
2751 # check for hypot() in math library
2752 LIBS_SAVE=$LIBS
2753 LIBS="$LIBS $LIBM"
2754 AC_REPLACE_FUNCS(hypot)
2755 LIBS=$LIBS_SAVE
2756
2757 # check for wchar.h
2758 AC_CHECK_HEADER(wchar.h, [
2759   AC_DEFINE(HAVE_WCHAR_H, 1,
2760   [Define if the compiler provides a wchar.h header file.])
2761   wchar_h="yes"
2762 ],
2763 wchar_h="no"
2764 )
2765
2766 # determine wchar_t size
2767 if test "$wchar_h" = yes
2768 then
2769   AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2770 fi
2771
2772 AC_MSG_CHECKING(for UCS-4 tcl)
2773 have_ucs4_tcl=no
2774 AC_TRY_COMPILE([
2775 #include <tcl.h>
2776 #if TCL_UTF_MAX != 6
2777 # error "NOT UCS4_TCL"
2778 #endif], [], [
2779   AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2780   have_ucs4_tcl=yes
2781 ])
2782 AC_MSG_RESULT($have_ucs4_tcl)
2783
2784 # check whether wchar_t is signed or not
2785 if test "$wchar_h" = yes
2786 then
2787   # check whether wchar_t is signed or not
2788   AC_MSG_CHECKING(whether wchar_t is signed)
2789   AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2790   AC_TRY_RUN([
2791   #include <wchar.h>
2792   int main()
2793   {
2794         exit((((wchar_t) -1) < ((wchar_t) 0)) ? 1 : 0);
2795   }
2796   ],
2797   ac_cv_wchar_t_signed=yes,
2798   ac_cv_wchar_t_signed=no,
2799   ac_cv_wchar_t_signed=yes)])
2800   AC_MSG_RESULT($ac_cv_wchar_t_signed)
2801 fi
2802
2803 AC_MSG_CHECKING(what type to use for unicode)
2804 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2805 AC_ARG_ENABLE(unicode,
2806               AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2807               [],
2808               [enable_unicode=yes])
2809
2810 if test $enable_unicode = yes
2811 then
2812   # Without any arguments, Py_UNICODE defaults to two-byte mode
2813   case "$have_ucs4_tcl" in
2814   yes) enable_unicode="ucs4"
2815        ;;
2816   *)   enable_unicode="ucs2"
2817        ;;
2818   esac
2819 fi
2820
2821 AH_TEMPLATE(Py_UNICODE_SIZE,
2822   [Define as the size of the unicode type.])
2823 case "$enable_unicode" in
2824 ucs2) unicode_size="2"
2825       AC_DEFINE(Py_UNICODE_SIZE,2)
2826       ;;
2827 ucs4) unicode_size="4"
2828       AC_DEFINE(Py_UNICODE_SIZE,4)
2829       ;;
2830 esac
2831
2832 AH_TEMPLATE(PY_UNICODE_TYPE,
2833   [Define as the integral type used for Unicode representation.])
2834
2835 AC_SUBST(UNICODE_OBJS)
2836 if test "$enable_unicode" = "no"
2837 then
2838   UNICODE_OBJS=""
2839   AC_MSG_RESULT(not used)
2840 else
2841   UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2842   AC_DEFINE(Py_USING_UNICODE, 1,
2843   [Define if you want to have a Unicode type.])
2844
2845   # wchar_t is only usable if it maps to an unsigned type
2846   if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2847           -a "$ac_cv_wchar_t_signed" = "no"
2848   then
2849     PY_UNICODE_TYPE="wchar_t"
2850     AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2851     [Define if you have a useable wchar_t type defined in wchar.h; useable
2852      means wchar_t must be an unsigned type with at least 16 bits. (see
2853      Include/unicodeobject.h).])
2854     AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2855   elif test "$ac_cv_sizeof_short" = "$unicode_size"
2856   then
2857        PY_UNICODE_TYPE="unsigned short"
2858        AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2859   elif test "$ac_cv_sizeof_long" = "$unicode_size"
2860   then
2861        PY_UNICODE_TYPE="unsigned long"
2862        AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2863   else
2864        PY_UNICODE_TYPE="no type found"
2865   fi
2866   AC_MSG_RESULT($PY_UNICODE_TYPE)
2867 fi
2868
2869 # check for endianness
2870 AC_C_BIGENDIAN
2871
2872 # Check whether right shifting a negative integer extends the sign bit
2873 # or fills with zeros (like the Cray J90, according to Tim Peters).
2874 AC_MSG_CHECKING(whether right shift extends the sign bit)
2875 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
2876 AC_TRY_RUN([
2877 int main()
2878 {
2879         exit(((-1)>>3 == -1) ? 0 : 1);
2880 }
2881 ],
2882 ac_cv_rshift_extends_sign=yes,
2883 ac_cv_rshift_extends_sign=no,
2884 ac_cv_rshift_extends_sign=yes)])
2885 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
2886 if test "$ac_cv_rshift_extends_sign" = no
2887 then
2888   AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
2889   [Define if i>>j for signed int i does not extend the sign bit
2890    when i < 0])
2891 fi
2892
2893 # check for getc_unlocked and related locking functions
2894 AC_MSG_CHECKING(for getc_unlocked() and friends)
2895 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
2896 AC_TRY_LINK([#include <stdio.h>],[
2897         FILE *f = fopen("/dev/null", "r");
2898         flockfile(f);
2899         getc_unlocked(f);
2900         funlockfile(f);
2901 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
2902 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
2903 if test "$ac_cv_have_getc_unlocked" = yes
2904 then
2905   AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
2906   [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
2907 fi
2908
2909 # check where readline lives
2910 # save the value of LIBS so we don't actually link Python with readline
2911 LIBS_no_readline=$LIBS
2912 AC_CHECK_LIB(readline, readline)
2913 if test "$ac_cv_have_readline_readline" = no
2914 then
2915   AC_CHECK_LIB(termcap, readline)
2916 fi
2917
2918 # check for readline 2.1
2919 AC_CHECK_LIB(readline, rl_callback_handler_install,
2920         AC_DEFINE(HAVE_RL_CALLBACK, 1,
2921         [Define if you have readline 2.1]), , )
2922
2923 # check for readline 2.2
2924 AC_TRY_CPP([#include <readline/readline.h>],
2925 have_readline=yes, have_readline=no)
2926 if test $have_readline = yes
2927 then
2928   AC_EGREP_HEADER([extern int rl_completion_append_character;],
2929   [readline/readline.h],
2930   AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
2931   [Define if you have readline 2.2]), )
2932 fi
2933
2934 # check for readline 4.0
2935 AC_CHECK_LIB(readline, rl_pre_input_hook,
2936         AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
2937         [Define if you have readline 4.0]), , )
2938
2939 # check for readline 4.2
2940 AC_CHECK_LIB(readline, rl_completion_matches,
2941         AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
2942         [Define if you have readline 4.2]), , )
2943
2944 # also in readline 4.2
2945 AC_TRY_CPP([#include <readline/readline.h>],
2946 have_readline=yes, have_readline=no)
2947 if test $have_readline = yes
2948 then
2949   AC_EGREP_HEADER([extern int rl_catch_signals;],
2950   [readline/readline.h],
2951   AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
2952   [Define if you can turn off readline's signal handling.]), )
2953 fi
2954
2955 # End of readline checks: restore LIBS
2956 LIBS=$LIBS_no_readline
2957
2958 AC_MSG_CHECKING(for broken nice())
2959 AC_CACHE_VAL(ac_cv_broken_nice, [
2960 AC_TRY_RUN([
2961 int main()
2962 {
2963         int val1 = nice(1);
2964         if (val1 != -1 && val1 == nice(2))
2965                 exit(0);
2966         exit(1);
2967 }
2968 ],
2969 ac_cv_broken_nice=yes,
2970 ac_cv_broken_nice=no,
2971 ac_cv_broken_nice=no)])
2972 AC_MSG_RESULT($ac_cv_broken_nice)
2973 if test "$ac_cv_broken_nice" = yes
2974 then
2975   AC_DEFINE(HAVE_BROKEN_NICE, 1,
2976   [Define if nice() returns success/failure instead of the new priority.])
2977 fi
2978
2979 AC_MSG_CHECKING(for broken poll())
2980 AC_TRY_RUN([
2981 #include <poll.h>
2982
2983 int main (void)
2984     {
2985     struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
2986
2987     close (42);
2988
2989     int poll_test = poll (&poll_struct, 1, 0);
2990
2991     if (poll_test < 0)
2992         {
2993         exit(0);
2994         }
2995     else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
2996         {
2997         exit(0);
2998         }
2999     else
3000         {
3001         exit(1);
3002         }
3003     }
3004 ],
3005 ac_cv_broken_poll=yes,
3006 ac_cv_broken_poll=no,
3007 ac_cv_broken_poll=no)
3008 AC_MSG_RESULT($ac_cv_broken_poll)
3009 if test "$ac_cv_broken_poll" = yes
3010 then
3011   AC_DEFINE(HAVE_BROKEN_POLL, 1,
3012       [Define if poll() sets errno on invalid file descriptors.])
3013 fi
3014
3015 # Before we can test tzset, we need to check if struct tm has a tm_zone
3016 # (which is not required by ISO C or UNIX spec) and/or if we support
3017 # tzname[]
3018 AC_STRUCT_TIMEZONE
3019
3020 # check tzset(3) exists and works like we expect it to
3021 AC_MSG_CHECKING(for working tzset())
3022 AC_CACHE_VAL(ac_cv_working_tzset, [
3023 AC_TRY_RUN([
3024 #include <stdlib.h>
3025 #include <time.h>
3026 #include <string.h>
3027
3028 #if HAVE_TZNAME
3029 extern char *tzname[];
3030 #endif
3031
3032 int main()
3033 {
3034         /* Note that we need to ensure that not only does tzset(3)
3035            do 'something' with localtime, but it works as documented
3036            in the library reference and as expected by the test suite.
3037            This includes making sure that tzname is set properly if
3038            tm->tm_zone does not exist since it is the alternative way
3039            of getting timezone info.
3040
3041            Red Hat 6.2 doesn't understand the southern hemisphere
3042            after New Year's Day.
3043         */
3044
3045         time_t groundhogday = 1044144000; /* GMT-based */
3046         time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3047
3048         putenv("TZ=UTC+0");
3049         tzset();
3050         if (localtime(&groundhogday)->tm_hour != 0)
3051             exit(1);
3052 #if HAVE_TZNAME
3053         /* For UTC, tzname[1] is sometimes "", sometimes "   " */
3054         if (strcmp(tzname[0], "UTC") ||
3055                 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3056             exit(1);
3057 #endif
3058
3059         putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3060         tzset();
3061         if (localtime(&groundhogday)->tm_hour != 19)
3062             exit(1);
3063 #if HAVE_TZNAME
3064         if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3065             exit(1);
3066 #endif
3067
3068         putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3069         tzset();
3070         if (localtime(&groundhogday)->tm_hour != 11)
3071             exit(1);
3072 #if HAVE_TZNAME
3073         if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3074             exit(1);
3075 #endif
3076
3077 #if HAVE_STRUCT_TM_TM_ZONE
3078         if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3079             exit(1);
3080         if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3081             exit(1);
3082 #endif
3083
3084         exit(0);
3085 }
3086 ],
3087 ac_cv_working_tzset=yes,
3088 ac_cv_working_tzset=no,
3089 ac_cv_working_tzset=no)])
3090 AC_MSG_RESULT($ac_cv_working_tzset)
3091 if test "$ac_cv_working_tzset" = yes
3092 then
3093   AC_DEFINE(HAVE_WORKING_TZSET, 1,
3094   [Define if tzset() actually switches the local timezone in a meaningful way.])
3095 fi
3096
3097 # Look for subsecond timestamps in struct stat
3098 AC_MSG_CHECKING(for tv_nsec in struct stat)
3099 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3100 AC_TRY_COMPILE([#include <sys/stat.h>], [
3101 struct stat st;
3102 st.st_mtim.tv_nsec = 1;
3103 ],
3104 ac_cv_stat_tv_nsec=yes,
3105 ac_cv_stat_tv_nsec=no,
3106 ac_cv_stat_tv_nsec=no))
3107 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3108 if test "$ac_cv_stat_tv_nsec" = yes
3109 then
3110   AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3111   [Define if you have struct stat.st_mtim.tv_nsec])
3112 fi
3113
3114 # Look for BSD style subsecond timestamps in struct stat
3115 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3116 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3117 AC_TRY_COMPILE([#include <sys/stat.h>], [
3118 struct stat st;
3119 st.st_mtimespec.tv_nsec = 1;
3120 ],
3121 ac_cv_stat_tv_nsec2=yes,
3122 ac_cv_stat_tv_nsec2=no,
3123 ac_cv_stat_tv_nsec2=no))
3124 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3125 if test "$ac_cv_stat_tv_nsec2" = yes
3126 then
3127   AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3128   [Define if you have struct stat.st_mtimensec])
3129 fi
3130
3131 # On HP/UX 11.0, mvwdelch is a block with a return statement
3132 AC_MSG_CHECKING(whether mvwdelch is an expression)
3133 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3134 AC_TRY_COMPILE([#include <curses.h>], [
3135   int rtn;
3136   rtn = mvwdelch(0,0,0);
3137 ], ac_cv_mvwdelch_is_expression=yes,
3138    ac_cv_mvwdelch_is_expression=no,
3139    ac_cv_mvwdelch_is_expression=yes))
3140 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3141
3142 if test "$ac_cv_mvwdelch_is_expression" = yes
3143 then
3144   AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3145   [Define if mvwdelch in curses.h is an expression.])
3146 fi
3147
3148 AC_MSG_CHECKING(whether WINDOW has _flags)
3149 AC_CACHE_VAL(ac_cv_window_has_flags,
3150 AC_TRY_COMPILE([#include <curses.h>], [
3151   WINDOW *w;
3152   w->_flags = 0;
3153 ], ac_cv_window_has_flags=yes,
3154    ac_cv_window_has_flags=no,
3155    ac_cv_window_has_flags=no))
3156 AC_MSG_RESULT($ac_cv_window_has_flags)
3157
3158
3159 if test "$ac_cv_window_has_flags" = yes
3160 then
3161   AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3162   [Define if WINDOW in curses.h offers a field _flags.])
3163 fi
3164
3165 AC_MSG_CHECKING(for /dev/ptmx)
3166
3167 if test -e /dev/ptmx
3168 then
3169   AC_MSG_RESULT(yes)
3170   AC_DEFINE(HAVE_DEV_PTMX, 1,
3171   [Define if we have /dev/ptmx.])
3172 else
3173   AC_MSG_RESULT(no)
3174 fi
3175
3176 AC_MSG_CHECKING(for /dev/ptc)
3177
3178 if test -e /dev/ptc
3179 then
3180   AC_MSG_RESULT(yes)
3181   AC_DEFINE(HAVE_DEV_PTC, 1,
3182   [Define if we have /dev/ptc.])
3183 else
3184   AC_MSG_RESULT(no)
3185 fi
3186
3187 AC_CHECK_TYPE(socklen_t,,
3188   AC_DEFINE(socklen_t,int,
3189             Define to `int' if <sys/socket.h> does not define.),[
3190 #ifdef HAVE_SYS_TYPES_H
3191 #include <sys/types.h>
3192 #endif
3193 #ifdef HAVE_SYS_SOCKET_H
3194 #include <sys/socket.h>
3195 #endif
3196 ])
3197
3198 AC_SUBST(THREADHEADERS)
3199
3200 for h in `(cd $srcdir;echo Python/thread_*.h)`
3201 do
3202   THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3203 done
3204
3205 AC_SUBST(SRCDIRS)
3206 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3207 AC_MSG_CHECKING(for build directories)
3208 for dir in $SRCDIRS; do
3209     if test ! -d $dir; then
3210         mkdir $dir
3211     fi
3212 done
3213 AC_MSG_RESULT(done)
3214
3215 # generate output files
3216 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3217 AC_OUTPUT
3218
3219 echo "creating Setup"
3220 if test ! -f Modules/Setup
3221 then
3222         cp $srcdir/Modules/Setup.dist Modules/Setup
3223 fi
3224
3225 echo "creating Setup.local"
3226 if test ! -f Modules/Setup.local
3227 then
3228         echo "# Edit this file for local setup changes" >Modules/Setup.local
3229 fi
3230
3231 echo "creating Makefile"
3232 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3233                         -s Modules Modules/Setup.config \
3234                         Modules/Setup.local Modules/Setup
3235 mv config.c Modules