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