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