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