configure.in

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