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