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