configure.in

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