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