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