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