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