configure.in

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