configure.in

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