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