configure.in

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