configure.in

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