configure.in

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