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