dnl Process this file with autoconf 2.0 or later to make a configure script.

# Set VERSION so we only need to edit in one place (i.e., here)

m4_define(PYTHON_VERSION, 2.3)

AC_REVISION($Revision$)

AC_PREREQ(2.53)

AC_INIT(python, PYTHON_VERSION)

AC_CONFIG_SRCDIR([Include/object.h])

AC_CONFIG_HEADER(pyconfig.h)

dnl This is for stuff that absolutely must end up in pyconfig.h.

dnl Please use pyport.h instead, if possible.

AH_TOP([

#ifndef Py_PYCONFIG_H

#define Py_PYCONFIG_H

])

AH_BOTTOM([

/* Define the macros needed if on a UnixWare 7.x system. */

#if defined(__USLC__) && defined(__SCO_VERSION__)

#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */

#endif

#endif /*Py_PYCONFIG_H*/

])

# We don't use PACKAGE_ variables, and they cause conflicts

# with other autoconf-based packages that include Python.h

grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new

rm confdefs.h

mv confdefs.h.new confdefs.h

AC_SUBST(VERSION)

VERSION=PYTHON_VERSION

AC_SUBST(SOVERSION)

SOVERSION=1.0

# The later defininition of _XOPEN_SOURCE disables certain features

# on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).

AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])

# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables

# certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable

# them.

AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])

# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables

# certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable

# them.

AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])

# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables

# u_int on Irix 5.3. Defining _BSD_TYPES brings it back.

AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])

define_xopen_source=yes

# Arguments passed to configure.

AC_SUBST(CONFIG_ARGS)

CONFIG_ARGS="$ac_configure_args"

dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output

AC_ARG_ENABLE(framework,

AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),

[

case $enableval in

yes)

enableval=/Library/Frameworks

esac

case $enableval in

no)

PYTHONFRAMEWORK=

PYTHONFRAMEWORKDIR=no-framework

PYTHONFRAMEWORKPREFIX=

PYTHONFRAMEWORKINSTALLDIR=

enable_framework=

;;

*)

PYTHONFRAMEWORK=Python

PYTHONFRAMEWORKDIR=Python.framework

PYTHONFRAMEWORKPREFIX=$enableval

PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR

prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION

esac

],[

PYTHONFRAMEWORK=

PYTHONFRAMEWORKDIR=no-framework

PYTHONFRAMEWORKPREFIX=

PYTHONFRAMEWORKINSTALLDIR=

enable_framework=

])

AC_SUBST(PYTHONFRAMEWORK)

AC_SUBST(PYTHONFRAMEWORKDIR)

AC_SUBST(PYTHONFRAMEWORKPREFIX)

AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)

##AC_ARG_WITH(dyld,

## AC_HELP_STRING(--with-dyld,

## Use (OpenStep|Rhapsody) dynamic linker))

##

# Set name for machine-dependent library files

AC_SUBST(MACHDEP)

AC_MSG_CHECKING(MACHDEP)

if test -z "$MACHDEP"

then

ac_sys_system=`uname -s`

if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \

-o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then

ac_sys_release=`uname -v`

else

ac_sys_release=`uname -r`

fi

ac_md_system=`echo $ac_sys_system |

tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`

ac_md_release=`echo $ac_sys_release |

tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`

MACHDEP="$ac_md_system$ac_md_release"

case $MACHDEP in

cygwin*) MACHDEP="cygwin";;

darwin*) MACHDEP="darwin";;

atheos*) MACHDEP="atheos";;

irix646) MACHDEP="irix6";;

'') MACHDEP="unknown";;

esac

fi

# Some systems cannot stand _XOPEN_SOURCE being defined at all; they

# disable features if it is defined, without any means to access these

# features as extensions. For these systems, we skip the definition of

# _XOPEN_SOURCE. Before adding a system to the list to gain access to

# some feature, make sure there is no alternative way to access this

# feature. Also, when using wildcards, make sure you have verified the

# need for not defining _XOPEN_SOURCE on all systems matching the

# wildcard, and that the wildcard does not include future systems

# (which may remove their limitations).

dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output

case $ac_sys_system/$ac_sys_release in

# On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,

# even though select is a POSIX function. Reported by J. Ribbens.

# Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.

OpenBSD/2.* | OpenBSD/3.@<:@01234@:>@)

define_xopen_source=no;;

# On Solaris 2.6, sys/wait.h is inconsistent in the usage

# of union __?sigval. Reported by Stuart Bishop.

SunOS/5.6)

define_xopen_source=no;;

# On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,

# but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.

# Reconfirmed for 7.1.4 by Martin v. Loewis.

OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)

define_xopen_source=no;;

# On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,

# but used in struct sockaddr.sa_family. Reported by Tim Rice.

SCO_SV/3.2)

define_xopen_source=no;;

# On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that

# it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,

# this is fixed in 10.3, which identifies itself as Darwin/7.*

# This should hopefully be fixed in FreeBSD 4.9

FreeBSD/4.8* | Darwin/6* )

define_xopen_source=no;;

# On AIX 4, mbstate_t is defined only when _XOPEN_SOURCE == 500 but used in

# wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined or

# has another value. By not (re)defining it, the defaults come in place.

AIX/4)

define_xopen_source=no;;

esac

if test $define_xopen_source = yes

then

AC_DEFINE(_XOPEN_SOURCE, 600,

Define to the level of X/Open that your system supports)

# On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires

# definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else

# several APIs are not declared. Since this is also needed in some

# cases for HP-UX, we define it globally.

AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1, Define to activate Unix95-and-earlier features)

AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)

fi

#

# SGI compilers allow the specification of the both the ABI and the

# ISA on the command line. Depending on the values of these switches,

# different and often incompatable code will be generated.

#

# The SGI_ABI variable can be used to modify the CC and LDFLAGS and

# thus supply support for various ABI/ISA combinations. The MACHDEP

# variable is also adjusted.

#

AC_SUBST(SGI_ABI)

if test ! -z "$SGI_ABI"

then

CC="cc $SGI_ABI"

LDFLAGS="$SGI_ABI $LDFLAGS"

MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`

fi

AC_MSG_RESULT($MACHDEP)

# And add extra plat-mac for darwin

AC_SUBST(EXTRAPLATDIR)

AC_SUBST(EXTRAMACHDEPPATH)

AC_MSG_CHECKING(EXTRAPLATDIR)

if test -z "$EXTRAPLATDIR"

then

case $MACHDEP in

darwin)

EXTRAPLATDIR="\$(PLATMACDIRS)"

EXTRAMACHDEPPATH="\$(PLATMACPATH)"

;;

*)

EXTRAPLATDIR=""

EXTRAMACHDEPPATH=""

;;

esac

fi

AC_MSG_RESULT($EXTRAPLATDIR)

# Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,

# it may influence the way we can build extensions, so distutils

# needs to check it

AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)

CONFIGURE_MACOSX_DEPLOYMENT_TARGET=

# checks for alternative programs

# compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just

# for debug/optimization stuff. BASECFLAGS is for flags that are required

# just to get things to compile and link. Users are free to override OPT

# when running configure or make. The build should not break if they do.

# BASECFLAGS should generally not be messed with, however.

# XXX shouldn't some/most/all of this code be merged with the stuff later

# on that fiddles with OPT and BASECFLAGS?

AC_MSG_CHECKING(for --without-gcc)

AC_ARG_WITH(gcc,

AC_HELP_STRING(--without-gcc,never use gcc),

[

case $withval in

no) CC=cc

without_gcc=yes;;

yes) CC=gcc

without_gcc=no;;

*) CC=$withval

without_gcc=$withval;;

esac], [

case $ac_sys_system in

AIX*) CC=cc_r

without_gcc=;;

BeOS*)

case $BE_HOST_CPU in

ppc)

CC=mwcc

without_gcc=yes

BASECFLAGS="$BASECFLAGS -export pragma"

OPT="$OPT -O"

LDFLAGS="$LDFLAGS -nodup"

;;

x86)

CC=gcc

without_gcc=no

OPT="$OPT -O"

;;

*)

AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])

;;

esac

AR="\$(srcdir)/Modules/ar_beos"

RANLIB=:

;;

Monterey*)

RANLIB=:

without_gcc=;;

*) without_gcc=no;;

esac])

AC_MSG_RESULT($without_gcc)

AC_SUBST(CXX)

AC_SUBST(MAINOBJ)

MAINOBJ=python.o

AC_MSG_CHECKING(for --with-cxx=<compiler>)

AC_ARG_WITH(cxx,

AC_HELP_STRING(--with-cxx=<compiler>, enable C++ support),

[

check_cxx=no

case $withval in

no) CXX=

with_cxx=no;;

*) CXX=$withval

MAINOBJ=ccpython.o

with_cxx=$withval;;

esac], [

with_cxx=no

check_cxx=yes

])

AC_MSG_RESULT($with_cxx)

if test "$with_cxx" = "yes"

then

AC_MSG_ERROR([must supply a compiler when using --with-cxx])

fi

dnl The following fragment works similar to AC_PROG_CXX.

dnl It does not fail if CXX is not found, and it is not executed if

dnl --without-cxx was given.

dnl Finally, it does not test whether CXX is g++.

dnl Autoconf 2.5x does not have AC_PROG_CXX_WORKS anymore

ifdef([AC_PROG_CXX_WORKS],[],

[AC_DEFUN([AC_PROG_CXX_WORKS],

[AC_LANG_PUSH(C++)dnl

_AC_COMPILER_EXEEXT

AC_LANG_POP()

]

)])

if test "$check_cxx" = "yes"

then

AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)

if test "$CXX" = "notfound"

then

CXX=

else

AC_PROG_CXX_WORKS

fi

fi

# If the user switches compilers, we can't believe the cache

if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"

then

AC_MSG_ERROR([cached CC is different -- throw away $cache_file

(it is also a good idea to do 'make clean' before compiling)])

fi

AC_PROG_CC

# checks for UNIX variants that set C preprocessor variables

AC_AIX

AC_MINIX

# Check for unsupported systems

case $ac_sys_system/$ac_sys_release in

SunOS/4*|DYNIX/*|dgux*/*|IRIX/4*|Linux*/1*)

echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.

echo See README for details.

exit 1;;

esac

if test "$MINIX" = yes; then

echo This system \(MINIX\) is no longer supported.

echo Read README for details.

exit 1

fi

AC_EXEEXT

AC_MSG_CHECKING(for --with-suffix)

AC_ARG_WITH(suffix,

AC_HELP_STRING(--with-suffix=.exe, set executable suffix),

[

case $withval in

no) EXEEXT=;;

yes) EXEEXT=.exe;;

*) EXEEXT=$withval;;

esac])

AC_MSG_RESULT($EXEEXT)

# Test whether we're running on a non-case-sensitive system, in which

# case we give a warning if no ext is given

AC_SUBST(BUILDEXEEXT)

AC_MSG_CHECKING(for case-insensitive build directory)

if test ! -d CaseSensitiveTestDir; then

mkdir CaseSensitiveTestDir

fi

if test -d casesensitivetestdir

then

AC_MSG_RESULT(yes)

BUILDEXEEXT=.exe

else

AC_MSG_RESULT(no)

BUILDEXEEXT=$EXEEXT

fi

rmdir CaseSensitiveTestDir

case $MACHDEP in

bsdos*)

case $CC in

gcc) CC="$CC -D_HAVE_BSDI";;

esac;;

esac

case $ac_sys_system in

hp*|HP*)

case $CC in

cc|*/cc) CC="$CC -Ae";;

esac;;

Monterey*)

case $CC in

cc) CC="$CC -Wl,-Bexport";;

esac;;

SunOS*)

# Some functions have a prototype only with that define, e.g. confstr

AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])

;;

esac

AC_SUBST(LIBRARY)

AC_MSG_CHECKING(LIBRARY)

if test -z "$LIBRARY"

then

LIBRARY='libpython$(VERSION).a'

fi

AC_MSG_RESULT($LIBRARY)

# LDLIBRARY is the name of the library to link against (as opposed to the

# name of the library into which to insert object files). BLDLIBRARY is also

# the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY

# is blank as the main program is not linked directly against LDLIBRARY.

# LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On

# systems without shared libraries, LDLIBRARY is the same as LIBRARY

# (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,

# DLLLIBRARY is the shared (i.e., DLL) library.

#

# RUNSHARED is used to run shared python without installed libraries

#

# INSTSONAME is the name of the shared library that will be use to install

# on the system - some systems like version suffix, others don't

AC_SUBST(LDLIBRARY)

AC_SUBST(DLLLIBRARY)

AC_SUBST(BLDLIBRARY)

AC_SUBST(LDLIBRARYDIR)

AC_SUBST(INSTSONAME)

AC_SUBST(RUNSHARED)

LDLIBRARY="$LIBRARY"

BLDLIBRARY='$(LDLIBRARY)'

INSTSONAME='$(LDLIBRARY)'

DLLLIBRARY=''

LDLIBRARYDIR=''

RUNSHARED=''

# LINKCC is the command that links the python executable -- default is $(CC).

# If CXX is set, and if it is needed to link a main function that was

# compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:

# python might then depend on the C++ runtime

# This is altered for AIX in order to build the export list before

# linking.

AC_SUBST(LINKCC)

AC_MSG_CHECKING(LINKCC)

if test -z "$LINKCC"

then

if test -z "$CXX"; then

LINKCC="\$(PURIFY) \$(CC)"

else

echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext

$CXX -c conftest.$ac_ext 2>&5

if $CC -o conftest$ac_exeext conftest.$ac_objext 2>&5 \

&& test -s conftest$ac_exeext && ./conftest$ac_exeext

then

LINKCC="\$(PURIFY) \$(CC)"

else

LINKCC="\$(PURIFY) \$(CXX)"

fi

rm -fr conftest*

fi

case $ac_sys_system in

AIX*)

exp_extra="\"\""

if test $ac_sys_release -ge 5 -o \

$ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then

exp_extra="."

fi

LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;

dgux*)

LINKCC="LD_RUN_PATH=$libdir $LINKCC";;

Monterey64*)

LINKCC="$LINKCC -L/usr/lib/ia64l64";;

esac

fi

AC_MSG_RESULT($LINKCC)

AC_MSG_CHECKING(for --enable-shared)

AC_ARG_ENABLE(shared,

AC_HELP_STRING(--enable-shared, disable/enable building shared python library))

if test -z "$enable_shared"

then

case $ac_sys_system in

CYGWIN* | atheos*)

enable_shared="yes";;

*)

enable_shared="no";;

esac

fi

AC_MSG_RESULT($enable_shared)

AC_MSG_CHECKING(LDLIBRARY)

# MacOSX framework builds need more magic. LDLIBRARY is the dynamic

# library that we build, but we do not want to link against it (we

# will find it with a -framework option). For this reason there is an

# extra variable BLDLIBRARY against which Python and the extension

# modules are linked, BLDLIBRARY. This is normally the same as

# LDLIBRARY, but empty for MacOSX framework builds.

if test "$enable_framework"

then

LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'

RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"

BLDLIBRARY=''

else

BLDLIBRARY='$(LDLIBRARY)'

fi

# Other platforms follow

if test $enable_shared = "yes"; then

AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])

case $ac_sys_system in

BeOS*)

LDLIBRARY='libpython$(VERSION).so'

;;

CYGWIN*)

LDLIBRARY='libpython$(VERSION).dll.a'

DLLLIBRARY='libpython$(VERSION).dll'

;;

SunOS*)

LDLIBRARY='libpython$(VERSION).so'

BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'

RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}

INSTSONAME="$LDLIBRARY".$SOVERSION

;;

Linux*|GNU*|NetBSD*)

LDLIBRARY='libpython$(VERSION).so'

BLDLIBRARY='-L. -lpython$(VERSION)'

RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}

INSTSONAME="$LDLIBRARY".$SOVERSION

;;

hp*|HP*)

LDLIBRARY='libpython$(VERSION).sl'

BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'

RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}

;;

OSF*)

LDLIBRARY='libpython$(VERSION).so'

BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'

RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}

;;

atheos*)

LDLIBRARY='libpython$(VERSION).so'

BLDLIBRARY='-L. -lpython$(VERSION)'

RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}

;;

esac

# DG/UX requires some fancy ld contortions to produce a .so from an .a

case $MACHDEP in

dguxR4)

LDLIBRARY='libpython$(VERSION).so'

BASECFLAGS="$BASECFLAGS -pic"

;;

esac

fi

AC_MSG_RESULT($LDLIBRARY)

AC_PROG_RANLIB

AC_SUBST(AR)

AC_CHECK_PROGS(AR, ar aal, ar)

case $MACHDEP in

bsdos*|hp*|HP*)

# install -d does not work on BSDI or HP-UX

if test -z "$INSTALL"

then

INSTALL="${srcdir}/install-sh -c"

fi

esac

AC_PROG_INSTALL

# Not every filesystem supports hard links

AC_SUBST(LN)

if test -z "$LN" ; then

case $ac_sys_system in

BeOS*) LN="ln -s";;

CYGWIN*) LN="ln -s";;

atheos*) LN="ln -s";;

*) LN=ln;;

esac

fi

# Check for --with-pydebug

AC_MSG_CHECKING(for --with-pydebug)

AC_ARG_WITH(pydebug,

AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),

[

if test "$withval" != no

then

AC_DEFINE(Py_DEBUG, 1,

[Define if you want to build an interpreter with many run-time checks.])

AC_MSG_RESULT(yes);

Py_DEBUG='true'

else AC_MSG_RESULT(no); Py_DEBUG='false'

fi],

[AC_MSG_RESULT(no)])

# XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be

# merged with this chunk of code?

# Optimizer/debugger flags

# ------------------------

# (The following bit of code is complicated enough - please keep things

# indented properly. Just pretend you're editing Python code. ;-)

# There are two parallel sets of case statements below, one that checks to

# see if OPT was set and one that does BASECFLAGS setting based upon

# compiler and platform. BASECFLAGS tweaks need to be made even if the

# user set OPT.

# tweak OPT based on compiler and platform, only if the user didn't set

# it on the command line

AC_SUBST(OPT)

if test -z "$OPT"

then

case $GCC in

yes)

case $ac_cv_prog_cc_g in

yes)

if test "$Py_DEBUG" = 'true' ; then

# Optimization messes up debuggers, so turn it off for

# debug builds.

OPT="-g -Wall -Wstrict-prototypes"

else

OPT="-g -O3 -Wall -Wstrict-prototypes"

fi

;;

*)

OPT="-O3 -Wall -Wstrict-prototypes"

;;

esac

case $ac_sys_system in

SCO_SV*) OPT="$OPT -m486 -DSCO5"

;;

esac

;;

*)

OPT="-O"

;;

esac

# The current (beta) Monterey compiler dies with optimizations

# XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?

case $ac_sys_system in

Monterey*)

OPT=""

;;

esac

fi

AC_SUBST(BASECFLAGS)

# tweak BASECFLAGS based on compiler and platform

case $GCC in

yes)

# Python violates C99 rules, by casting between incompatible

# pointer types. GCC may generate bad code as a result of that,

# so use -fno-strict-aliasing if supported.

AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)

ac_save_cc="$CC"

CC="$CC -fno-strict-aliasing"

AC_TRY_RUN([int main() { return 0; }],

ac_cv_no_strict_aliasing_ok=yes,

ac_cv_no_strict_aliasing_ok=no,

ac_cv_no_strict_aliasing_ok=no)

CC="$ac_save_cc"

AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)

if test $ac_cv_no_strict_aliasing_ok = yes

then

BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"

fi

case $ac_sys_system in

SCO_SV*)

BASECFLAGS="$BASECFLAGS -m486 -DSCO5"

;;

# is there any other compiler on Darwin besides gcc?

Darwin*)

BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"

;;

esac

;;

*)

case $ac_sys_system in

OpenUNIX*|UnixWare*)

BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "

;;

OSF*)

BASECFLAGS="$BASECFLAGS -ieee -std"

;;

SCO_SV*)

BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"

;;

esac

;;

esac

if test "$Py_DEBUG" = 'true'; then

:

else

OPT="-DNDEBUG $OPT"

fi

if test "$ac_arch_flags"

then

BASECFLAGS="$BASECFLAGS $ac_arch_flags"

fi

AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)

AC_CACHE_VAL(ac_cv_opt_olimit_ok,

[ac_save_cc="$CC"

CC="$CC -OPT:Olimit=0"

AC_TRY_RUN([int main() { return 0; }],

ac_cv_opt_olimit_ok=yes,

ac_cv_opt_olimit_ok=no,

ac_cv_opt_olimit_ok=no)

CC="$ac_save_cc"])

AC_MSG_RESULT($ac_cv_opt_olimit_ok)

if test $ac_cv_opt_olimit_ok = yes; then

case $ac_sys_system in

# XXX is this branch needed? On MacOSX 10.2.2 the result of the

# olimit_ok test is "no". Is it "yes" in some other Darwin-esque

# environment?

Darwin*)

;;

*)

BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"

;;

esac

else

AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)

AC_CACHE_VAL(ac_cv_olimit_ok,

[ac_save_cc="$CC"

CC="$CC -Olimit 1500"

AC_TRY_RUN([int main() { return 0; }],

ac_cv_olimit_ok=yes,

ac_cv_olimit_ok=no,

ac_cv_olimit_ok=no)

CC="$ac_save_cc"])

AC_MSG_RESULT($ac_cv_olimit_ok)

if test $ac_cv_olimit_ok = yes; then

BASECFLAGS="$BASECFLAGS -Olimit 1500"

fi

fi

# On some compilers, pthreads are available without further options

# (e.g. MacOS X). On some of these systems, the compiler will not

# complain if unaccepted options are passed (e.g. gcc on Mac OS X).

# So we have to see first whether pthreads are available without

# options before we can check whether -Kpthread improves anything.

AC_MSG_CHECKING(whether pthreads are available without options)

AC_CACHE_VAL(ac_cv_pthread_is_default,

[AC_TRY_RUN([

#include <pthread.h>

void* routine(void* p){return NULL;}

int main(){

pthread_t p;

if(pthread_create(&p,NULL,routine,NULL)!=0)

return 1;

(void)pthread_detach(p);

return 0;

}

],

[

ac_cv_pthread_is_default=yes

ac_cv_kthread=no

ac_cv_pthread=no

],

ac_cv_pthread_is_default=no,

ac_cv_pthread_is_default=no)

])

AC_MSG_RESULT($ac_cv_pthread_is_default)

if test $ac_cv_pthread_is_default = yes

then

ac_cv_kpthread=no

else

# -Kpthread, if available, provides the right #defines

# and linker options to make pthread_create available

# Some compilers won't report that they do not support -Kpthread,

# so we need to run a program to see whether it really made the

# function available.

AC_MSG_CHECKING(whether $CC accepts -Kpthread)

AC_CACHE_VAL(ac_cv_kpthread,

[ac_save_cc="$CC"

CC="$CC -Kpthread"

AC_TRY_RUN([

#include <pthread.h>

void* routine(void* p){return NULL;}

int main(){

pthread_t p;

if(pthread_create(&p,NULL,routine,NULL)!=0)

return 1;

(void)pthread_detach(p);

return 0;

}

],

ac_cv_kpthread=yes,

ac_cv_kpthread=no,

ac_cv_kpthread=no)

CC="$ac_save_cc"])

AC_MSG_RESULT($ac_cv_kpthread)

fi

if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no

then

# -Kthread, if available, provides the right #defines

# and linker options to make pthread_create available

# Some compilers won't report that they do not support -Kthread,

# so we need to run a program to see whether it really made the

# function available.

AC_MSG_CHECKING(whether $CC accepts -Kthread)

AC_CACHE_VAL(ac_cv_kthread,

[ac_save_cc="$CC"

CC="$CC -Kthread"

AC_TRY_RUN([

#include <pthread.h>

void* routine(void* p){return NULL;}

int main(){

pthread_t p;

if(pthread_create(&p,NULL,routine,NULL)!=0)

return 1;

(void)pthread_detach(p);

return 0;

}

],

ac_cv_kthread=yes,

ac_cv_kthread=no,

ac_cv_kthread=no)

CC="$ac_save_cc"])

AC_MSG_RESULT($ac_cv_kthread)

fi

if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no

then

# -pthread, if available, provides the right #defines

# and linker options to make pthread_create available

# Some compilers won't report that they do not support -pthread,

# so we need to run a program to see whether it really made the

# function available.

AC_MSG_CHECKING(whether $CC accepts -pthread)

AC_CACHE_VAL(ac_cv_thread,

[ac_save_cc="$CC"

CC="$CC -pthread"

AC_TRY_RUN([

#include <pthread.h>

void* routine(void* p){return NULL;}

int main(){

pthread_t p;

if(pthread_create(&p,NULL,routine,NULL)!=0)

return 1;

(void)pthread_detach(p);

return 0;

}

],

ac_cv_pthread=yes,

ac_cv_pthread=no,

ac_cv_pthread=no)

CC="$ac_save_cc"])

AC_MSG_RESULT($ac_cv_pthread)

fi

# If we have set a CC compiler flag for thread support then

# check if it works for CXX, too.

ac_cv_cxx_thread=no

if test ! -z "$CXX"

then

AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)

ac_save_cxx="$CXX"

if test "$ac_cv_kpthread" = "yes"

then

CXX="$CXX -Kpthread"

ac_cv_cxx_thread=yes

elif test "$ac_cv_kthread" = "yes"

then

CXX="$CXX -Kthread"

ac_cv_cxx_thread=yes

elif test "$ac_cv_pthread" = "yes"

then

CXX="$CXX -pthread"

ac_cv_cxx_thread=yes

fi

if test $ac_cv_cxx_thread = yes

then

echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext

$CXX -c conftest.$ac_ext 2>&5

if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \

&& test -s conftest$ac_exeext && ./conftest$ac_exeext

then

ac_cv_cxx_thread=yes

else

ac_cv_cxx_thread=no

fi

rm -fr conftest*

fi

fi

CXX="$ac_save_cxx"

AC_MSG_RESULT($ac_cv_cxx_thread)

dnl # check for ANSI or K&R ("traditional") preprocessor

dnl AC_MSG_CHECKING(for C preprocessor type)

dnl AC_TRY_COMPILE([

dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}

dnl int foo;

dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");

dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)

dnl AC_MSG_RESULT($cpp_type)

# checks for header files

AC_HEADER_STDC

AC_CHECK_HEADERS(curses.h dlfcn.h fcntl.h grp.h limits.h langinfo.h \

libintl.h locale.h ncurses.h poll.h pthread.h \

signal.h stdarg.h stddef.h stdlib.h stropts.h termios.h thread.h \

unistd.h utime.h \

sys/audioio.h sys/bsdtty.h sys/file.h sys/lock.h sys/mkdev.h sys/modem.h \

sys/param.h sys/poll.h sys/select.h sys/socket.h sys/time.h sys/times.h \

sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \

sys/resource.h netpacket/packet.h sysexits.h)

AC_HEADER_DIRENT

AC_HEADER_MAJOR

# On Solaris, term.h requires curses.h

AC_CHECK_HEADER(term.h,,,[

#ifdef HAVE_CURSES_H

#include <curses.h>

#endif

])

# checks for typedefs

was_it_defined=no

AC_MSG_CHECKING(for clock_t in time.h)

AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [

AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])

])

AC_MSG_RESULT($was_it_defined)

# Check whether using makedev requires defining _OSF_SOURCE

AC_MSG_CHECKING(for makedev)

AC_TRY_LINK([#include <sys/types.h> ],

[ makedev(0, 0) ],

ac_cv_has_makedev=yes,

ac_cv_has_makedev=no)

if test "$ac_cv_has_makedev" = "no"; then

# we didn't link, try if _OSF_SOURCE will allow us to link

AC_TRY_LINK([

#define _OSF_SOURCE 1

#include <sys/types.h>

],

[ makedev(0, 0) ],

ac_cv_has_makedev=yes,

ac_cv_has_makedev=no)

if test "$ac_cv_has_makedev" = "yes"; then

AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])

fi

fi

AC_MSG_RESULT($ac_cv_has_makedev)

if test "$ac_cv_has_makedev" = "yes"; then

AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])

fi

# Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in

# the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are

# defined, but the compiler does not support pragma redefine_extname,

# and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit

# structures (such as rlimit64) without declaring them. As a

# work-around, disable LFS on such configurations

use_lfs=yes

AC_MSG_CHECKING(Solaris LFS bug)

AC_TRY_COMPILE([

#define _LARGEFILE_SOURCE 1

#define _FILE_OFFSET_BITS 64

#include <sys/resource.h>

],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)

AC_MSG_RESULT($sol_lfs_bug)

if test "$sol_lfs_bug" = "yes"; then

use_lfs=no