configure.in

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