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