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