configure.in

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