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