configure.in

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