configure.in

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