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