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