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