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)

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

# 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*/

])

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])

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";;

'') 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.

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

define_xopen_source=no;;

# On FreeBSD 5.0, chroot and setgroups are not declared if _XOPEN_SOURCE

# is define. Reported by M. Recht.

FreeBSD/5.0*)

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)

# checks for alternative programs

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

OPT="-O -export pragma"

LDFLAGS="$LDFLAGS -nodup"

;;

x86)

CC=gcc

without_gcc=no

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

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*)

LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp \"\" \$(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)'

LDLIBRARYDIR='$(PYTHONFRAMEWORKDIR)'

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,-rpath,$(LIBDIR) -L. -lpython$(VERSION)'

RUNSHARED=LD_LIBRARY_PATH=`pwd`:$LD_LIBRARY_PATH

;;

Linux*|GNU*)

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'

OPT="$OPT -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)])

# Optimizer/debugger flags

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

;;

*)

case $ac_sys_system in

OpenUNIX*|UnixWare*)

OPT="-O -K pentium,host,inline,loop_unroll,alloca ";;

SCO_SV*)

CFLAGS="$CFLAGS -belf"

OPT="-belf -O -Ki486 -DSCO5";;

*)

OPT="-O";;

esac

esac

case $ac_sys_system in

Darwin*)

OPT="$OPT -Wno-long-double -no-cpp-precomp";;

esac

fi

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

:

else

OPT="-DNDEBUG $OPT"

fi

# The current (beta) Monterey compiler dies with optimizations

case $ac_sys_system in

Monterey*) OPT="";;

esac

if test "$ac_arch_flags"

then

OPT="$OPT $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

Darwin*) OPT="$OPT" ;;

*) OPT="$OPT -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

OPT="$OPT -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_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

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(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 thread.h unistd.h utime.h termios.h \

sys/audioio.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 term.h libutil.h \

sys/resource.h netpacket/packet.h)

AC_HEADER_DIRENT

AC_HEADER_MAJOR

# 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

fi

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

# Two defines needed to enable largefile support on various platforms

# These may affect some typedefs

AC_DEFINE(_LARGEFILE_SOURCE, 1,

[This must be defined on some systems to enable large file support.])

AC_DEFINE(_FILE_OFFSET_BITS, 64,

[This must be set to 64 on some systems to enable large file support.])

fi

# Add some code to confdefs.h so that the test for off_t works on SCO

cat >> confdefs.h <<\EOF

#if defined(SCO_DS)

#undef _OFF_T

#endif

EOF

# Type availability checks

AC_TYPE_MODE_T

AC_TYPE_OFF_T

AC_TYPE_PID_T

AC_TYPE_SIGNAL

AC_TYPE_SIZE_T

AC_TYPE_UID_T

# Sizes of various common basic types

AC_CHECK_SIZEOF(int, 4)

AC_CHECK_SIZEOF(long, 4)

AC_CHECK_SIZEOF(void *, 4)

AC_CHECK_SIZEOF(char, 1)

AC_CHECK_SIZEOF(short, 2)

AC_CHECK_SIZEOF(float, 4)

AC_CHECK_SIZEOF(double, 8)

AC_CHECK_SIZEOF(fpos_t, 4)

AC_MSG_CHECKING(for long long support)

have_long_long=no

AC_TRY_COMPILE([], [long long x; x = (long long)0;], [

AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])

have_long_long=yes

])

AC_MSG_RESULT($have_long_long)

if test "$have_long_long" = yes ; then

AC_CHECK_SIZEOF(long long, 8)

fi

AC_MSG_CHECKING(for uintptr_t support)

have_uintptr_t=no

AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [

AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])

have_uintptr_t=yes

])

AC_MSG_RESULT($have_uintptr_t)

if test "$have_uintptr_t" = yes ; then

AC_CHECK_SIZEOF(uintptr_t, 4)

fi

# Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.

AC_MSG_CHECKING(size of off_t)

AC_CACHE_VAL(ac_cv_sizeof_off_t,

[AC_TRY_RUN([#include <stdio.h>

#include <sys/types.h>

main()

{

FILE *f=fopen("conftestval", "w");

if (!f) exit(1);

fprintf(f, "%d\n", sizeof(off_t));

exit(0);

}],

ac_cv_sizeof_off_t=`cat conftestval`,

ac_cv_sizeof_off_t=0,

ac_cv_sizeof_off_t=4)

])

AC_MSG_RESULT($ac_cv_sizeof_off_t)

AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,

[The number of bytes in an off_t.])

AC_MSG_CHECKING(whether to enable large file support)

if test "$have_long_long" = yes -a \

"$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \

"$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then

AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,

[Defined to enable large file support when an off_t is bigger than a long

and long long is available and at least as big as an off_t. You may need

to add some flags for configuration and compilation to enable this mode.

(For Solaris and Linux, the necessary defines are already defined.)])

AC_MSG_RESULT(yes)

else

AC_MSG_RESULT(no)

fi

# AC_CHECK_SIZEOF() doesn't include <time.h>.

AC_MSG_CHECKING(size of time_t)

AC_CACHE_VAL(ac_cv_sizeof_time_t,

[AC_TRY_RUN([#include <stdio.h>

#include <time.h>

main()

{

FILE *f=fopen("conftestval", "w");

if (!f) exit(1);

fprintf(f, "%d\n", sizeof(time_t));

exit(0);

}],

ac_cv_sizeof_time_t=`cat conftestval`,

ac_cv_sizeof_time_t=0,

ac_cv_sizeof_time_t=4)

])

AC_MSG_RESULT($ac_cv_sizeof_time_t)

AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,

[The number of bytes in a time_t.])

# if have pthread_t then define SIZEOF_PTHREAD_T

ac_save_cc="$CC"

if test "$ac_cv_kpthread" = "yes"

then CC="$CC -Kpthread"

fi

AC_MSG_CHECKING(for pthread_t)

have_pthread_t=no

AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)

AC_MSG_RESULT($have_pthread_t)

if test "$have_pthread_t" = yes ; then

# AC_CHECK_SIZEOF() doesn't include <pthread.h>.

AC_MSG_CHECKING(size of pthread_t)

AC_CACHE_VAL(ac_cv_sizeof_pthread_t,

[AC_TRY_RUN([#include <stdio.h>

#include <pthread.h>

main()

{

FILE *f=fopen("conftestval", "w");

if (!f) exit(1);

fprintf(f, "%d\n", sizeof(pthread_t));

exit(0);

}],

ac_cv_sizeof_pthread_t=`cat conftestval`,

ac_cv_sizeof_pthread_t=0,

ac_cv_sizeof_pthread_t=4)

])

AC_MSG_RESULT($ac_cv_sizeof_pthread_t)

AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,

[The number of bytes in a pthread_t.])

fi

CC="$ac_save_cc"

AC_MSG_CHECKING(for --enable-toolbox-glue)

AC_ARG_ENABLE(toolbox-glue,

AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))

if test -z "$enable_toolbox_glue"

then

case $ac_sys_system/$ac_sys_release in

Darwin/*)

enable_toolbox_glue="yes";;

*)

enable_toolbox_glue="no";;

esac

fi

case "$enable_toolbox_glue" in

yes)

extra_frameworks="-framework CoreServices -framework Foundation"

extra_machdep_objs="Python/mactoolboxglue.o"

extra_undefs="-u __dummy -u _PyMac_Error"

AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,

[Define if you want to use MacPython modules on MacOSX in unix-Python.])

;;

*)

extra_frameworks=""

extra_machdep_objs=""

extra_undefs=""

;;

esac

AC_MSG_RESULT($enable_toolbox_glue)

AC_SUBST(LIBTOOL_CRUFT)

case $ac_sys_system/$ac_sys_release in

Darwin/1.3*)

LIBTOOL_CRUFT="-lcc_dynamic -arch_only ppc"

LIBTOOL_CRUFT="$LIBTOOL_CRUFT $extra_frameworks"

LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Python'

LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;

Darwin/*)

LIBTOOL_CRUFT="-lcc_dynamic -arch_only ppc"

LIBTOOL_CRUFT="$LIBTOOL_CRUFT $extra_frameworks"

LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Python'

LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;

esac

AC_MSG_CHECKING(for --enable-framework)

if test "$enable_framework"

then

OPT="$OPT -fno-common -dynamic"

# -F. is needed to allow linking to the framework while

# in the build location.

LDFLAGS="$LDFLAGS -Wl,-F."

AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,

[Define if you want to produce an OpenStep/Rhapsody framework

(shared library plus accessory files).])

AC_MSG_RESULT(yes)

else

AC_MSG_RESULT(no)

fi

AC_MSG_CHECKING(for dyld)

case $ac_sys_system/$ac_sys_release in

Darwin/*)

AC_DEFINE(WITH_DYLD, 1,

[Define if you want to use the new-style (Openstep, Rhapsody, MacOS)

dynamic linker (dyld) instead of the old-style (NextStep) dynamic

linker (rld). Dyld is necessary to support frameworks.])

AC_MSG_RESULT(always on for Darwin)

;;

*)

AC_MSG_RESULT(no)

;;

esac

# Set info about shared libraries.

AC_SUBST(SO)

AC_SUBST(LDSHARED)

AC_SUBST(BLDSHARED)

AC_SUBST(CCSHARED)

AC_SUBST(LINKFORSHARED)

# SO is the extension of shared libraries `(including the dot!)

# -- usually .so, .sl on HP-UX, .dll on Cygwin

AC_MSG_CHECKING(SO)

if test -z "$SO"

then

case $ac_sys_system in

hp*|HP*) SO=.sl;;

CYGWIN*) SO=.dll;;

*) SO=.so;;

esac

fi

AC_MSG_RESULT($SO)

# LDSHARED is the ld *command* used to create shared library

# -- "ld" on SunOS 4.x.x, "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5

# (Shared libraries in this instance are shared modules to be loaded into

# Python, as opposed to building Python itself as a shared library.)

AC_MSG_CHECKING(LDSHARED)

if test -z "$LDSHARED"

then

case $ac_sys_system/$ac_sys_release in

AIX*)

BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"

LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"

;;

BeOS*)

BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"

LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"

;;

IRIX/5*) LDSHARED="ld -shared";;

IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;

SunOS/4*) LDSHARED="ld";;

SunOS/5*)

if test "$GCC" = "yes"

then LDSHARED='$(CC) -shared'

else LDSHARED='$(CC) -G';

fi ;;

hp*|HP*) LDSHARED="ld -b";;

OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;

DYNIX/ptx*) LDSHARED="ld -G";;

Darwin/1.3*)

LDSHARED='$(CC) $(LDFLAGS) -bundle'

if test "$enable_framework" ; then

# Link against the framework. All externals should be defined.

LDSHARED="$LDSHARED "'-framework $(PYTHONFRAMEWORK)'

else

# No framework. Ignore undefined symbols, assuming they come from Python

LDSHARED="$LDSHARED -undefined suppress"

fi ;;

Darwin/*)

LDSHARED='$(CC) $(LDFLAGS) -bundle'