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