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 "
 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 Unversioned directory"
 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         if test $enable_shared = "yes"
1526         then
1527                 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1528         fi
1529 else
1530         AC_MSG_RESULT(no)
1531 fi
1532
1533 AC_MSG_CHECKING(for dyld)
1534 case $ac_sys_system/$ac_sys_release in
1535   Darwin/*)
1536         AC_DEFINE(WITH_DYLD, 1,
1537         [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1538          dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1539          linker (rld). Dyld is necessary to support frameworks.])
1540         AC_MSG_RESULT(always on for Darwin)
1541         ;;
1542   *)
1543         AC_MSG_RESULT(no)
1544         ;;
1545 esac
1546
1547 # Set info about shared libraries.
1548 AC_SUBST(SO)
1549 AC_SUBST(LDSHARED)
1550 AC_SUBST(BLDSHARED)
1551 AC_SUBST(CCSHARED)
1552 AC_SUBST(LINKFORSHARED)
1553 # SO is the extension of shared libraries `(including the dot!)
1554 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1555 AC_MSG_CHECKING(SO)
1556 if test -z "$SO"
1557 then
1558         case $ac_sys_system in
1559         hp*|HP*)
1560                 case `uname -m` in
1561                         ia64) SO=.so;;
1562                         *)    SO=.sl;;
1563                 esac
1564                 ;;
1565         CYGWIN*)   SO=.dll;;
1566         *)         SO=.so;;
1567         esac
1568 else
1569         # this might also be a termcap variable, see #610332
1570         echo
1571         echo '====================================================================='
1572         echo '+                                                                   +'
1573         echo '+ WARNING: You have set SO in your environment.                     +'
1574         echo '+ Do you really mean to change the extension for shared libraries?  +'
1575         echo '+ Continuing in 10 seconds to let you to ponder.                    +'
1576         echo '+                                                                   +'
1577         echo '====================================================================='
1578         sleep 10
1579 fi
1580 AC_MSG_RESULT($SO)
1581
1582 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1583 # LDSHARED is the ld *command* used to create shared library
1584 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1585 # (Shared libraries in this instance are shared modules to be loaded into
1586 # Python, as opposed to building Python itself as a shared library.)
1587 AC_MSG_CHECKING(LDSHARED)
1588 if test -z "$LDSHARED"
1589 then
1590         case $ac_sys_system/$ac_sys_release in
1591         AIX*)
1592                 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1593                 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1594                 ;;
1595         IRIX/5*) LDSHARED="ld -shared";;
1596         IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1597         SunOS/5*)
1598                 if test "$GCC" = "yes"
1599                 then LDSHARED='$(CC) -shared'
1600                 else LDSHARED='$(CC) -G';
1601                 fi ;;
1602         hp*|HP*)
1603                 if test "$GCC" = "yes"
1604                 then LDSHARED='$(CC) -shared'
1605                 else LDSHARED='ld -b';
1606                 fi ;;
1607         OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1608         Darwin/1.3*)
1609                 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1610                 if test "$enable_framework" ; then
1611                         # Link against the framework. All externals should be defined.
1612                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1613                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1614                 else
1615                         # No framework. Ignore undefined symbols, assuming they come from Python
1616                         LDSHARED="$LDSHARED -undefined suppress"
1617                 fi ;;
1618         Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1619                 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1620                 if test "$enable_framework" ; then
1621                         # Link against the framework. All externals should be defined.
1622                         BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1623                         LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1624                 else
1625                         # No framework, use the Python app as bundle-loader
1626                         BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1627                         LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1628                 fi ;;
1629         Darwin/*)
1630                 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1631                 # This allows an extension to be used in any Python
1632
1633                 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1634                 then
1635                         if test "${enable_universalsdk}"; then
1636                                 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1637                         fi
1638                         LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1639                         BLDSHARED="$LDSHARED"
1640                 else
1641                         LDSHARED='$(CC) $(LDFLAGS) -bundle'
1642                         if test "$enable_framework" ; then
1643                                 # Link against the framework. All externals should be defined.
1644                                 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1645                                 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1646                         else
1647                                 # No framework, use the Python app as bundle-loader
1648                                 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1649                                 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1650                         fi
1651                 fi
1652                 ;;
1653         Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1654         BSD/OS*/4*) LDSHARED="gcc -shared";;
1655         FreeBSD*)
1656                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1657                 then
1658                         LDSHARED="$CC -shared ${LDFLAGS}"
1659                 else
1660                         LDSHARED="ld -Bshareable ${LDFLAGS}"
1661                 fi;;
1662         OpenBSD*)
1663                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1664                 then
1665                                 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1666                 else
1667                                 case `uname -r` in
1668                                 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1669                                    LDSHARED="ld -Bshareable ${LDFLAGS}"
1670                                    ;;
1671                                 *)
1672                                    LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1673                                    ;;
1674                                 esac
1675                 fi;;
1676         NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1677         OpenUNIX*|UnixWare*)
1678                 if test "$GCC" = "yes"
1679                 then LDSHARED='$(CC) -shared'
1680                 else LDSHARED='$(CC) -G'
1681                 fi;;
1682         SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1683         Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1684         CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1685         atheos*) LDSHARED="gcc -shared";;
1686         *)      LDSHARED="ld";;
1687         esac
1688 fi
1689 AC_MSG_RESULT($LDSHARED)
1690 BLDSHARED=${BLDSHARED-$LDSHARED}
1691 # CCSHARED are the C *flags* used to create objects to go into a shared
1692 # library (module) -- this is only needed for a few systems
1693 AC_MSG_CHECKING(CCSHARED)
1694 if test -z "$CCSHARED"
1695 then
1696         case $ac_sys_system/$ac_sys_release in
1697         SunOS*) if test "$GCC" = yes;
1698                 then CCSHARED="-fPIC";
1699                 elif test `uname -p` = sparc;
1700                 then CCSHARED="-xcode=pic32";
1701                 else CCSHARED="-Kpic";
1702                 fi;;
1703         hp*|HP*) if test "$GCC" = yes;
1704                  then CCSHARED="-fPIC";
1705                  else CCSHARED="+z";
1706                  fi;;
1707         Linux*|GNU*) CCSHARED="-fPIC";;
1708         BSD/OS*/4*) CCSHARED="-fpic";;
1709         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1710         OpenUNIX*|UnixWare*)
1711                 if test "$GCC" = "yes"
1712                 then CCSHARED="-fPIC"
1713                 else CCSHARED="-KPIC"
1714                 fi;;
1715         SCO_SV*)
1716                 if test "$GCC" = "yes"
1717                 then CCSHARED="-fPIC"
1718                 else CCSHARED="-Kpic -belf"
1719                 fi;;
1720         Monterey*) CCSHARED="-G";;
1721         IRIX*/6*)  case $CC in
1722                    *gcc*) CCSHARED="-shared";;
1723                    *) CCSHARED="";;
1724                    esac;;
1725         atheos*) CCSHARED="-fPIC";;
1726         esac
1727 fi
1728 AC_MSG_RESULT($CCSHARED)
1729 # LINKFORSHARED are the flags passed to the $(CC) command that links
1730 # the python executable -- this is only needed for a few systems
1731 AC_MSG_CHECKING(LINKFORSHARED)
1732 if test -z "$LINKFORSHARED"
1733 then
1734         case $ac_sys_system/$ac_sys_release in
1735         AIX*)   LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1736         hp*|HP*)
1737             LINKFORSHARED="-Wl,-E -Wl,+s";;
1738 #           LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1739         BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1740         Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1741         # -u libsys_s pulls in all symbols in libsys
1742         Darwin/*)
1743                 LINKFORSHARED="$extra_undefs -framework CoreFoundation"
1744                 if test "$enable_framework"
1745                 then
1746                         LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1747                 fi
1748                 LINKFORSHARED="$LINKFORSHARED";;
1749         OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1750         SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1751         ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1752         FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1753                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1754                 then
1755                         LINKFORSHARED="-Wl,--export-dynamic"
1756                 fi;;
1757         SunOS/5*) case $CC in
1758                   *gcc*)
1759                     if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1760                     then
1761                         LINKFORSHARED="-Xlinker --export-dynamic"
1762                     fi;;
1763                   esac;;
1764         CYGWIN*)
1765                 if test $enable_shared = "no"
1766                 then
1767                         LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1768                 fi;;
1769         QNX*)
1770                 # -Wl,-E causes the symbols to be added to the dynamic
1771                 # symbol table so that they can be found when a module
1772                 # is loaded.  -N 2048K causes the stack size to be set
1773                 # to 2048 kilobytes so that the stack doesn't overflow
1774                 # when running test_compile.py.
1775                 LINKFORSHARED='-Wl,-E -N 2048K';;
1776         esac
1777 fi
1778 AC_MSG_RESULT($LINKFORSHARED)
1779
1780
1781 AC_SUBST(CFLAGSFORSHARED)
1782 AC_MSG_CHECKING(CFLAGSFORSHARED)
1783 if test ! "$LIBRARY" = "$LDLIBRARY"
1784 then
1785         case $ac_sys_system in
1786         CYGWIN*)
1787                 # Cygwin needs CCSHARED when building extension DLLs
1788                 # but not when building the interpreter DLL.
1789                 CFLAGSFORSHARED='';;
1790         *)
1791                 CFLAGSFORSHARED='$(CCSHARED)'
1792         esac
1793 fi
1794 AC_MSG_RESULT($CFLAGSFORSHARED)
1795
1796 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1797 # library (with --enable-shared).
1798 # For platforms on which shared libraries are not allowed to have unresolved
1799 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1800 # if it is not required, since it creates a dependency of the shared library
1801 # to LIBS. This, in turn, means that applications linking the shared libpython
1802 # don't need to link LIBS explicitly. The default should be only changed
1803 # on systems where this approach causes problems.
1804 AC_SUBST(SHLIBS)
1805 AC_MSG_CHECKING(SHLIBS)
1806 case "$ac_sys_system" in
1807         *)
1808                 SHLIBS='$(LIBS)';;
1809 esac
1810 AC_MSG_RESULT($SHLIBS)
1811
1812
1813 # checks for libraries
1814 AC_CHECK_LIB(dl, dlopen)        # Dynamic linking for SunOS/Solaris and SYSV
1815 AC_CHECK_LIB(dld, shl_load)     # Dynamic linking for HP-UX
1816
1817 # only check for sem_init if thread support is requested
1818 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1819     AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1820                                                 # posix4 on Solaris 2.6
1821                                                 # pthread (first!) on Linux
1822 fi
1823
1824 # check if we need libintl for locale functions
1825 AC_CHECK_LIB(intl, textdomain,
1826         [AC_DEFINE(WITH_LIBINTL, 1,
1827         [Define to 1 if libintl is needed for locale functions.])
1828         LIBS="-lintl $LIBS"])
1829
1830 # checks for system dependent C++ extensions support
1831 case "$ac_sys_system" in
1832         AIX*)   AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1833                 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1834                             [loadAndInit("", 0, "")],
1835                             [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1836                       [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1837                        and you want support for AIX C++ shared extension modules.])
1838                              AC_MSG_RESULT(yes)],
1839                             [AC_MSG_RESULT(no)]);;
1840         *) ;;
1841 esac
1842
1843 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1844 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1845 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1846
1847 AC_MSG_CHECKING(for --with-libs)
1848 AC_ARG_WITH(libs,
1849             AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1850 [
1851 AC_MSG_RESULT($withval)
1852 LIBS="$withval $LIBS"
1853 ],
1854 [AC_MSG_RESULT(no)])
1855
1856 # Check for use of the system libffi library
1857 AC_MSG_CHECKING(for --with-system-ffi)
1858 AC_ARG_WITH(system_ffi,
1859             AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1860
1861 AC_MSG_RESULT($with_system_ffi)
1862
1863 # Check for --with-dbmliborder
1864 AC_MSG_CHECKING(for --with-dbmliborder)
1865 AC_ARG_WITH(dbmliborder,
1866             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'.]),
1867 [
1868 if test x$with_dbmliborder = xyes
1869 then
1870 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1871 else
1872   for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1873     if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1874     then
1875       AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1876     fi
1877   done
1878 fi])
1879 AC_MSG_RESULT($with_dbmliborder)
1880
1881 # Determine if signalmodule should be used.
1882 AC_SUBST(USE_SIGNAL_MODULE)
1883 AC_SUBST(SIGNAL_OBJS)
1884 AC_MSG_CHECKING(for --with-signal-module)
1885 AC_ARG_WITH(signal-module,
1886             AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1887
1888 if test -z "$with_signal_module"
1889 then with_signal_module="yes"
1890 fi
1891 AC_MSG_RESULT($with_signal_module)
1892
1893 if test "${with_signal_module}" = "yes"; then
1894         USE_SIGNAL_MODULE=""
1895         SIGNAL_OBJS=""
1896 else
1897         USE_SIGNAL_MODULE="#"
1898         SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1899 fi
1900
1901 # This is used to generate Setup.config
1902 AC_SUBST(USE_THREAD_MODULE)
1903 USE_THREAD_MODULE=""
1904
1905 AC_MSG_CHECKING(for --with-dec-threads)
1906 AC_SUBST(LDLAST)
1907 AC_ARG_WITH(dec-threads,
1908             AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1909 [
1910 AC_MSG_RESULT($withval)
1911 LDLAST=-threads
1912 if test "${with_thread+set}" != set; then
1913    with_thread="$withval";
1914 fi],
1915 [AC_MSG_RESULT(no)])
1916
1917 # Templates for things AC_DEFINEd more than once.
1918 # For a single AC_DEFINE, no template is needed.
1919 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1920 AH_TEMPLATE(_REENTRANT,
1921   [Define to force use of thread-safe errno, h_errno, and other functions])
1922 AH_TEMPLATE(WITH_THREAD,
1923   [Define if you want to compile in rudimentary thread support])
1924
1925 AC_MSG_CHECKING(for --with-threads)
1926 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1927 AC_ARG_WITH(threads,
1928             AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1929
1930 # --with-thread is deprecated, but check for it anyway
1931 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1932 AC_ARG_WITH(thread,
1933             AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1934             [with_threads=$with_thread])
1935
1936 if test -z "$with_threads"
1937 then with_threads="yes"
1938 fi
1939 AC_MSG_RESULT($with_threads)
1940
1941 AC_SUBST(THREADOBJ)
1942 if test "$with_threads" = "no"
1943 then
1944     USE_THREAD_MODULE="#"
1945 elif test "$ac_cv_pthread_is_default" = yes
1946 then
1947     AC_DEFINE(WITH_THREAD)
1948     # Defining _REENTRANT on system with POSIX threads should not hurt.
1949     AC_DEFINE(_REENTRANT)
1950     posix_threads=yes
1951     THREADOBJ="Python/thread.o"
1952 elif test "$ac_cv_kpthread" = "yes"
1953 then
1954     CC="$CC -Kpthread"
1955     if test "$ac_cv_cxx_thread" = "yes"; then
1956         CXX="$CXX -Kpthread"
1957     fi
1958     AC_DEFINE(WITH_THREAD)
1959     posix_threads=yes
1960     THREADOBJ="Python/thread.o"
1961 elif test "$ac_cv_kthread" = "yes"
1962 then
1963     CC="$CC -Kthread"
1964     if test "$ac_cv_cxx_thread" = "yes"; then
1965         CXX="$CXX -Kthread"
1966     fi
1967     AC_DEFINE(WITH_THREAD)
1968     posix_threads=yes
1969     THREADOBJ="Python/thread.o"
1970 elif test "$ac_cv_pthread" = "yes"
1971 then
1972     CC="$CC -pthread"
1973     if test "$ac_cv_cxx_thread" = "yes"; then
1974         CXX="$CXX -pthread"
1975     fi
1976     AC_DEFINE(WITH_THREAD)
1977     posix_threads=yes
1978     THREADOBJ="Python/thread.o"
1979 else
1980     if test ! -z "$with_threads" -a -d "$with_threads"
1981     then LDFLAGS="$LDFLAGS -L$with_threads"
1982     fi
1983     if test ! -z "$withval" -a -d "$withval"
1984     then LDFLAGS="$LDFLAGS -L$withval"
1985     fi
1986
1987     # According to the POSIX spec, a pthreads implementation must
1988     # define _POSIX_THREADS in unistd.h. Some apparently don't
1989     # (e.g. gnu pth with pthread emulation)
1990     AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1991     AC_EGREP_CPP(yes,
1992     [
1993 #include <unistd.h>
1994 #ifdef _POSIX_THREADS
1995 yes
1996 #endif
1997     ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1998     AC_MSG_RESULT($unistd_defines_pthreads)
1999
2000     AC_DEFINE(_REENTRANT)
2001     AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2002     AC_DEFINE(C_THREADS)
2003     AC_DEFINE(HURD_C_THREADS, 1,
2004     [Define if you are using Mach cthreads directly under /include])
2005     LIBS="$LIBS -lthreads"
2006     THREADOBJ="Python/thread.o"],[
2007     AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2008     AC_DEFINE(C_THREADS)
2009     AC_DEFINE(MACH_C_THREADS, 1,
2010     [Define if you are using Mach cthreads under mach /])
2011     THREADOBJ="Python/thread.o"],[
2012     AC_MSG_CHECKING(for --with-pth)
2013     AC_ARG_WITH([pth],
2014                 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2015                 [AC_MSG_RESULT($withval)
2016                   AC_DEFINE([WITH_THREAD])
2017                   AC_DEFINE([HAVE_PTH], 1,
2018                             [Define if you have GNU PTH threads.])
2019                   LIBS="-lpth $LIBS"
2020                   THREADOBJ="Python/thread.o"],
2021                 [AC_MSG_RESULT(no)
2022
2023     # Just looking for pthread_create in libpthread is not enough:
2024     # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2025     # So we really have to include pthread.h, and then link.
2026     _libs=$LIBS
2027     LIBS="$LIBS -lpthread"
2028     AC_MSG_CHECKING([for pthread_create in -lpthread])
2029     AC_TRY_LINK([#include <pthread.h>
2030
2031 void * start_routine (void *arg) { exit (0); }], [
2032 pthread_create (NULL, NULL, start_routine, NULL)], [
2033     AC_MSG_RESULT(yes)
2034     AC_DEFINE(WITH_THREAD)
2035     posix_threads=yes
2036     THREADOBJ="Python/thread.o"],[
2037     LIBS=$_libs
2038     AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2039     posix_threads=yes
2040     THREADOBJ="Python/thread.o"],[
2041     AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2042     AC_DEFINE(ATHEOS_THREADS, 1,
2043     [Define this if you have AtheOS threads.])
2044     THREADOBJ="Python/thread.o"],[
2045     AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2046     posix_threads=yes
2047     LIBS="$LIBS -lpthreads"
2048     THREADOBJ="Python/thread.o"], [
2049     AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2050     posix_threads=yes
2051     LIBS="$LIBS -lc_r"
2052     THREADOBJ="Python/thread.o"], [
2053     AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2054     posix_threads=yes
2055     LIBS="$LIBS -lpthread"
2056     THREADOBJ="Python/thread.o"], [
2057     AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2058     posix_threads=yes
2059     LIBS="$LIBS -lcma"
2060     THREADOBJ="Python/thread.o"],[
2061     USE_THREAD_MODULE="#"])
2062     ])])])])])])])])])
2063
2064     AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2065     LIBS="$LIBS -lmpc"
2066     THREADOBJ="Python/thread.o"
2067     USE_THREAD_MODULE=""])
2068
2069     if test "$posix_threads" != "yes"; then
2070       AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2071       LIBS="$LIBS -lthread"
2072       THREADOBJ="Python/thread.o"
2073       USE_THREAD_MODULE=""])
2074     fi
2075
2076     if test "$USE_THREAD_MODULE" != "#"
2077     then
2078         # If the above checks didn't disable threads, (at least) OSF1
2079         # needs this '-threads' argument during linking.
2080         case $ac_sys_system in
2081         OSF1) LDLAST=-threads;;
2082         esac
2083     fi
2084 fi
2085
2086 if test "$posix_threads" = "yes"; then
2087       if test "$unistd_defines_pthreads" = "no"; then
2088          AC_DEFINE(_POSIX_THREADS, 1,
2089          [Define if you have POSIX threads,
2090           and your system does not define that.])
2091       fi
2092
2093       # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2094       case  $ac_sys_system/$ac_sys_release in
2095   SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2096                        Defined for Solaris 2.6 bug in pthread header.)
2097                        ;;
2098       SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2099                        Define if the Posix semaphores do not work on your system)
2100                        ;;
2101       AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2102                        Define if the Posix semaphores do not work on your system)
2103                        ;;
2104       esac
2105
2106       AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2107       AC_CACHE_VAL(ac_cv_pthread_system_supported,
2108       [AC_TRY_RUN([#include <pthread.h>
2109       void *foo(void *parm) {
2110         return NULL;
2111       }
2112       main() {
2113         pthread_attr_t attr;
2114         pthread_t id;
2115         if (pthread_attr_init(&attr)) exit(-1);
2116         if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2117         if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2118         exit(0);
2119       }],
2120       ac_cv_pthread_system_supported=yes,
2121       ac_cv_pthread_system_supported=no,
2122       ac_cv_pthread_system_supported=no)
2123       ])
2124       AC_MSG_RESULT($ac_cv_pthread_system_supported)
2125       if test "$ac_cv_pthread_system_supported" = "yes"; then
2126         AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2127       fi
2128       AC_CHECK_FUNCS(pthread_sigmask,
2129         [case $ac_sys_system in
2130         CYGWIN*)
2131           AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2132             [Define if pthread_sigmask() does not work on your system.])
2133             ;;
2134         esac])
2135 fi
2136
2137
2138 # Check for enable-ipv6
2139 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2140 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2141 AC_ARG_ENABLE(ipv6,
2142 [  --enable-ipv6           Enable ipv6 (with ipv4) support
2143   --disable-ipv6          Disable ipv6 support],
2144 [ case "$enableval" in
2145   no)
2146        AC_MSG_RESULT(no)
2147        ipv6=no
2148        ;;
2149   *)   AC_MSG_RESULT(yes)
2150        AC_DEFINE(ENABLE_IPV6)
2151        ipv6=yes
2152        ;;
2153   esac ],
2154
2155 [
2156 dnl the check does not work on cross compilation case...
2157   AC_TRY_RUN([ /* AF_INET6 available check */
2158 #include <sys/types.h>
2159 #include <sys/socket.h>
2160 main()
2161 {
2162  if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2163    exit(1);
2164  else
2165    exit(0);
2166 }
2167 ],
2168   AC_MSG_RESULT(yes)
2169   ipv6=yes,
2170   AC_MSG_RESULT(no)
2171   ipv6=no,
2172   AC_MSG_RESULT(no)
2173   ipv6=no
2174 )
2175
2176 if test "$ipv6" = "yes"; then
2177         AC_MSG_CHECKING(if RFC2553 API is available)
2178         AC_TRY_COMPILE([#include <sys/types.h>
2179 #include <netinet/in.h>],
2180         [struct sockaddr_in6 x;
2181 x.sin6_scope_id;],
2182                 AC_MSG_RESULT(yes)
2183                 ipv6=yes,
2184                 AC_MSG_RESULT(no, IPv6 disabled)
2185                 ipv6=no)
2186 fi
2187
2188 if test "$ipv6" = "yes"; then
2189         AC_DEFINE(ENABLE_IPV6)
2190 fi
2191 ])
2192
2193 ipv6type=unknown
2194 ipv6lib=none
2195 ipv6trylibc=no
2196
2197 if test "$ipv6" = "yes"; then
2198         AC_MSG_CHECKING([ipv6 stack type])
2199         for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2200         do
2201                 case $i in
2202                 inria)
2203                         dnl http://www.kame.net/
2204                         AC_EGREP_CPP(yes, [
2205 #include <netinet/in.h>
2206 #ifdef IPV6_INRIA_VERSION
2207 yes
2208 #endif],
2209                                 [ipv6type=$i])
2210                         ;;
2211                 kame)
2212                         dnl http://www.kame.net/
2213                         AC_EGREP_CPP(yes, [
2214 #include <netinet/in.h>
2215 #ifdef __KAME__
2216 yes
2217 #endif],
2218                                 [ipv6type=$i;
2219                                 ipv6lib=inet6
2220                                 ipv6libdir=/usr/local/v6/lib
2221                                 ipv6trylibc=yes])
2222                         ;;
2223                 linux-glibc)
2224                         dnl http://www.v6.linux.or.jp/
2225                         AC_EGREP_CPP(yes, [
2226 #include <features.h>
2227 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2228 yes
2229 #endif],
2230                                 [ipv6type=$i;
2231                                 ipv6trylibc=yes])
2232                         ;;
2233                 linux-inet6)
2234                         dnl http://www.v6.linux.or.jp/
2235                         if test -d /usr/inet6; then
2236                                 ipv6type=$i
2237                                 ipv6lib=inet6
2238                                 ipv6libdir=/usr/inet6/lib
2239                                 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2240                         fi
2241                         ;;
2242                 solaris)
2243                         if test -f /etc/netconfig; then
2244                           if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2245                                 ipv6type=$i
2246                                 ipv6trylibc=yes
2247                           fi
2248                         fi
2249                         ;;
2250                 toshiba)
2251                         AC_EGREP_CPP(yes, [
2252 #include <sys/param.h>
2253 #ifdef _TOSHIBA_INET6
2254 yes
2255 #endif],
2256                                 [ipv6type=$i;
2257                                 ipv6lib=inet6;
2258                                 ipv6libdir=/usr/local/v6/lib])
2259                         ;;
2260                 v6d)
2261                         AC_EGREP_CPP(yes, [
2262 #include </usr/local/v6/include/sys/v6config.h>
2263 #ifdef __V6D__
2264 yes
2265 #endif],
2266                                 [ipv6type=$i;
2267                                 ipv6lib=v6;
2268                                 ipv6libdir=/usr/local/v6/lib;
2269                                 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2270                         ;;
2271                 zeta)
2272                         AC_EGREP_CPP(yes, [
2273 #include <sys/param.h>
2274 #ifdef _ZETA_MINAMI_INET6
2275 yes
2276 #endif],
2277                                 [ipv6type=$i;
2278                                 ipv6lib=inet6;
2279                                 ipv6libdir=/usr/local/v6/lib])
2280                         ;;
2281                 esac
2282                 if test "$ipv6type" != "unknown"; then
2283                         break
2284                 fi
2285         done
2286         AC_MSG_RESULT($ipv6type)
2287 fi
2288
2289 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2290         if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2291                 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2292                 echo "using lib$ipv6lib"
2293         else
2294                 if test $ipv6trylibc = "yes"; then
2295                         echo "using libc"
2296                 else
2297                         echo 'Fatal: no $ipv6lib library found.  cannot continue.'
2298                         echo "You need to fetch lib$ipv6lib.a from appropriate"
2299                         echo 'ipv6 kit and compile beforehand.'
2300                         exit 1
2301                 fi
2302         fi
2303 fi
2304
2305 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2306 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2307   AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2308   AC_MSG_RESULT(yes),
2309   AC_MSG_RESULT(no)
2310 )
2311
2312 # Check for --with-doc-strings
2313 AC_MSG_CHECKING(for --with-doc-strings)
2314 AC_ARG_WITH(doc-strings,
2315             AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2316
2317 if test -z "$with_doc_strings"
2318 then with_doc_strings="yes"
2319 fi
2320 if test "$with_doc_strings" != "no"
2321 then
2322     AC_DEFINE(WITH_DOC_STRINGS, 1,
2323       [Define if you want documentation strings in extension modules])
2324 fi
2325 AC_MSG_RESULT($with_doc_strings)
2326
2327 # Check for Python-specific malloc support
2328 AC_MSG_CHECKING(for --with-tsc)
2329 AC_ARG_WITH(tsc,
2330 [  --with(out)-tsc         enable/disable timestamp counter profile], [
2331 if test "$withval" != no
2332 then
2333   AC_DEFINE(WITH_TSC, 1,
2334     [Define to profile with the Pentium timestamp counter])
2335     AC_MSG_RESULT(yes)
2336 else AC_MSG_RESULT(no)
2337 fi],
2338 [AC_MSG_RESULT(no)])
2339
2340 # Check for Python-specific malloc support
2341 AC_MSG_CHECKING(for --with-pymalloc)
2342 AC_ARG_WITH(pymalloc,
2343             AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2344
2345 if test -z "$with_pymalloc"
2346 then with_pymalloc="yes"
2347 fi
2348 if test "$with_pymalloc" != "no"
2349 then
2350     AC_DEFINE(WITH_PYMALLOC, 1,
2351      [Define if you want to compile in Python-specific mallocs])
2352 fi
2353 AC_MSG_RESULT($with_pymalloc)
2354
2355 # Check for --with-wctype-functions
2356 AC_MSG_CHECKING(for --with-wctype-functions)
2357 AC_ARG_WITH(wctype-functions,
2358             AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2359 [
2360 if test "$withval" != no
2361 then
2362   AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2363   [Define if you want wctype.h functions to be used instead of the
2364    one supplied by Python itself. (see Include/unicodectype.h).])
2365   AC_MSG_RESULT(yes)
2366 else AC_MSG_RESULT(no)
2367 fi],
2368 [AC_MSG_RESULT(no)])
2369
2370 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2371 AC_SUBST(DLINCLDIR)
2372 DLINCLDIR=.
2373
2374 # the dlopen() function means we might want to use dynload_shlib.o. some
2375 # platforms, such as AIX, have dlopen(), but don't want to use it.
2376 AC_CHECK_FUNCS(dlopen)
2377
2378 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2379 # loading of modules.
2380 AC_SUBST(DYNLOADFILE)
2381 AC_MSG_CHECKING(DYNLOADFILE)
2382 if test -z "$DYNLOADFILE"
2383 then
2384         case $ac_sys_system/$ac_sys_release in
2385         AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2386         if test "$ac_cv_func_dlopen" = yes
2387         then DYNLOADFILE="dynload_shlib.o"
2388         else DYNLOADFILE="dynload_aix.o"
2389         fi
2390         ;;
2391         hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2392         # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2393         Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2394         atheos*) DYNLOADFILE="dynload_atheos.o";;
2395         *)
2396         # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2397         # out any dynamic loading
2398         if test "$ac_cv_func_dlopen" = yes
2399         then DYNLOADFILE="dynload_shlib.o"
2400         else DYNLOADFILE="dynload_stub.o"
2401         fi
2402         ;;
2403         esac
2404 fi
2405 AC_MSG_RESULT($DYNLOADFILE)
2406 if test "$DYNLOADFILE" != "dynload_stub.o"
2407 then
2408         AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2409         [Defined when any dynamic module loading is enabled.])
2410 fi
2411
2412 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2413
2414 AC_SUBST(MACHDEP_OBJS)
2415 AC_MSG_CHECKING(MACHDEP_OBJS)
2416 if test -z "$MACHDEP_OBJS"
2417 then
2418         MACHDEP_OBJS=$extra_machdep_objs
2419 else
2420         MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2421 fi
2422 AC_MSG_RESULT(MACHDEP_OBJS)
2423
2424 # checks for library functions
2425 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2426  clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2427  gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2428  getpriority getpwent getspnam getspent getsid getwd \
2429  kill killpg lchmod lchown lstat mbrtowc mkfifo mknod mktime \
2430  mremap nice pathconf pause plock poll pthread_init \
2431  putenv readlink realpath \
2432  select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2433  setgid \
2434  setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2435  sigaction siginterrupt sigrelse strftime strlcpy \
2436  sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2437  truncate uname unsetenv utimes waitpid wait3 wait4 \
2438  wcscoll wcsftime wcsxfrm _getpty)
2439
2440 # For some functions, having a definition is not sufficient, since
2441 # we want to take their address.
2442 AC_MSG_CHECKING(for chroot)
2443 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2444   AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2445   AC_MSG_RESULT(yes),
2446   AC_MSG_RESULT(no)
2447 )
2448 AC_MSG_CHECKING(for link)
2449 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2450   AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2451   AC_MSG_RESULT(yes),
2452   AC_MSG_RESULT(no)
2453 )
2454 AC_MSG_CHECKING(for symlink)
2455 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2456   AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2457   AC_MSG_RESULT(yes),
2458   AC_MSG_RESULT(no)
2459 )
2460 AC_MSG_CHECKING(for fchdir)
2461 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2462   AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2463   AC_MSG_RESULT(yes),
2464   AC_MSG_RESULT(no)
2465 )
2466 AC_MSG_CHECKING(for fsync)
2467 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2468   AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2469   AC_MSG_RESULT(yes),
2470   AC_MSG_RESULT(no)
2471 )
2472 AC_MSG_CHECKING(for fdatasync)
2473 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2474   AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2475   AC_MSG_RESULT(yes),
2476   AC_MSG_RESULT(no)
2477 )
2478 AC_MSG_CHECKING(for epoll)
2479 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2480   AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2481   AC_MSG_RESULT(yes),
2482   AC_MSG_RESULT(no)
2483 )
2484 AC_MSG_CHECKING(for kqueue)
2485 AC_TRY_COMPILE([
2486 #include <sys/types.h>
2487 #include <sys/event.h>
2488     ], int x=kqueue(),
2489   AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2490   AC_MSG_RESULT(yes),
2491   AC_MSG_RESULT(no)
2492 )
2493 # On some systems (eg. FreeBSD 5), we would find a definition of the
2494 # functions ctermid_r, setgroups in the library, but no prototype
2495 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2496 # address to avoid compiler warnings and potential miscompilations
2497 # because of the missing prototypes.
2498
2499 AC_MSG_CHECKING(for ctermid_r)
2500 AC_TRY_COMPILE([
2501 #include "confdefs.h"
2502 #include <stdio.h>
2503 ], void* p = ctermid_r,
2504   AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2505   AC_MSG_RESULT(yes),
2506   AC_MSG_RESULT(no)
2507 )
2508
2509 AC_MSG_CHECKING(for flock)
2510 AC_TRY_COMPILE([
2511 #include "confdefs.h"
2512 #include <sys/file.h>
2513 ], void* p = flock,
2514   AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2515   AC_MSG_RESULT(yes),
2516   AC_MSG_RESULT(no)
2517 )
2518
2519 AC_MSG_CHECKING(for getpagesize)
2520 AC_TRY_COMPILE([
2521 #include "confdefs.h"
2522 #include <unistd.h>
2523 ], void* p = getpagesize,
2524   AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2525   AC_MSG_RESULT(yes),
2526   AC_MSG_RESULT(no)
2527 )
2528
2529 dnl check for true
2530 AC_CHECK_PROGS(TRUE, true, /bin/true)
2531
2532 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2533 dnl On others, they are in the C library, so we to take no action
2534 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2535   AC_CHECK_LIB(resolv, inet_aton)
2536 )
2537
2538 # On Tru64, chflags seems to be present, but calling it will
2539 # exit Python
2540 AC_MSG_CHECKING(for chflags)
2541 AC_TRY_RUN([
2542 #include <sys/stat.h>
2543 #include <unistd.h>
2544 int main(int argc, char*argv[])
2545 {
2546   if(chflags(argv[0], 0) != 0)
2547     return 1;
2548   return 0;
2549 }
2550 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2551   AC_MSG_RESULT(yes),
2552   AC_MSG_RESULT(no)
2553 )
2554
2555 AC_MSG_CHECKING(for lchflags)
2556 AC_TRY_RUN([
2557 #include <sys/stat.h>
2558 #include <unistd.h>
2559 int main(int argc, char*argv[])
2560 {
2561   if(lchflags(argv[0], 0) != 0)
2562     return 1;
2563   return 0;
2564 }
2565 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2566   AC_MSG_RESULT(yes),
2567   AC_MSG_RESULT(no)
2568 )
2569
2570 dnl Check if system zlib has *Copy() functions
2571 dnl
2572 dnl On MacOSX the linker will search for dylibs on the entire linker path
2573 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2574 dnl to revert to a more traditional unix behaviour and make it possible to
2575 dnl override the system libz with a local static library of libz. Temporarily
2576 dnl add that flag to our CFLAGS as well to ensure that we check the version
2577 dnl of libz that will be used by setup.py.
2578 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2579 dnl environment as setup.py (and leaving it out can cause configure to use the
2580 dnl wrong version of the library)
2581 case $ac_sys_system/$ac_sys_release in
2582 Darwin/*)
2583         _CUR_CFLAGS="${CFLAGS}"
2584         _CUR_LDFLAGS="${LDFLAGS}"
2585         CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2586         LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2587         ;;
2588 esac
2589
2590 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2591
2592 case $ac_sys_system/$ac_sys_release in
2593 Darwin/*)
2594         CFLAGS="${_CUR_CFLAGS}"
2595         LDFLAGS="${_CUR_LDFLAGS}"
2596         ;;
2597 esac
2598
2599 AC_MSG_CHECKING(for hstrerror)
2600 AC_TRY_LINK([
2601 #include "confdefs.h"
2602 #include <netdb.h>
2603 ], void* p = hstrerror; hstrerror(0),
2604   AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2605   AC_MSG_RESULT(yes),
2606   AC_MSG_RESULT(no)
2607 )
2608
2609 AC_MSG_CHECKING(for inet_aton)
2610 AC_TRY_LINK([
2611 #include "confdefs.h"
2612 #include <sys/types.h>
2613 #include <sys/socket.h>
2614 #include <netinet/in.h>
2615 #include <arpa/inet.h>
2616 ], void* p = inet_aton;inet_aton(0,0),
2617   AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2618   AC_MSG_RESULT(yes),
2619   AC_MSG_RESULT(no)
2620 )
2621
2622 AC_MSG_CHECKING(for inet_pton)
2623 AC_TRY_COMPILE([
2624 #include "confdefs.h"
2625 #include <sys/types.h>
2626 #include <sys/socket.h>
2627 #include <netinet/in.h>
2628 #include <arpa/inet.h>
2629 ], void* p = inet_pton,
2630   AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2631   AC_MSG_RESULT(yes),
2632   AC_MSG_RESULT(no)
2633 )
2634
2635 # On some systems, setgroups is in unistd.h, on others, in grp.h
2636 AC_MSG_CHECKING(for setgroups)
2637 AC_TRY_COMPILE([
2638 #include "confdefs.h"
2639 #include <unistd.h>
2640 #ifdef HAVE_GRP_H
2641 #include <grp.h>
2642 #endif
2643 ],
2644 void* p = setgroups,
2645   AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2646   AC_MSG_RESULT(yes),
2647   AC_MSG_RESULT(no)
2648 )
2649
2650 # check for openpty and forkpty
2651
2652 AC_CHECK_FUNCS(openpty,,
2653    AC_CHECK_LIB(util,openpty,
2654      [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2655      AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2656    )
2657 )
2658 AC_CHECK_FUNCS(forkpty,,
2659    AC_CHECK_LIB(util,forkpty,
2660      [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2661      AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2662    )
2663 )
2664
2665 # Stuff for expat.
2666 AC_CHECK_FUNCS(memmove)
2667
2668 # check for long file support functions
2669 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2670
2671 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2672 AC_CHECK_FUNCS(getpgrp,
2673   AC_TRY_COMPILE([#include <unistd.h>],
2674    [getpgrp(0);],
2675    AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2676    [Define if getpgrp() must be called as getpgrp(0).])
2677  )
2678 )
2679 AC_CHECK_FUNCS(setpgrp,
2680   AC_TRY_COMPILE([#include <unistd.h>],
2681     [setpgrp(0,0);],
2682     AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2683     [Define if setpgrp() must be called as setpgrp(0, 0).])
2684   )
2685 )
2686 AC_CHECK_FUNCS(gettimeofday,
2687   AC_TRY_COMPILE([#include <sys/time.h>],
2688     [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2689     AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2690     [Define if gettimeofday() does not have second (timezone) argument
2691      This is the case on Motorola V4 (R40V4.2)])
2692   )
2693 )
2694
2695 AC_MSG_CHECKING(for major, minor, and makedev)
2696 AC_TRY_LINK([
2697 #if defined(MAJOR_IN_MKDEV)
2698 #include <sys/mkdev.h>
2699 #elif defined(MAJOR_IN_SYSMACROS)
2700 #include <sys/sysmacros.h>
2701 #else
2702 #include <sys/types.h>
2703 #endif
2704 ],[
2705   makedev(major(0),minor(0));
2706 ],[
2707   AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2708             [Define to 1 if you have the device macros.])
2709   AC_MSG_RESULT(yes)
2710 ],[
2711   AC_MSG_RESULT(no)
2712 ])
2713
2714 # On OSF/1 V5.1, getaddrinfo is available, but a define
2715 # for [no]getaddrinfo in netdb.h.
2716 AC_MSG_CHECKING(for getaddrinfo)
2717 AC_TRY_LINK([
2718 #include <sys/types.h>
2719 #include <sys/socket.h>
2720 #include <netdb.h>
2721 #include <stdio.h>
2722 ],[
2723 getaddrinfo(NULL, NULL, NULL, NULL);
2724 ], [
2725 AC_MSG_RESULT(yes)
2726 AC_MSG_CHECKING(getaddrinfo bug)
2727 AC_TRY_RUN([
2728 #include <sys/types.h>
2729 #include <netdb.h>
2730 #include <string.h>
2731 #include <sys/socket.h>
2732 #include <netinet/in.h>
2733
2734 main()
2735 {
2736   int passive, gaierr, inet4 = 0, inet6 = 0;
2737   struct addrinfo hints, *ai, *aitop;
2738   char straddr[INET6_ADDRSTRLEN], strport[16];
2739
2740   for (passive = 0; passive <= 1; passive++) {
2741     memset(&hints, 0, sizeof(hints));
2742     hints.ai_family = AF_UNSPEC;
2743     hints.ai_flags = passive ? AI_PASSIVE : 0;
2744     hints.ai_socktype = SOCK_STREAM;
2745     hints.ai_protocol = IPPROTO_TCP;
2746     if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2747       (void)gai_strerror(gaierr);
2748       goto bad;
2749     }
2750     for (ai = aitop; ai; ai = ai->ai_next) {
2751       if (ai->ai_addr == NULL ||
2752           ai->ai_addrlen == 0 ||
2753           getnameinfo(ai->ai_addr, ai->ai_addrlen,
2754                       straddr, sizeof(straddr), strport, sizeof(strport),
2755                       NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2756         goto bad;
2757       }
2758       switch (ai->ai_family) {
2759       case AF_INET:
2760         if (strcmp(strport, "54321") != 0) {
2761           goto bad;
2762         }
2763         if (passive) {
2764           if (strcmp(straddr, "0.0.0.0") != 0) {
2765             goto bad;
2766           }
2767         } else {
2768           if (strcmp(straddr, "127.0.0.1") != 0) {
2769             goto bad;
2770           }
2771         }
2772         inet4++;
2773         break;
2774       case AF_INET6:
2775         if (strcmp(strport, "54321") != 0) {
2776           goto bad;
2777         }
2778         if (passive) {
2779           if (strcmp(straddr, "::") != 0) {
2780             goto bad;
2781           }
2782         } else {
2783           if (strcmp(straddr, "::1") != 0) {
2784             goto bad;
2785           }
2786         }
2787         inet6++;
2788         break;
2789       case AF_UNSPEC:
2790         goto bad;
2791         break;
2792       default:
2793         /* another family support? */
2794         break;
2795       }
2796     }
2797   }
2798
2799   if (!(inet4 == 0 || inet4 == 2))
2800     goto bad;
2801   if (!(inet6 == 0 || inet6 == 2))
2802     goto bad;
2803
2804   if (aitop)
2805     freeaddrinfo(aitop);
2806   exit(0);
2807
2808  bad:
2809   if (aitop)
2810     freeaddrinfo(aitop);
2811   exit(1);
2812 }
2813 ],
2814 AC_MSG_RESULT(good)
2815 buggygetaddrinfo=no,
2816 AC_MSG_RESULT(buggy)
2817 buggygetaddrinfo=yes,
2818 AC_MSG_RESULT(buggy)
2819 buggygetaddrinfo=yes)], [
2820 AC_MSG_RESULT(no)
2821 buggygetaddrinfo=yes
2822 ])
2823
2824 if test "$buggygetaddrinfo" = "yes"; then
2825         if test "$ipv6" = "yes"; then
2826                 echo 'Fatal: You must get working getaddrinfo() function.'
2827                 echo '       or you can specify "--disable-ipv6"'.
2828                 exit 1
2829         fi
2830 else
2831         AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2832 fi
2833 AC_CHECK_FUNCS(getnameinfo)
2834
2835 # checks for structures
2836 AC_HEADER_TIME
2837 AC_STRUCT_TM
2838 AC_STRUCT_TIMEZONE
2839 AC_CHECK_MEMBERS([struct stat.st_rdev])
2840 AC_CHECK_MEMBERS([struct stat.st_blksize])
2841 AC_CHECK_MEMBERS([struct stat.st_flags])
2842 AC_CHECK_MEMBERS([struct stat.st_gen])
2843 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2844 AC_STRUCT_ST_BLOCKS
2845
2846 AC_MSG_CHECKING(for time.h that defines altzone)
2847 AC_CACHE_VAL(ac_cv_header_time_altzone,
2848 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2849   ac_cv_header_time_altzone=yes,
2850   ac_cv_header_time_altzone=no)])
2851 AC_MSG_RESULT($ac_cv_header_time_altzone)
2852 if test $ac_cv_header_time_altzone = yes; then
2853   AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2854 fi
2855
2856 was_it_defined=no
2857 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2858 AC_TRY_COMPILE([
2859 #include <sys/types.h>
2860 #include <sys/select.h>
2861 #include <sys/time.h>
2862 ], [;], [
2863   AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2864   [Define if  you can safely include both <sys/select.h> and <sys/time.h>
2865    (which you can't on SCO ODT 3.0).])
2866   was_it_defined=yes
2867 ])
2868 AC_MSG_RESULT($was_it_defined)
2869
2870 AC_MSG_CHECKING(for addrinfo)
2871 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2872 AC_TRY_COMPILE([
2873 #               include <netdb.h>],
2874         [struct addrinfo a],
2875         ac_cv_struct_addrinfo=yes,
2876         ac_cv_struct_addrinfo=no))
2877 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2878 if test $ac_cv_struct_addrinfo = yes; then
2879         AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2880 fi
2881
2882 AC_MSG_CHECKING(for sockaddr_storage)
2883 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2884 AC_TRY_COMPILE([
2885 #               include <sys/types.h>
2886 #               include <sys/socket.h>],
2887         [struct sockaddr_storage s],
2888         ac_cv_struct_sockaddr_storage=yes,
2889         ac_cv_struct_sockaddr_storage=no))
2890 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2891 if test $ac_cv_struct_sockaddr_storage = yes; then
2892         AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2893 fi
2894
2895 # checks for compiler characteristics
2896
2897 AC_C_CHAR_UNSIGNED
2898 AC_C_CONST
2899
2900 works=no
2901 AC_MSG_CHECKING(for working volatile)
2902 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2903   AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2904 )
2905 AC_MSG_RESULT($works)
2906
2907 works=no
2908 AC_MSG_CHECKING(for working signed char)
2909 AC_TRY_COMPILE([], [signed char c;], works=yes,
2910   AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2911 )
2912 AC_MSG_RESULT($works)
2913
2914 have_prototypes=no
2915 AC_MSG_CHECKING(for prototypes)
2916 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2917   AC_DEFINE(HAVE_PROTOTYPES, 1,
2918    [Define if your compiler supports function prototype])
2919   have_prototypes=yes
2920 ])
2921 AC_MSG_RESULT($have_prototypes)
2922
2923 works=no
2924 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2925 AC_TRY_COMPILE([
2926 #include <stdarg.h>
2927 int foo(int x, ...) {
2928         va_list va;
2929         va_start(va, x);
2930         va_arg(va, int);
2931         va_arg(va, char *);
2932         va_arg(va, double);
2933         return 0;
2934 }
2935 ], [return foo(10, "", 3.14);], [
2936   AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2937    [Define if your compiler supports variable length function prototypes
2938    (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2939   works=yes
2940 ])
2941 AC_MSG_RESULT($works)
2942
2943 # check for socketpair
2944 AC_MSG_CHECKING(for socketpair)
2945 AC_TRY_COMPILE([
2946 #include <sys/types.h>
2947 #include <sys/socket.h>
2948 ], void *x=socketpair,
2949   AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2950   AC_MSG_RESULT(yes),
2951   AC_MSG_RESULT(no)
2952 )
2953
2954 # check if sockaddr has sa_len member
2955 AC_MSG_CHECKING(if sockaddr has sa_len member)
2956 AC_TRY_COMPILE([#include <sys/types.h>
2957 #include <sys/socket.h>],
2958 [struct sockaddr x;
2959 x.sa_len = 0;],
2960         AC_MSG_RESULT(yes)
2961         AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2962         AC_MSG_RESULT(no))
2963
2964 va_list_is_array=no
2965 AC_MSG_CHECKING(whether va_list is an array)
2966 AC_TRY_COMPILE([
2967 #ifdef HAVE_STDARG_PROTOTYPES
2968 #include <stdarg.h>
2969 #else
2970 #include <varargs.h>
2971 #endif
2972 ], [va_list list1, list2; list1 = list2;], , [
2973  AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2974  va_list_is_array=yes
2975 ])
2976 AC_MSG_RESULT($va_list_is_array)
2977
2978 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2979 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2980   [Define this if you have some version of gethostbyname_r()])
2981
2982 AC_CHECK_FUNC(gethostbyname_r, [
2983   AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2984   AC_MSG_CHECKING([gethostbyname_r with 6 args])
2985   OLD_CFLAGS=$CFLAGS
2986   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2987   AC_TRY_COMPILE([
2988 #   include <netdb.h>
2989   ], [
2990     char *name;
2991     struct hostent *he, *res;
2992     char buffer[2048];
2993     int buflen = 2048;
2994     int h_errnop;
2995
2996     (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2997   ], [
2998     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2999     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3000     [Define this if you have the 6-arg version of gethostbyname_r().])
3001     AC_MSG_RESULT(yes)
3002   ], [
3003     AC_MSG_RESULT(no)
3004     AC_MSG_CHECKING([gethostbyname_r with 5 args])
3005     AC_TRY_COMPILE([
3006 #     include <netdb.h>
3007     ], [
3008       char *name;
3009       struct hostent *he;
3010       char buffer[2048];
3011       int buflen = 2048;
3012       int h_errnop;
3013
3014       (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3015     ], [
3016       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3017       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3018       [Define this if you have the 5-arg version of gethostbyname_r().])
3019       AC_MSG_RESULT(yes)
3020     ], [
3021       AC_MSG_RESULT(no)
3022       AC_MSG_CHECKING([gethostbyname_r with 3 args])
3023       AC_TRY_COMPILE([
3024 #       include <netdb.h>
3025       ], [
3026         char *name;
3027         struct hostent *he;
3028         struct hostent_data data;
3029
3030         (void) gethostbyname_r(name, he, &data);
3031       ], [
3032         AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3033         AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3034         [Define this if you have the 3-arg version of gethostbyname_r().])
3035         AC_MSG_RESULT(yes)
3036       ], [
3037         AC_MSG_RESULT(no)
3038       ])
3039     ])
3040   ])
3041   CFLAGS=$OLD_CFLAGS
3042 ], [
3043   AC_CHECK_FUNCS(gethostbyname)
3044 ])
3045 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3046 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3047 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3048 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3049 AC_SUBST(HAVE_GETHOSTBYNAME)
3050
3051 # checks for system services
3052 # (none yet)
3053
3054 # Linux requires this for correct f.p. operations
3055 AC_CHECK_FUNC(__fpu_control,
3056   [],
3057   [AC_CHECK_LIB(ieee, __fpu_control)
3058 ])
3059
3060 # Check for --with-fpectl
3061 AC_MSG_CHECKING(for --with-fpectl)
3062 AC_ARG_WITH(fpectl,
3063             AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3064 [
3065 if test "$withval" != no
3066 then
3067   AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3068   [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3069   AC_MSG_RESULT(yes)
3070 else AC_MSG_RESULT(no)
3071 fi],
3072 [AC_MSG_RESULT(no)])
3073
3074 # check for --with-libm=...
3075 AC_SUBST(LIBM)
3076 case $ac_sys_system in
3077 Darwin) ;;
3078 *) LIBM=-lm
3079 esac
3080 AC_MSG_CHECKING(for --with-libm=STRING)
3081 AC_ARG_WITH(libm,
3082             AC_HELP_STRING(--with-libm=STRING, math library),
3083 [
3084 if test "$withval" = no
3085 then LIBM=
3086      AC_MSG_RESULT(force LIBM empty)
3087 elif test "$withval" != yes
3088 then LIBM=$withval
3089      AC_MSG_RESULT(set LIBM="$withval")
3090 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3091 fi],
3092 [AC_MSG_RESULT(default LIBM="$LIBM")])
3093
3094 # check for --with-libc=...
3095 AC_SUBST(LIBC)
3096 AC_MSG_CHECKING(for --with-libc=STRING)
3097 AC_ARG_WITH(libc,
3098             AC_HELP_STRING(--with-libc=STRING, C library),
3099 [
3100 if test "$withval" = no
3101 then LIBC=
3102      AC_MSG_RESULT(force LIBC empty)
3103 elif test "$withval" != yes
3104 then LIBC=$withval
3105      AC_MSG_RESULT(set LIBC="$withval")
3106 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3107 fi],
3108 [AC_MSG_RESULT(default LIBC="$LIBC")])
3109
3110 # **************************************************
3111 # * Check for various properties of floating point *
3112 # **************************************************
3113
3114 AC_MSG_CHECKING(whether C doubles are little-endian IEEE 754 binary64)
3115 AC_CACHE_VAL(ac_cv_little_endian_double, [
3116 AC_TRY_RUN([
3117 #include <string.h>
3118 int main() {
3119     double x = 9006104071832581.0;
3120     if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
3121         return 0;
3122     else
3123         return 1;
3124 }
3125 ],
3126 ac_cv_little_endian_double=yes,
3127 ac_cv_little_endian_double=no,
3128 ac_cv_little_endian_double=no)])
3129 AC_MSG_RESULT($ac_cv_little_endian_double)
3130 if test "$ac_cv_little_endian_double" = yes
3131 then
3132   AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1,
3133   [Define if C doubles are 64-bit IEEE 754 binary format, stored
3134    with the least significant byte first])
3135 fi
3136
3137 AC_MSG_CHECKING(whether C doubles are big-endian IEEE 754 binary64)
3138 AC_CACHE_VAL(ac_cv_big_endian_double, [
3139 AC_TRY_RUN([
3140 #include <string.h>
3141 int main() {
3142     double x = 9006104071832581.0;
3143     if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
3144         return 0;
3145     else
3146         return 1;
3147 }
3148 ],
3149 ac_cv_big_endian_double=yes,
3150 ac_cv_big_endian_double=no,
3151 ac_cv_big_endian_double=no)])
3152 AC_MSG_RESULT($ac_cv_big_endian_double)
3153 if test "$ac_cv_big_endian_double" = yes
3154 then
3155   AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1,
3156   [Define if C doubles are 64-bit IEEE 754 binary format, stored
3157    with the most significant byte first])
3158 fi
3159
3160 # Some ARM platforms use a mixed-endian representation for doubles.
3161 # While Python doesn't currently have full support for these platforms
3162 # (see e.g., issue 1762561), we can at least make sure that float <-> string
3163 # conversions work.
3164 AC_MSG_CHECKING(whether C doubles are ARM mixed-endian IEEE 754 binary64)
3165 AC_CACHE_VAL(ac_cv_mixed_endian_double, [
3166 AC_TRY_RUN([
3167 #include <string.h>
3168 int main() {
3169     double x = 9006104071832581.0;
3170     if (memcmp(&x, "\x01\xff\x3f\x43\x05\x04\x03\x02", 8) == 0)
3171         return 0;
3172     else
3173         return 1;
3174 }
3175 ],
3176 ac_cv_mixed_endian_double=yes,
3177 ac_cv_mixed_endian_double=no,
3178 ac_cv_mixed_endian_double=no)])
3179 AC_MSG_RESULT($ac_cv_mixed_endian_double)
3180 if test "$ac_cv_mixed_endian_double" = yes
3181 then
3182   AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1,
3183   [Define if C doubles are 64-bit IEEE 754 binary format, stored
3184    in ARM mixed-endian order (byte order 45670123)])
3185 fi
3186
3187 # The short float repr introduced in Python 3.1 requires the
3188 # correctly-rounded string <-> double conversion functions from
3189 # Python/dtoa.c, which in turn require that the FPU uses 53-bit
3190 # rounding; this is a problem on x86, where the x87 FPU has a default
3191 # rounding precision of 64 bits.  For gcc/x86, we try to fix this by
3192 # using inline assembler to get and set the x87 FPU control word.
3193 if test "$GCC" = yes && test -n "`$CC -dM -E - </dev/null | grep i386`"
3194 then
3195     # Check that it's okay to use gcc inline assembler to get and set
3196     # x87 control word.  It should be, but you never know...
3197     AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word)
3198     AC_TRY_COMPILE([], [
3199       unsigned short cw;
3200       __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
3201       __asm__ __volatile__ ("fldcw %0" : : "m" (cw));
3202     ],
3203     [have_gcc_asm_for_x87=yes], [have_gcc_asm_for_x87=no])
3204     AC_MSG_RESULT($have_gcc_asm_for_x87)
3205     if test "$have_gcc_asm_for_x87" = yes
3206     then
3207         AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1,
3208         [Define if we can use gcc inline assembler to get and set x87 control word])
3209     fi
3210 fi
3211
3212 # Detect whether system arithmetic is subject to x87-style double
3213 # rounding issues.  The result of this test has little meaning on non
3214 # IEEE 754 platforms.  On IEEE 754, test should return 1 if rounding
3215 # mode is round-to-nearest and double rounding issues are present, and
3216 # 0 otherwise.  See http://bugs.python.org/issue2937 for more info.
3217 AC_MSG_CHECKING(for x87-style double rounding)
3218 # $BASECFLAGS may affect the result
3219 ac_save_cc="$CC"
3220 CC="$CC $BASECFLAGS"
3221 AC_TRY_RUN([
3222 #include <stdlib.h>
3223 #include <math.h>
3224 int main() {
3225     volatile double x, y, z;
3226     /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3227     x = 0.99999999999999989; /* 1-2**-53 */
3228     y = 1./x;
3229     if (y != 1.)
3230         exit(0);
3231     /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3232     x = 1e16;
3233     y = 2.99999;
3234     z = x + y;
3235     if (z != 1e16+4.)
3236         exit(0);
3237     /* both tests show evidence of double rounding */
3238     exit(1);
3239 }
3240 ],
3241 ac_cv_x87_double_rounding=no,
3242 ac_cv_x87_double_rounding=yes,
3243 ac_cv_x87_double_rounding=no)
3244 CC="$ac_save_cc"
3245 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3246 if test "$ac_cv_x87_double_rounding" = yes
3247 then
3248   AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3249   [Define if arithmetic is subject to x87-style double rounding issue])
3250 fi
3251
3252 # ************************************
3253 # * Check for mathematical functions *
3254 # ************************************
3255
3256 LIBS_SAVE=$LIBS
3257 LIBS="$LIBS $LIBM"
3258
3259 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3260 # -0. on some architectures.
3261 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3262 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3263 AC_TRY_RUN([
3264 #include <math.h>
3265 #include <stdlib.h>
3266 int main() {
3267     /* return 0 if either negative zeros don't exist
3268        on this platform or if negative zeros exist
3269        and tanh(-0.) == -0. */
3270   if (atan2(0., -1.) == atan2(-0., -1.) ||
3271       atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3272   else exit(1);
3273 }
3274 ],
3275 ac_cv_tanh_preserves_zero_sign=yes,
3276 ac_cv_tanh_preserves_zero_sign=no,
3277 ac_cv_tanh_preserves_zero_sign=no)])
3278 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3279 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3280 then
3281   AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3282   [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3283 fi
3284
3285 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p round])
3286 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3287
3288 LIBS=$LIBS_SAVE
3289
3290 # Multiprocessing check for broken sem_getvalue
3291 AC_MSG_CHECKING(for broken sem_getvalue)
3292 AC_TRY_RUN([
3293 #include <unistd.h>
3294 #include <fcntl.h>
3295 #include <stdio.h>
3296 #include <semaphore.h>
3297 #include <sys/stat.h>
3298
3299 int main(void){
3300   sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3301   int count;
3302   int res;
3303   if(a==SEM_FAILED){
3304     perror("sem_open");
3305     return 1;
3306
3307   }
3308   res = sem_getvalue(a, &count);
3309   sem_close(a);
3310   return res==-1 ? 1 : 0;
3311 }
3312 ]
3313 ,AC_MSG_RESULT(no),
3314  AC_MSG_RESULT(yes)
3315   AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3316 )
3317
3318 # determine what size digit to use for Python's longs
3319 AC_MSG_CHECKING([digit size for Python's longs])
3320 AC_ARG_ENABLE(big-digits,
3321 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3322 [case $enable_big_digits in
3323 yes)
3324   enable_big_digits=30 ;;
3325 no)
3326   enable_big_digits=15 ;;
3327 [15|30])
3328   ;;
3329 *)
3330   AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3331 esac
3332 AC_MSG_RESULT($enable_big_digits)
3333 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3334 ],
3335 [AC_MSG_RESULT(no value specified)])
3336
3337 # check for wchar.h
3338 AC_CHECK_HEADER(wchar.h, [
3339   AC_DEFINE(HAVE_WCHAR_H, 1,
3340   [Define if the compiler provides a wchar.h header file.])
3341   wchar_h="yes"
3342 ],
3343 wchar_h="no"
3344 )
3345
3346 # determine wchar_t size
3347 if test "$wchar_h" = yes
3348 then
3349   AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3350 fi
3351
3352 AC_MSG_CHECKING(for UCS-4 tcl)
3353 have_ucs4_tcl=no
3354 AC_TRY_COMPILE([
3355 #include <tcl.h>
3356 #if TCL_UTF_MAX != 6
3357 # error "NOT UCS4_TCL"
3358 #endif], [], [
3359   AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3360   have_ucs4_tcl=yes
3361 ])
3362 AC_MSG_RESULT($have_ucs4_tcl)
3363
3364 # check whether wchar_t is signed or not
3365 if test "$wchar_h" = yes
3366 then
3367   # check whether wchar_t is signed or not
3368   AC_MSG_CHECKING(whether wchar_t is signed)
3369   AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3370   AC_TRY_RUN([
3371   #include <wchar.h>
3372   int main()
3373   {
3374         /* Success: exit code 0 */
3375         exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3376   }
3377   ],
3378   ac_cv_wchar_t_signed=yes,
3379   ac_cv_wchar_t_signed=no,
3380   ac_cv_wchar_t_signed=yes)])
3381   AC_MSG_RESULT($ac_cv_wchar_t_signed)
3382 fi
3383
3384 AC_MSG_CHECKING(what type to use for str)
3385 AC_ARG_WITH(wide-unicode,
3386             AC_HELP_STRING(--with-wide-unicode, Use 4-byte Unicode characters (default is 2 bytes)),
3387 [
3388 if test "$withval" != no
3389 then unicode_size="4"
3390 else unicode_size="2"
3391 fi
3392 ],
3393 [
3394 case "$have_ucs4_tcl" in
3395   yes) unicode_size="4" ;;
3396   *)   unicode_size="2" ;;
3397 esac
3398 ])
3399
3400 AH_TEMPLATE(Py_UNICODE_SIZE,
3401   [Define as the size of the unicode type.])
3402 case "$unicode_size" in
3403   4) AC_DEFINE(Py_UNICODE_SIZE, 4) ;;
3404   *) AC_DEFINE(Py_UNICODE_SIZE, 2) ;;
3405 esac
3406
3407 AH_TEMPLATE(PY_UNICODE_TYPE,
3408   [Define as the integral type used for Unicode representation.])
3409
3410 # wchar_t is only usable if it maps to an unsigned type
3411 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3412           -a "$ac_cv_wchar_t_signed" = "no"
3413 then
3414   PY_UNICODE_TYPE="wchar_t"
3415   AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3416   [Define if you have a useable wchar_t type defined in wchar.h; useable
3417    means wchar_t must be an unsigned type with at least 16 bits. (see
3418    Include/unicodeobject.h).])
3419   AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3420 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3421 then
3422      PY_UNICODE_TYPE="unsigned short"
3423      AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3424 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3425 then
3426      PY_UNICODE_TYPE="unsigned long"
3427      AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3428 else
3429      PY_UNICODE_TYPE="no type found"
3430 fi
3431 AC_MSG_RESULT($PY_UNICODE_TYPE)
3432
3433 # check for endianness
3434 AC_C_BIGENDIAN
3435
3436 # Check whether right shifting a negative integer extends the sign bit
3437 # or fills with zeros (like the Cray J90, according to Tim Peters).
3438 AC_MSG_CHECKING(whether right shift extends the sign bit)
3439 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3440 AC_TRY_RUN([
3441 int main()
3442 {
3443         exit(((-1)>>3 == -1) ? 0 : 1);
3444 }
3445 ],
3446 ac_cv_rshift_extends_sign=yes,
3447 ac_cv_rshift_extends_sign=no,
3448 ac_cv_rshift_extends_sign=yes)])
3449 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3450 if test "$ac_cv_rshift_extends_sign" = no
3451 then
3452   AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3453   [Define if i>>j for signed int i does not extend the sign bit
3454    when i < 0])
3455 fi
3456
3457 # check for getc_unlocked and related locking functions
3458 AC_MSG_CHECKING(for getc_unlocked() and friends)
3459 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3460 AC_TRY_LINK([#include <stdio.h>],[
3461         FILE *f = fopen("/dev/null", "r");
3462         flockfile(f);
3463         getc_unlocked(f);
3464         funlockfile(f);
3465 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3466 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3467 if test "$ac_cv_have_getc_unlocked" = yes
3468 then
3469   AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3470   [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3471 fi
3472
3473 # check where readline lives
3474 # save the value of LIBS so we don't actually link Python with readline
3475 LIBS_no_readline=$LIBS
3476
3477 # On some systems we need to link readline to a termcap compatible
3478 # library.  NOTE: Keep the precedence of listed libraries synchronised
3479 # with setup.py.
3480 py_cv_lib_readline=no
3481 AC_MSG_CHECKING([how to link readline libs])
3482 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3483   if test -z "$py_libtermcap"; then
3484     READLINE_LIBS="-lreadline"
3485   else
3486     READLINE_LIBS="-lreadline -l$py_libtermcap"
3487   fi
3488   LIBS="$READLINE_LIBS $LIBS_no_readline"
3489   AC_LINK_IFELSE(
3490     [AC_LANG_CALL([],[readline])],
3491     [py_cv_lib_readline=yes])
3492   if test $py_cv_lib_readline = yes; then
3493     break
3494   fi
3495 done
3496 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3497 #AC_SUBST([READLINE_LIBS])
3498 if test $py_cv_lib_readline = no; then
3499   AC_MSG_RESULT([none])
3500 else
3501   AC_MSG_RESULT([$READLINE_LIBS])
3502   AC_DEFINE(HAVE_LIBREADLINE, 1,
3503     [Define if you have the readline library (-lreadline).])
3504 fi
3505
3506 # check for readline 2.1
3507 AC_CHECK_LIB(readline, rl_callback_handler_install,
3508         AC_DEFINE(HAVE_RL_CALLBACK, 1,
3509         [Define if you have readline 2.1]), ,$READLINE_LIBS)
3510
3511 # check for readline 2.2
3512 AC_TRY_CPP([#include <readline/readline.h>],
3513 have_readline=yes, have_readline=no)
3514 if test $have_readline = yes
3515 then
3516   AC_EGREP_HEADER([extern int rl_completion_append_character;],
3517   [readline/readline.h],
3518   AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3519   [Define if you have readline 2.2]), )
3520 fi
3521
3522 # check for readline 4.0
3523 AC_CHECK_LIB(readline, rl_pre_input_hook,
3524         AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3525         [Define if you have readline 4.0]), ,$READLINE_LIBS)
3526
3527 # also in 4.0
3528 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3529         AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3530         [Define if you have readline 4.0]), ,$READLINE_LIBS)
3531
3532 # check for readline 4.2
3533 AC_CHECK_LIB(readline, rl_completion_matches,
3534         AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3535         [Define if you have readline 4.2]), ,$READLINE_LIBS)
3536
3537 # also in readline 4.2
3538 AC_TRY_CPP([#include <readline/readline.h>],
3539 have_readline=yes, have_readline=no)
3540 if test $have_readline = yes
3541 then
3542   AC_EGREP_HEADER([extern int rl_catch_signals;],
3543   [readline/readline.h],
3544   AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3545   [Define if you can turn off readline's signal handling.]), )
3546 fi
3547
3548 # End of readline checks: restore LIBS
3549 LIBS=$LIBS_no_readline
3550
3551 AC_MSG_CHECKING(for broken nice())
3552 AC_CACHE_VAL(ac_cv_broken_nice, [
3553 AC_TRY_RUN([
3554 int main()
3555 {
3556         int val1 = nice(1);
3557         if (val1 != -1 && val1 == nice(2))
3558                 exit(0);
3559         exit(1);
3560 }
3561 ],
3562 ac_cv_broken_nice=yes,
3563 ac_cv_broken_nice=no,
3564 ac_cv_broken_nice=no)])
3565 AC_MSG_RESULT($ac_cv_broken_nice)
3566 if test "$ac_cv_broken_nice" = yes
3567 then
3568   AC_DEFINE(HAVE_BROKEN_NICE, 1,
3569   [Define if nice() returns success/failure instead of the new priority.])
3570 fi
3571
3572 AC_MSG_CHECKING(for broken poll())
3573 AC_TRY_RUN([
3574 #include <poll.h>
3575
3576 int main (void)
3577     {
3578     struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3579
3580     close (42);
3581
3582     int poll_test = poll (&poll_struct, 1, 0);
3583
3584     if (poll_test < 0)
3585         {
3586         exit(0);
3587         }
3588     else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3589         {
3590         exit(0);
3591         }
3592     else
3593         {
3594         exit(1);
3595         }
3596     }
3597 ],
3598 ac_cv_broken_poll=yes,
3599 ac_cv_broken_poll=no,
3600 ac_cv_broken_poll=no)
3601 AC_MSG_RESULT($ac_cv_broken_poll)
3602 if test "$ac_cv_broken_poll" = yes
3603 then
3604   AC_DEFINE(HAVE_BROKEN_POLL, 1,
3605       [Define if poll() sets errno on invalid file descriptors.])
3606 fi
3607
3608 # Before we can test tzset, we need to check if struct tm has a tm_zone
3609 # (which is not required by ISO C or UNIX spec) and/or if we support
3610 # tzname[]
3611 AC_STRUCT_TIMEZONE
3612
3613 # check tzset(3) exists and works like we expect it to
3614 AC_MSG_CHECKING(for working tzset())
3615 AC_CACHE_VAL(ac_cv_working_tzset, [
3616 AC_TRY_RUN([
3617 #include <stdlib.h>
3618 #include <time.h>
3619 #include <string.h>
3620
3621 #if HAVE_TZNAME
3622 extern char *tzname[];
3623 #endif
3624
3625 int main()
3626 {
3627         /* Note that we need to ensure that not only does tzset(3)
3628            do 'something' with localtime, but it works as documented
3629            in the library reference and as expected by the test suite.
3630            This includes making sure that tzname is set properly if
3631            tm->tm_zone does not exist since it is the alternative way
3632            of getting timezone info.
3633
3634            Red Hat 6.2 doesn't understand the southern hemisphere
3635            after New Year's Day.
3636         */
3637
3638         time_t groundhogday = 1044144000; /* GMT-based */
3639         time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3640
3641         putenv("TZ=UTC+0");
3642         tzset();
3643         if (localtime(&groundhogday)->tm_hour != 0)
3644             exit(1);
3645 #if HAVE_TZNAME
3646         /* For UTC, tzname[1] is sometimes "", sometimes "   " */
3647         if (strcmp(tzname[0], "UTC") ||
3648                 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3649             exit(1);
3650 #endif
3651
3652         putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3653         tzset();
3654         if (localtime(&groundhogday)->tm_hour != 19)
3655             exit(1);
3656 #if HAVE_TZNAME
3657         if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3658             exit(1);
3659 #endif
3660
3661         putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3662         tzset();
3663         if (localtime(&groundhogday)->tm_hour != 11)
3664             exit(1);
3665 #if HAVE_TZNAME
3666         if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3667             exit(1);
3668 #endif
3669
3670 #if HAVE_STRUCT_TM_TM_ZONE
3671         if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3672             exit(1);
3673         if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3674             exit(1);
3675 #endif
3676
3677         exit(0);
3678 }
3679 ],
3680 ac_cv_working_tzset=yes,
3681 ac_cv_working_tzset=no,
3682 ac_cv_working_tzset=no)])
3683 AC_MSG_RESULT($ac_cv_working_tzset)
3684 if test "$ac_cv_working_tzset" = yes
3685 then
3686   AC_DEFINE(HAVE_WORKING_TZSET, 1,
3687   [Define if tzset() actually switches the local timezone in a meaningful way.])
3688 fi
3689
3690 # Look for subsecond timestamps in struct stat
3691 AC_MSG_CHECKING(for tv_nsec in struct stat)
3692 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3693 AC_TRY_COMPILE([#include <sys/stat.h>], [
3694 struct stat st;
3695 st.st_mtim.tv_nsec = 1;
3696 ],
3697 ac_cv_stat_tv_nsec=yes,
3698 ac_cv_stat_tv_nsec=no,
3699 ac_cv_stat_tv_nsec=no))
3700 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3701 if test "$ac_cv_stat_tv_nsec" = yes
3702 then
3703   AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3704   [Define if you have struct stat.st_mtim.tv_nsec])
3705 fi
3706
3707 # Look for BSD style subsecond timestamps in struct stat
3708 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3709 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3710 AC_TRY_COMPILE([#include <sys/stat.h>], [
3711 struct stat st;
3712 st.st_mtimespec.tv_nsec = 1;
3713 ],
3714 ac_cv_stat_tv_nsec2=yes,
3715 ac_cv_stat_tv_nsec2=no,
3716 ac_cv_stat_tv_nsec2=no))
3717 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3718 if test "$ac_cv_stat_tv_nsec2" = yes
3719 then
3720   AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3721   [Define if you have struct stat.st_mtimensec])
3722 fi
3723
3724 # On HP/UX 11.0, mvwdelch is a block with a return statement
3725 AC_MSG_CHECKING(whether mvwdelch is an expression)
3726 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3727 AC_TRY_COMPILE([#include <curses.h>], [
3728   int rtn;
3729   rtn = mvwdelch(0,0,0);
3730 ], ac_cv_mvwdelch_is_expression=yes,
3731    ac_cv_mvwdelch_is_expression=no,
3732    ac_cv_mvwdelch_is_expression=yes))
3733 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3734
3735 if test "$ac_cv_mvwdelch_is_expression" = yes
3736 then
3737   AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3738   [Define if mvwdelch in curses.h is an expression.])
3739 fi
3740
3741 AC_MSG_CHECKING(whether WINDOW has _flags)
3742 AC_CACHE_VAL(ac_cv_window_has_flags,
3743 AC_TRY_COMPILE([#include <curses.h>], [
3744   WINDOW *w;
3745   w->_flags = 0;
3746 ], ac_cv_window_has_flags=yes,
3747    ac_cv_window_has_flags=no,
3748    ac_cv_window_has_flags=no))
3749 AC_MSG_RESULT($ac_cv_window_has_flags)
3750
3751
3752 if test "$ac_cv_window_has_flags" = yes
3753 then
3754   AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3755   [Define if WINDOW in curses.h offers a field _flags.])
3756 fi
3757
3758 AC_MSG_CHECKING(for is_term_resized)
3759 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3760   AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3761   AC_MSG_RESULT(yes),
3762   AC_MSG_RESULT(no)
3763 )
3764
3765 AC_MSG_CHECKING(for resize_term)
3766 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3767   AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3768   AC_MSG_RESULT(yes),
3769   AC_MSG_RESULT(no)
3770 )
3771
3772 AC_MSG_CHECKING(for resizeterm)
3773 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3774   AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3775   AC_MSG_RESULT(yes),
3776   AC_MSG_RESULT(no)
3777 )
3778
3779 AC_MSG_CHECKING(for /dev/ptmx)
3780
3781 if test -r /dev/ptmx
3782 then
3783   AC_MSG_RESULT(yes)
3784   AC_DEFINE(HAVE_DEV_PTMX, 1,
3785   [Define if we have /dev/ptmx.])
3786 else
3787   AC_MSG_RESULT(no)
3788 fi
3789
3790 AC_MSG_CHECKING(for /dev/ptc)
3791
3792 if test -r /dev/ptc
3793 then
3794   AC_MSG_RESULT(yes)
3795   AC_DEFINE(HAVE_DEV_PTC, 1,
3796   [Define if we have /dev/ptc.])
3797 else
3798   AC_MSG_RESULT(no)
3799 fi
3800
3801 AC_MSG_CHECKING(for %zd printf() format support)
3802 AC_TRY_RUN([#include <stdio.h>
3803 #include <stddef.h>
3804 #include <string.h>
3805
3806 #ifdef HAVE_SYS_TYPES_H
3807 #include <sys/types.h>
3808 #endif
3809
3810 #ifdef HAVE_SSIZE_T
3811 typedef ssize_t Py_ssize_t;
3812 #elif SIZEOF_VOID_P == SIZEOF_LONG
3813 typedef long Py_ssize_t;
3814 #else
3815 typedef int Py_ssize_t;
3816 #endif
3817
3818 int main()
3819 {
3820     char buffer[256];
3821
3822     if(sprintf(buffer, "%zd", (size_t)123) < 0)
3823         return 1;
3824
3825     if (strcmp(buffer, "123"))
3826         return 1;
3827
3828     if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3829         return 1;
3830
3831     if (strcmp(buffer, "-123"))
3832         return 1;
3833
3834     return 0;
3835 }],
3836 [AC_MSG_RESULT(yes)
3837  AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3838  AC_MSG_RESULT(no))
3839
3840 AC_CHECK_TYPE(socklen_t,,
3841   AC_DEFINE(socklen_t,int,
3842             Define to `int' if <sys/socket.h> does not define.),[
3843 #ifdef HAVE_SYS_TYPES_H
3844 #include <sys/types.h>
3845 #endif
3846 #ifdef HAVE_SYS_SOCKET_H
3847 #include <sys/socket.h>
3848 #endif
3849 ])
3850
3851 AC_MSG_CHECKING(for broken mbstowcs)
3852 AC_TRY_RUN([
3853 #include<stdlib.h>
3854 int main() {
3855     size_t len = -1;
3856     const char *str = "text";
3857     len = mbstowcs(NULL, str, 0);
3858     return (len != 4);
3859 }
3860 ],
3861 ac_cv_broken_mbstowcs=no,
3862 ac_cv_broken_mbstowcs=yes,
3863 ac_cv_broken_mbstowcs=no)
3864 AC_MSG_RESULT($ac_cv_broken_mbstowcs)
3865 if test "$ac_cv_broken_mbstowcs" = yes
3866 then
3867   AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
3868   [Define if mbstowcs(NULL, "text", 0) does not return the number of
3869    wide chars that would be converted.])
3870 fi
3871
3872 # Check for --with-computed-gotos
3873 AC_MSG_CHECKING(for --with-computed-gotos)
3874 AC_ARG_WITH(computed-gotos,
3875             AC_HELP_STRING(--with-computed-gotos,
3876                            Use computed gotos / threaded dispatch in evaluation loop (not available on all compilers)),
3877 [
3878 if test "$withval" != no
3879 then
3880   AC_DEFINE(USE_COMPUTED_GOTOS, 1,
3881   [Define if you want to use computed gotos in ceval.c.])
3882   AC_MSG_RESULT(yes)
3883 else AC_MSG_RESULT(no)
3884 fi],
3885 [AC_MSG_RESULT(no)])
3886
3887
3888 AC_SUBST(THREADHEADERS)
3889
3890 for h in `(cd $srcdir;echo Python/thread_*.h)`
3891 do
3892   THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3893 done
3894
3895 AC_SUBST(SRCDIRS)
3896 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3897 AC_MSG_CHECKING(for build directories)
3898 for dir in $SRCDIRS; do
3899     if test ! -d $dir; then
3900         mkdir $dir
3901     fi
3902 done
3903 AC_MSG_RESULT(done)
3904
3905 # generate output files
3906 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
3907 AC_OUTPUT
3908
3909 echo "creating Modules/Setup"
3910 if test ! -f Modules/Setup
3911 then
3912         cp $srcdir/Modules/Setup.dist Modules/Setup
3913 fi
3914
3915 echo "creating Modules/Setup.local"
3916 if test ! -f Modules/Setup.local
3917 then
3918         echo "# Edit this file for local setup changes" >Modules/Setup.local
3919 fi
3920
3921 echo "creating Makefile"
3922 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3923                         -s Modules Modules/Setup.config \
3924                         Modules/Setup.local Modules/Setup
3925 mv config.c Modules