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