Context Navigation

configure.in

Visit:

Last change on this file was 3225, checked in by bird, 18 years ago
Python 2.5
File size: 94.1 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format