Context Navigation

configure.ac@ 1150

Last change on this file since 1150 was 1150, checked in by dmik, 8 years ago
python: Remove excessive LDFLAGS reference on OS/2.
Property svn:eol-style set to `native`
File size: 131.1 KB

Rev	Line
[388]	1	dnl ***********************************************
	2	dnl * Please run autoreconf to test your changes! *
	3	dnl ***********************************************
	4
	5	# Set VERSION so we only need to edit in one place (i.e., here)
	6	m4_define(PYTHON_VERSION, 2.7)
	7
	8	AC_PREREQ(2.65)
	9
	10	AC_REVISION($Revision$)
	11	AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/)
	12	AC_CONFIG_SRCDIR([Include/object.h])
	13	AC_CONFIG_HEADER(pyconfig.h)
	14
	15	AC_CANONICAL_HOST
	16	AC_SUBST(build)
	17	AC_SUBST(host)
	18
	19	if test "$cross_compiling" = yes; then
	20	AC_MSG_CHECKING([for python interpreter for cross build])
	21	if test -z "$PYTHON_FOR_BUILD"; then
	22	for interp in python$PACKAGE_VERSION python2 python; do
	23	which $interp >/dev/null 2>&1 \|\| continue
	24	if $interp -c 'import sys;sys.exit(not (sys.version_info@<:@:2@:>@ >= (2,7) and sys.version_info@<:@0@:>@ < 3))'; then
	25	break
	26	fi
	27	interp=
	28	done
	29	if test x$interp = x; then
	30	AC_MSG_ERROR([python$PACKAGE_VERSION interpreter not found])
	31	fi
	32	AC_MSG_RESULT($interp)
	33	PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib:$(srcdir)/Lib/plat-$(MACHDEP) '$interp
	34	fi
	35	elif test "$cross_compiling" = maybe; then
	36	AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH])
	37	else
	38	PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
	39	fi
	40	AC_SUBST(PYTHON_FOR_BUILD)
	41
	42	dnl Ensure that if prefix is specified, it does not end in a slash. If
	43	dnl it does, we get path names containing '//' which is both ugly and
	44	dnl can cause trouble.
	45
	46	dnl Last slash shouldn't be stripped if prefix=/
	47	if test "$prefix" != "/"; then
	48	prefix=`echo "$prefix" \| sed -e 's/\/$//g'`
	49	fi
	50
	51	dnl This is for stuff that absolutely must end up in pyconfig.h.
	52	dnl Please use pyport.h instead, if possible.
	53	AH_TOP([
	54	#ifndef Py_PYCONFIG_H
	55	#define Py_PYCONFIG_H
	56	])
	57	AH_BOTTOM([
	58	/* Define the macros needed if on a UnixWare 7.x system. */
	59	#if defined(__USLC__) && defined(__SCO_VERSION__)
	60	#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
	61	#endif
	62
	63	#endif /Py_PYCONFIG_H/
	64	])
	65
	66	# We don't use PACKAGE_ variables, and they cause conflicts
	67	# with other autoconf-based packages that include Python.h
	68	grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
	69	rm confdefs.h
	70	mv confdefs.h.new confdefs.h
	71
	72	AC_SUBST(VERSION)
	73	VERSION=PYTHON_VERSION
	74
	75	AC_SUBST(SOVERSION)
	76	SOVERSION=1.0
	77
	78	# The later defininition of _XOPEN_SOURCE disables certain features
	79	# on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
	80	AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
	81
	82	# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
	83	# certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
	84	# them.
	85	AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
	86
	87	# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
	88	# certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
	89	# them.
	90	AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
	91
	92	# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
	93	# u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
	94	AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
	95
	96	# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
	97	# certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
	98	# them.
	99	AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
	100
	101
	102	define_xopen_source=yes
	103
	104	# Arguments passed to configure.
	105	AC_SUBST(CONFIG_ARGS)
	106	CONFIG_ARGS="$ac_configure_args"
	107
	108	AC_MSG_CHECKING([for --enable-universalsdk])
	109	AC_ARG_ENABLE(universalsdk,
	110	AS_HELP_STRING([--enable-universalsdk@<:@=SDKDIR@:>@], [Build against Mac OS X 10.4u SDK (ppc/i386)]),
	111	[
	112	case $enableval in
	113	yes)
	114	enableval=/Developer/SDKs/MacOSX10.4u.sdk
	115	if test ! -d "${enableval}"
	116	then
	117	enableval=/
	118	fi
	119	;;
	120	esac
	121	case $enableval in
	122	no)
	123	UNIVERSALSDK=
	124	enable_universalsdk=
	125	;;
	126	*)
	127	UNIVERSALSDK=$enableval
	128	if test ! -d "${UNIVERSALSDK}"
	129	then
	130	AC_MSG_ERROR([--enable-universalsdk specifies non-existing SDK: ${UNIVERSALSDK}])
	131	fi
	132	;;
	133	esac
	134
	135	],[
	136	UNIVERSALSDK=
	137	enable_universalsdk=
	138	])
	139	if test -n "${UNIVERSALSDK}"
	140	then
	141	AC_MSG_RESULT(${UNIVERSALSDK})
	142	else
	143	AC_MSG_RESULT(no)
	144	fi
	145	AC_SUBST(UNIVERSALSDK)
	146
	147	AC_SUBST(ARCH_RUN_32BIT)
	148	ARCH_RUN_32BIT=""
	149
	150	UNIVERSAL_ARCHS="32-bit"
	151	AC_SUBST(LIPO_32BIT_FLAGS)
	152	AC_MSG_CHECKING(for --with-universal-archs)
	153	AC_ARG_WITH(universal-archs,
	154	AS_HELP_STRING([--with-universal-archs=ARCH], [select architectures for universal build ("32-bit", "64-bit", "3-way", "intel" or "all")]),
	155	[
	156	AC_MSG_RESULT($withval)
	157	UNIVERSAL_ARCHS="$withval"
	158	if test "${enable_universalsdk}" ; then
	159	:
	160	else
	161	AC_MSG_ERROR([--with-universal-archs without --enable-universalsdk. See Mac/README])
	162	fi
	163	],
	164	[
	165	AC_MSG_RESULT(32-bit)
	166	])
	167
	168
	169
	170	AC_ARG_WITH(framework-name,
	171	AS_HELP_STRING([--with-framework-name=FRAMEWORK],
	172	[specify an alternate name of the framework built with --enable-framework]),
	173	[
	174	if test "${enable_framework}"; then
	175	:
	176	else
	177	AC_MSG_ERROR([--with-framework-name without --enable-framework. See Mac/README])
	178	fi
	179	PYTHONFRAMEWORK=${withval}
	180	PYTHONFRAMEWORKDIR=${withval}.framework
	181	PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval \| tr '[A-Z]' '[a-z]'`
	182	],[
	183	PYTHONFRAMEWORK=Python
	184	PYTHONFRAMEWORKDIR=Python.framework
	185	PYTHONFRAMEWORKIDENTIFIER=org.python.python
	186	])
	187	dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
	188	AC_ARG_ENABLE(framework,
	189	AS_HELP_STRING([--enable-framework@<:@=INSTALLDIR@:>@], [Build (MacOSX\|Darwin) framework]),
	190	[
	191	case $enableval in
	192	yes)
	193	enableval=/Library/Frameworks
	194	esac
	195	case $enableval in
	196	no)
	197	PYTHONFRAMEWORK=
	198	PYTHONFRAMEWORKDIR=no-framework
	199	PYTHONFRAMEWORKPREFIX=
	200	PYTHONFRAMEWORKINSTALLDIR=
	201	FRAMEWORKINSTALLFIRST=
	202	FRAMEWORKINSTALLLAST=
	203	FRAMEWORKALTINSTALLFIRST=
	204	FRAMEWORKALTINSTALLLAST=
	205	if test "x${prefix}" = "xNONE"; then
	206	FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
	207	else
	208	FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
	209	fi
	210	enable_framework=
	211	;;
	212	*)
	213	PYTHONFRAMEWORKPREFIX="${enableval}"
	214	PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
	215	FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
	216	FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
	217	FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
	218	FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
	219	FRAMEWORKINSTALLAPPSPREFIX="/Applications"
	220
	221	if test "x${prefix}" = "xNONE" ; then
	222	FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
	223
	224	else
	225	FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
	226	fi
	227
	228	case "${enableval}" in
	229	/System*)
	230	FRAMEWORKINSTALLAPPSPREFIX="/Applications"
	231	if test "${prefix}" = "NONE" ; then
	232	# See below
	233	FRAMEWORKUNIXTOOLSPREFIX="/usr"
	234	fi
	235	;;
	236
	237	/Library*)
	238	FRAMEWORKINSTALLAPPSPREFIX="/Applications"
	239	;;
	240
	241	*/Library/Frameworks)
	242	MDIR="`dirname "${enableval}"`"
	243	MDIR="`dirname "${MDIR}"`"
	244	FRAMEWORKINSTALLAPPSPREFIX="${MDIR}/Applications"
	245
	246	if test "${prefix}" = "NONE"; then
	247	# User hasn't specified the
	248	# --prefix option, but wants to install
	249	# the framework in a non-default location,
	250	# ensure that the compatibility links get
	251	# installed relative to that prefix as well
	252	# instead of in /usr/local.
	253	FRAMEWORKUNIXTOOLSPREFIX="${MDIR}"
	254	fi
	255	;;
	256
	257	*)
	258	FRAMEWORKINSTALLAPPSPREFIX="/Applications"
	259	;;
	260	esac
	261
	262	prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
	263
	264	# Add files for Mac specific code to the list of output
	265	# files:
	266	AC_CONFIG_FILES(Mac/Makefile)
	267	AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
	268	AC_CONFIG_FILES(Mac/IDLE/Makefile)
	269	AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
	270	AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
	271	esac
	272	],[
	273	PYTHONFRAMEWORK=
	274	PYTHONFRAMEWORKDIR=no-framework
	275	PYTHONFRAMEWORKPREFIX=
	276	PYTHONFRAMEWORKINSTALLDIR=
	277	FRAMEWORKINSTALLFIRST=
	278	FRAMEWORKINSTALLLAST=
	279	FRAMEWORKALTINSTALLFIRST=
	280	FRAMEWORKALTINSTALLLAST=
	281	if test "x${prefix}" = "xNONE" ; then
	282	FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
	283	else
	284	FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
	285	fi
	286	enable_framework=
	287
	288	])
	289	AC_SUBST(PYTHONFRAMEWORK)
	290	AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
	291	AC_SUBST(PYTHONFRAMEWORKDIR)
	292	AC_SUBST(PYTHONFRAMEWORKPREFIX)
	293	AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
	294	AC_SUBST(FRAMEWORKINSTALLFIRST)
	295	AC_SUBST(FRAMEWORKINSTALLLAST)
	296	AC_SUBST(FRAMEWORKALTINSTALLFIRST)
	297	AC_SUBST(FRAMEWORKALTINSTALLLAST)
	298	AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
	299	AC_SUBST(FRAMEWORKINSTALLAPPSPREFIX)
	300
	301	##AC_ARG_WITH(dyld,
	302	## AS_HELP_STRING([--with-dyld],
	303	## [Use (OpenStep\|Rhapsody) dynamic linker]))
	304	##
	305	# Set name for machine-dependent library files
	306	AC_SUBST(MACHDEP)
	307	AC_MSG_CHECKING(MACHDEP)
	308	if test -z "$MACHDEP"
	309	then
	310	# avoid using uname for cross builds
	311	if test "$cross_compiling" = yes; then
	312	# ac_sys_system and ac_sys_release are only used for setting
	313	# `define_xopen_source' in the case statement below. For the
	314	# current supported cross builds, this macro is not adjusted.
	315	case "$host" in
	316	--linux*)
	317	ac_sys_system=Linux
	318	;;
	319	--cygwin*)
	320	ac_sys_system=Cygwin
	321	;;
	322	*)
	323	# for now, limit cross builds to known configurations
	324	MACHDEP="unknown"
	325	AC_MSG_ERROR([cross build not supported for $host])
	326	esac
	327	ac_sys_release=
	328	else
	329	ac_sys_system=`uname -s`
	330	if test "$ac_sys_system" = "AIX" \
	331	-o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
	332	ac_sys_release=`uname -v`
	333	else
	334	ac_sys_release=`uname -r`
	335	fi
	336	fi
	337	ac_md_system=`echo $ac_sys_system \|
	338	tr -d '[/ ]' \| tr '[[A-Z]]' '[[a-z]]'`
	339	ac_md_release=`echo $ac_sys_release \|
	340	tr -d '[/ ]' \| sed 's/^[[A-Z]]\.//' \| sed 's/\..*//'`
	341	MACHDEP="$ac_md_system$ac_md_release"
	342
	343	case $MACHDEP in
	344	linux*) MACHDEP="linux2";;
	345	cygwin*) MACHDEP="cygwin";;
	346	darwin*) MACHDEP="darwin";;
	347	atheos*) MACHDEP="atheos";;
	348	irix646) MACHDEP="irix6";;
[400]	349	os2\|OS/2\|emx*) MACHDEP="os2knix";;
[388]	350	'') MACHDEP="unknown";;
	351	esac
	352	fi
	353
	354	AC_SUBST(_PYTHON_HOST_PLATFORM)
	355	if test "$cross_compiling" = yes; then
	356	case "$host" in
	357	--linux*)
	358	case "$host_cpu" in
	359	arm*)
	360	_host_cpu=arm
	361	;;
	362	*)
	363	_host_cpu=$host_cpu
	364	esac
	365	;;
	366	--cygwin*)
	367	_host_cpu=
	368	;;
	369	*)
	370	# for now, limit cross builds to known configurations
	371	MACHDEP="unknown"
	372	AC_MSG_ERROR([cross build not supported for $host])
	373	esac
	374	_PYTHON_HOST_PLATFORM="$MACHDEP${_host_cpu:+-$_host_cpu}"
	375	fi
	376
	377	# Some systems cannot stand _XOPEN_SOURCE being defined at all; they
	378	# disable features if it is defined, without any means to access these
	379	# features as extensions. For these systems, we skip the definition of
	380	# _XOPEN_SOURCE. Before adding a system to the list to gain access to
	381	# some feature, make sure there is no alternative way to access this
	382	# feature. Also, when using wildcards, make sure you have verified the
	383	# need for not defining _XOPEN_SOURCE on all systems matching the
	384	# wildcard, and that the wildcard does not include future systems
	385	# (which may remove their limitations).
	386	dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
	387	case $ac_sys_system/$ac_sys_release in
	388	# On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
	389	# even though select is a POSIX function. Reported by J. Ribbens.
	390	# Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
	391	# In addition, Stefan Krah confirms that issue #1244610 exists through
	392	# OpenBSD 4.6, but is fixed in 4.7.
	393	OpenBSD/2.* \| OpenBSD/3.* \| OpenBSD/4.@<:@0123456@:>@)
	394	define_xopen_source=no
	395	# OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
	396	# also defined. This can be overridden by defining _BSD_SOURCE
	397	# As this has a different meaning on Linux, only define it on OpenBSD
	398	AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
	399	;;
	400	OpenBSD/*)
	401	# OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
	402	# also defined. This can be overridden by defining _BSD_SOURCE
	403	# As this has a different meaning on Linux, only define it on OpenBSD
	404	AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
	405	;;
	406	# Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
	407	# _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
	408	# Marc Recht
	409	NetBSD/1.5 \| NetBSD/1.5.* \| NetBSD/1.6 \| NetBSD/1.6.* \| NetBSD/1.6@<:@A-S@:>@)
	410	define_xopen_source=no;;
	411	# From the perspective of Solaris, _XOPEN_SOURCE is not so much a
	412	# request to enable features supported by the standard as a request
	413	# to disable features not supported by the standard. The best way
	414	# for Python to use Solaris is simply to leave _XOPEN_SOURCE out
	415	# entirely and define __EXTENSIONS__ instead.
	416	SunOS/*)
	417	define_xopen_source=no;;
	418	# On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
	419	# but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
	420	# Reconfirmed for 7.1.4 by Martin v. Loewis.
	421	OpenUNIX/8.0.0\| UnixWare/7.1.@<:@0-4@:>@)
	422	define_xopen_source=no;;
	423	# On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
	424	# but used in struct sockaddr.sa_family. Reported by Tim Rice.
	425	SCO_SV/3.2)
	426	define_xopen_source=no;;
	427	# On FreeBSD 4, the math functions C89 does not cover are never defined
	428	# with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
	429	FreeBSD/4.*)
	430	define_xopen_source=no;;
	431	# On MacOS X 10.2, a bug in ncurses.h means that it craps out if
	432	# _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
	433	# identifies itself as Darwin/7.*
	434	# On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
	435	# disables platform specific features beyond repair.
	436	# On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
	437	# has no effect, don't bother defining them
	438	Darwin/@<:@6789@:>@.*)
	439	define_xopen_source=no;;
	440	Darwin/1@<:@0-9@:>@.*)
	441	define_xopen_source=no;;
	442	# On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
	443	# used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
	444	# or has another value. By not (re)defining it, the defaults come in place.
	445	AIX/4)
	446	define_xopen_source=no;;
	447	AIX/5)
	448	if test `uname -r` -eq 1; then
	449	define_xopen_source=no
	450	fi
	451	;;
	452	# On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
	453	# defining NI_NUMERICHOST.
	454	QNX/6.3.2)
	455	define_xopen_source=no
	456	;;
	457
	458	esac
	459
	460	if test $define_xopen_source = yes
	461	then
	462	AC_DEFINE(_XOPEN_SOURCE, 600,
	463	Define to the level of X/Open that your system supports)
	464
	465	# On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
	466	# definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
	467	# several APIs are not declared. Since this is also needed in some
	468	# cases for HP-UX, we define it globally.
	469	AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
	470	Define to activate Unix95-and-earlier features)
	471
	472	AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
	473
	474	fi
	475
	476	#
	477	# SGI compilers allow the specification of the both the ABI and the
	478	# ISA on the command line. Depending on the values of these switches,
	479	# different and often incompatable code will be generated.
	480	#
	481	# The SGI_ABI variable can be used to modify the CC and LDFLAGS and
	482	# thus supply support for various ABI/ISA combinations. The MACHDEP
	483	# variable is also adjusted.
	484	#
	485	AC_SUBST(SGI_ABI)
	486	if test ! -z "$SGI_ABI"
	487	then
	488	CC="cc $SGI_ABI"
	489	LDFLAGS="$SGI_ABI $LDFLAGS"
	490	MACHDEP=`echo "${MACHDEP}${SGI_ABI}" \| sed 's/ *//g'`
	491	fi
	492	AC_MSG_RESULT($MACHDEP)
	493
	494	# And add extra plat-mac for darwin
	495	AC_SUBST(EXTRAPLATDIR)
	496	AC_SUBST(EXTRAMACHDEPPATH)
	497	AC_MSG_CHECKING(EXTRAPLATDIR)
	498	if test -z "$EXTRAPLATDIR"
	499	then
	500	case $MACHDEP in
	501	darwin)
	502	EXTRAPLATDIR="\$(PLATMACDIRS)"
	503	EXTRAMACHDEPPATH="\$(PLATMACPATH)"
	504	;;
	505	*)
	506	EXTRAPLATDIR=""
	507	EXTRAMACHDEPPATH=""
	508	;;
	509	esac
	510	fi
	511	AC_MSG_RESULT($EXTRAPLATDIR)
	512
	513	# Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
	514	# it may influence the way we can build extensions, so distutils
	515	# needs to check it
	516	AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
	517	AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
	518	CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
	519	EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
	520
	521	# checks for alternative programs
	522
	523	# compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
	524	# for debug/optimization stuff. BASECFLAGS is for flags that are required
	525	# just to get things to compile and link. Users are free to override OPT
	526	# when running configure or make. The build should not break if they do.
	527	# BASECFLAGS should generally not be messed with, however.
	528
	529	# XXX shouldn't some/most/all of this code be merged with the stuff later
	530	# on that fiddles with OPT and BASECFLAGS?
	531	AC_MSG_CHECKING(for --without-gcc)
	532	AC_ARG_WITH(gcc,
	533	AS_HELP_STRING([--without-gcc], [never use gcc]),
	534	[
	535	case $withval in
	536	no) CC=${CC:-cc}
	537	without_gcc=yes;;
	538	yes) CC=gcc
	539	without_gcc=no;;
	540	*) CC=$withval
	541	without_gcc=$withval;;
	542	esac], [
	543	case $ac_sys_system in
	544	AIX*) CC=${CC:-xlc_r}
	545	without_gcc=;;
	546	BeOS*)
	547	case $BE_HOST_CPU in
	548	ppc)
	549	CC=mwcc
	550	without_gcc=yes
	551	BASECFLAGS="$BASECFLAGS -export pragma"
	552	OPT="$OPT -O"
	553	LDFLAGS="$LDFLAGS -nodup"
	554	;;
	555	x86)
	556	CC=gcc
	557	without_gcc=no
	558	OPT="$OPT -O"
	559	;;
	560	*)
	561	AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
	562	;;
	563	esac
	564	AR="\$(srcdir)/Modules/ar_beos"
	565	RANLIB=:
	566	;;
	567	*) without_gcc=no;;
	568	esac])
	569	AC_MSG_RESULT($without_gcc)
	570
	571	# If the user switches compilers, we can't believe the cache
	572	if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
	573	then
	574	AC_MSG_ERROR([cached CC is different -- throw away $cache_file
	575	(it is also a good idea to do 'make clean' before compiling)])
	576	fi
	577
	578	if test "$MACHDEP" = "irix6" && test "$CC" != "gcc"; then
	579	# Normally, MIPSpro CC treats #error directives as warnings, which means
	580	# a successful exit code is returned (0). This is a problem because IRIX
	581	# has a bunch of system headers with this guard at the top:
	582	#
	583	# #ifndef __c99
	584	# #error This header file is to be used only for c99 mode compilations
	585	# #else
	586	#
	587	# When autoconf tests for such a header, like stdint.h, this happens:
	588	#
	589	# configure:4619: cc -c conftest.c >&5
	590	# cc-1035 cc: WARNING File = /usr/include/stdint.h, Line = 5
	591	# #error directive: This header file is to be used only for c99 mode
	592	# compilations
	593	#
	594	# #error This header file is to be used only for c99 mode compilations
	595	# ^
	596	#
	597	# configure:4619: $? = 0
	598	# configure:4619: result: yes
	599	#
	600	# Therefore, we use `-diag_error 1035` to have the compiler treat the
	601	# warning as an error, which causes cc to return a non-zero result,
	602	# which autoconf can interpret correctly.
	603	CFLAGS="$CFLAGS -diag_error 1035"
	604	# Whilst we're here, we might as well make sure CXX defaults to something
	605	# sensible if we're not using gcc.
	606	if test -z "$CXX"; then
	607	CXX="CC"
	608	fi
	609	fi
	610
	611	# If the user set CFLAGS, use this instead of the automatically
	612	# determined setting
	613	preset_cflags="$CFLAGS"
	614	AC_PROG_CC
	615	if test ! -z "$preset_cflags"
	616	then
	617	CFLAGS=$preset_cflags
	618	fi
	619
	620	AC_SUBST(CXX)
	621	AC_SUBST(MAINCC)
	622	AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
	623	AC_ARG_WITH(cxx_main,
	624	AS_HELP_STRING([--with-cxx-main=<compiler>],
	625	[compile main() and link python executable with C++ compiler]),
	626	[
	627
	628	case $withval in
	629	no) with_cxx_main=no
	630	MAINCC='$(CC)';;
	631	yes) with_cxx_main=yes
	632	MAINCC='$(CXX)';;
	633	*) with_cxx_main=yes
	634	MAINCC=$withval
	635	if test -z "$CXX"
	636	then
	637	CXX=$withval
	638	fi;;
	639	esac], [
	640	with_cxx_main=no
	641	MAINCC='$(CC)'
	642	])
	643	AC_MSG_RESULT($with_cxx_main)
	644
	645	preset_cxx="$CXX"
	646	if test -z "$CXX"
	647	then
	648	case "$CC" in
	649	gcc) AC_PATH_TOOL(CXX, [g++], [g++], [notfound]) ;;
	650	cc) AC_PATH_TOOL(CXX, [c++], [c++], [notfound]) ;;
	651	esac
	652	if test "$CXX" = "notfound"
	653	then
	654	CXX=""
	655	fi
	656	fi
	657	if test -z "$CXX"
	658	then
	659	AC_CHECK_TOOLS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
	660	if test "$CXX" = "notfound"
	661	then
	662	CXX=""
	663	fi
	664	fi
	665	if test "$preset_cxx" != "$CXX"
	666	then
	667	AC_MSG_WARN([
	668
	669	By default, distutils will build C++ extension modules with "$CXX".
	670	If this is not intended, then set CXX on the configure command line.
	671	])
	672	fi
	673
	674	MULTIARCH=$($CC --print-multiarch 2>/dev/null)
	675	AC_SUBST(MULTIARCH)
	676
	677
	678	# checks for UNIX variants that set C preprocessor variables
	679	AC_USE_SYSTEM_EXTENSIONS
	680
	681	# Check for unsupported systems
	682	case $ac_sys_system/$ac_sys_release in
	683	atheos\|Linux/1*)
	684	echo This system $$ac_sys_system/$ac_sys_release$ is no longer supported.
	685	echo See README for details.
	686	exit 1;;
	687	esac
	688
	689	AC_EXEEXT
	690	AC_MSG_CHECKING(for --with-suffix)
	691	AC_ARG_WITH(suffix,
	692	AS_HELP_STRING([--with-suffix=.exe], [set executable suffix]),
	693	[
	694	case $withval in
	695	no) EXEEXT=;;
	696	yes) EXEEXT=.exe;;
	697	*) EXEEXT=$withval;;
	698	esac])
	699	AC_MSG_RESULT($EXEEXT)
	700
	701	# Test whether we're running on a non-case-sensitive system, in which
	702	# case we give a warning if no ext is given
	703	AC_SUBST(BUILDEXEEXT)
	704	AC_MSG_CHECKING(for case-insensitive build directory)
	705	if test ! -d CaseSensitiveTestDir; then
	706	mkdir CaseSensitiveTestDir
	707	fi
	708
	709	if test -d casesensitivetestdir
	710	then
	711	AC_MSG_RESULT(yes)
	712	BUILDEXEEXT=.exe
	713	else
	714	AC_MSG_RESULT(no)
	715	BUILDEXEEXT=$EXEEXT
	716	fi
	717	rmdir CaseSensitiveTestDir
	718
	719	case $MACHDEP in
	720	bsdos*)
	721	case $CC in
	722	gcc) CC="$CC -D_HAVE_BSDI";;
	723	esac;;
	724	esac
	725
	726	case $ac_sys_system in
	727	hp\|HP)
	728	case $CC in
	729	cc\|*/cc) CC="$CC -Ae";;
	730	esac;;
	731	SunOS*)
	732	# Some functions have a prototype only with that define, e.g. confstr
	733	AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
	734	;;
	735	esac
	736
	737
	738	AC_SUBST(LIBRARY)
	739	AC_MSG_CHECKING(LIBRARY)
	740	if test -z "$LIBRARY"
	741	then
	742	LIBRARY='libpython$(VERSION).a'
	743	fi
	744	AC_MSG_RESULT($LIBRARY)
	745
	746	# LDLIBRARY is the name of the library to link against (as opposed to the
	747	# name of the library into which to insert object files). BLDLIBRARY is also
	748	# the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
	749	# is blank as the main program is not linked directly against LDLIBRARY.
	750	# LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
	751	# systems without shared libraries, LDLIBRARY is the same as LIBRARY
[400]	752	# (defined in the Makefiles). On Cygwin and OS/2 LDLIBRARY is the import
	753	# library, DLLLIBRARY is the shared (i.e., DLL) library.
	754	#
[388]	755	# RUNSHARED is used to run shared python without installed libraries
	756	#
	757	# INSTSONAME is the name of the shared library that will be use to install
	758	# on the system - some systems like version suffix, others don't
	759	AC_SUBST(LDLIBRARY)
	760	AC_SUBST(DLLLIBRARY)
	761	AC_SUBST(BLDLIBRARY)
	762	AC_SUBST(LDLIBRARYDIR)
	763	AC_SUBST(INSTSONAME)
	764	AC_SUBST(RUNSHARED)
[400]	765	AC_SUBST(CONDENSED_VERSION)
[388]	766	LDLIBRARY="$LIBRARY"
	767	BLDLIBRARY='$(LDLIBRARY)'
	768	INSTSONAME='$(LDLIBRARY)'
	769	DLLLIBRARY=''
	770	LDLIBRARYDIR=''
	771	RUNSHARED=''
[400]	772	CONDENSED_VERSION=''
[388]	773
	774	# LINKCC is the command that links the python executable -- default is $(CC).
	775	# If CXX is set, and if it is needed to link a main function that was
	776	# compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
	777	# python might then depend on the C++ runtime
	778	# This is altered for AIX in order to build the export list before
	779	# linking.
	780	AC_SUBST(LINKCC)
	781	AC_MSG_CHECKING(LINKCC)
	782	if test -z "$LINKCC"
	783	then
	784	LINKCC='$(PURIFY) $(MAINCC)'
	785	case $ac_sys_system in
	786	AIX*)
	787	exp_extra="\"\""
	788	if test $ac_sys_release -ge 5 -o \
	789	$ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
	790	exp_extra="."
	791	fi
	792	LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
	793	QNX*)
	794	# qcc must be used because the other compilers do not
	795	# support -N.
	796	LINKCC=qcc;;
	797	esac
	798	fi
	799	AC_MSG_RESULT($LINKCC)
	800
	801	# GNULD is set to "yes" if the GNU linker is used. If this goes wrong
	802	# make sure we default having it set to "no": this is used by
	803	# distutils.unixccompiler to know if it should add --enable-new-dtags
	804	# to linker command lines, and failing to detect GNU ld simply results
	805	# in the same bahaviour as before.
	806	AC_SUBST(GNULD)
	807	AC_MSG_CHECKING(for GNU ld)
	808	ac_prog=ld
	809	if test "$GCC" = yes; then
	810	ac_prog=`$CC -print-prog-name=ld`
	811	fi
	812	case `"$ac_prog" -V 2>&1 < /dev/null` in
	813	GNU)
	814	GNULD=yes;;
	815	*)
	816	GNULD=no;;
	817	esac
	818	AC_MSG_RESULT($GNULD)
	819
	820	AC_MSG_CHECKING(for --enable-shared)
	821	AC_ARG_ENABLE(shared,
	822	AS_HELP_STRING([--enable-shared], [disable/enable building shared python library]))
	823
	824	if test -z "$enable_shared"
	825	then
	826	case $ac_sys_system in
[400]	827	CYGWIN* \| atheos* \| OS/2 \| emx \| os2)
[388]	828	enable_shared="yes";;
	829	*)
	830	enable_shared="no";;
	831	esac
	832	fi
	833	AC_MSG_RESULT($enable_shared)
	834
	835	AC_MSG_CHECKING(for --enable-profiling)
	836	AC_ARG_ENABLE(profiling,
	837	AS_HELP_STRING([--enable-profiling], [enable C-level code profiling]))
	838	if test "x$enable_profiling" = xyes; then
	839	ac_save_cc="$CC"
	840	CC="$CC -pg"
	841	AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],
	842	[],
	843	[enable_profiling=no])
	844	CC="$ac_save_cc"
	845	else
	846	enable_profiling=no
	847	fi
	848	AC_MSG_RESULT($enable_profiling)
	849
	850	if test "x$enable_profiling" = xyes; then
	851	BASECFLAGS="-pg $BASECFLAGS"
	852	LDFLAGS="-pg $LDFLAGS"
	853	fi
	854
	855	AC_MSG_CHECKING(LDLIBRARY)
	856
	857	# MacOSX framework builds need more magic. LDLIBRARY is the dynamic
	858	# library that we build, but we do not want to link against it (we
	859	# will find it with a -framework option). For this reason there is an
	860	# extra variable BLDLIBRARY against which Python and the extension
	861	# modules are linked, BLDLIBRARY. This is normally the same as
	862	# LDLIBRARY, but empty for MacOSX framework builds.
	863	if test "$enable_framework"
	864	then
	865	LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	866	RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
	867	BLDLIBRARY=''
	868	else
	869	BLDLIBRARY='$(LDLIBRARY)'
	870	fi
	871
	872	# Other platforms follow
	873	if test $enable_shared = "yes"; then
	874	AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
	875	case $ac_sys_system in
	876	BeOS*)
	877	LDLIBRARY='libpython$(VERSION).so'
	878	;;
	879	CYGWIN*)
	880	LDLIBRARY='libpython$(VERSION).dll.a'
	881	DLLLIBRARY='libpython$(VERSION).dll'
	882	;;
	883	SunOS*)
	884	LDLIBRARY='libpython$(VERSION).so'
	885	BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
	886	RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
	887	INSTSONAME="$LDLIBRARY".$SOVERSION
	888	;;
	889	Linux\|GNU\|NetBSD\|FreeBSD\|DragonFly\|OpenBSD)
	890	LDLIBRARY='libpython$(VERSION).so'
	891	BLDLIBRARY='-L. -lpython$(VERSION)'
	892	RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
	893	case $ac_sys_system in
	894	FreeBSD*)
	895	SOVERSION=`echo $SOVERSION\|cut -d "." -f 1`
	896	;;
	897	esac
	898	INSTSONAME="$LDLIBRARY".$SOVERSION
	899	;;
	900	hp\|HP)
	901	case `uname -m` in
	902	ia64)
	903	LDLIBRARY='libpython$(VERSION).so'
	904	;;
	905	*)
	906	LDLIBRARY='libpython$(VERSION).sl'
	907	;;
	908	esac
	909	BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
	910	RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
	911	;;
	912	OSF*)
	913	LDLIBRARY='libpython$(VERSION).so'
	914	BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
	915	RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
	916	;;
	917	atheos*)
	918	LDLIBRARY='libpython$(VERSION).so'
	919	BLDLIBRARY='-L. -lpython$(VERSION)'
	920	RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
	921	;;
	922	Darwin*)
	923	LDLIBRARY='libpython$(VERSION).dylib'
	924	BLDLIBRARY='-L. -lpython$(VERSION)'
	925	RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
	926	;;
	927	AIX*)
	928	LDLIBRARY='libpython$(VERSION).so'
	929	RUNSHARED=LIBPATH=`pwd`:${LIBPATH}
	930	;;
[400]	931	OS/2\|os2\|emx)
	932	LDLIBRARY='python$(VERSION)_dll.a'
	933	BLDLIBRARY='-L. -lpython$(VERSION)'
	934	RUNSHARED=BEGINLIBPATH="'`pwd`;$BEGINLIBPATH'"
[1117]	935	CONDENSED_VERSION=`echo "${VERSION}" \| tr -d .,`
[400]	936	DLLLIBRARY='python$(CONDENSED_VERSION).dll'
	937	;;
[388]	938
	939	esac
	940	else # shared is disabled
	941	case $ac_sys_system in
	942	CYGWIN*)
	943	BLDLIBRARY='$(LIBRARY)'
	944	LDLIBRARY='libpython$(VERSION).dll.a'
	945	;;
	946	esac
	947	fi
	948
	949	if test "$cross_compiling" = yes; then
	950	RUNSHARED=
	951	fi
	952
	953	AC_MSG_RESULT($LDLIBRARY)
	954
	955	AC_PROG_RANLIB
	956	AC_SUBST(AR)
	957	AC_CHECK_TOOLS(AR, ar aal, ar)
	958
	959	# tweak ARFLAGS only if the user didn't set it on the command line
	960	AC_SUBST(ARFLAGS)
	961	if test -z "$ARFLAGS"
	962	then
	963	ARFLAGS="rc"
	964	fi
	965
	966	AC_SUBST(SVNVERSION)
	967	AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
	968	if test $SVNVERSION = found
	969	then
	970	SVNVERSION="svnversion \$(srcdir)"
	971	else
	972	SVNVERSION="echo Unversioned directory"
	973	fi
	974
	975	AC_SUBST(BASECPPFLAGS)
	976	if test "$abs_srcdir" != "$abs_builddir"; then
	977	# If we're building out-of-tree make sure Include (in the current dir)
	978	# gets picked up before its $srcdir counterpart in order for Python-ast.h
	979	# and graminit.h to get picked up from the correct directory.
	980	# (A side effect of this is that these resources will automatically be
	981	# regenerated when building out-of-tree, regardless of whether or not
	982	# the $srcdir counterpart is up-to-date. This is an acceptable trade
	983	# off.)
	984	BASECPPFLAGS="-IInclude"
	985	else
	986	BASECPPFLAGS=""
	987	fi
	988
	989	AC_SUBST(HGVERSION)
	990	AC_SUBST(HGTAG)
	991	AC_SUBST(HGBRANCH)
	992	AC_CHECK_PROG(HAS_HG, hg, found, not-found)
	993	if test $HAS_HG = found
	994	then
	995	HGVERSION="hg id -i \$(srcdir)"
	996	HGTAG="hg id -t \$(srcdir)"
	997	HGBRANCH="hg id -b \$(srcdir)"
	998	else
	999	HGVERSION=""
	1000	HGTAG=""
	1001	HGBRANCH=""
	1002	fi
	1003
	1004	case $MACHDEP in
	1005	bsdos\|hp\|HP*)
	1006	# install -d does not work on BSDI or HP-UX
	1007	if test -z "$INSTALL"
	1008	then
	1009	INSTALL="${srcdir}/install-sh -c"
	1010	fi
	1011	esac
	1012	AC_PROG_INSTALL
	1013	AC_PROG_MKDIR_P
	1014
	1015	# Not every filesystem supports hard links
	1016	AC_SUBST(LN)
	1017	if test -z "$LN" ; then
	1018	case $ac_sys_system in
	1019	BeOS*) LN="ln -s";;
	1020	CYGWIN*) LN="ln -s";;
[400]	1021	OS/2\|os2\|emx) LN="ln -s";;
[388]	1022	atheos*) LN="ln -s";;
	1023	*) LN=ln;;
	1024	esac
	1025	fi
	1026
	1027	# Check for --with-pydebug
	1028	AC_MSG_CHECKING(for --with-pydebug)
	1029	AC_ARG_WITH(pydebug,
	1030	AS_HELP_STRING([--with-pydebug], [build with Py_DEBUG defined]),
	1031	[
	1032	if test "$withval" != no
	1033	then
	1034	AC_DEFINE(Py_DEBUG, 1,
	1035	[Define if you want to build an interpreter with many run-time checks.])
	1036	AC_MSG_RESULT(yes);
	1037	Py_DEBUG='true'
	1038	else AC_MSG_RESULT(no); Py_DEBUG='false'
	1039	fi],
	1040	[AC_MSG_RESULT(no)])
	1041
	1042	# XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
	1043	# merged with this chunk of code?
	1044
	1045	# Optimizer/debugger flags
	1046	# ------------------------
	1047	# (The following bit of code is complicated enough - please keep things
	1048	# indented properly. Just pretend you're editing Python code. ;-)
	1049
	1050	# There are two parallel sets of case statements below, one that checks to
	1051	# see if OPT was set and one that does BASECFLAGS setting based upon
	1052	# compiler and platform. BASECFLAGS tweaks need to be made even if the
	1053	# user set OPT.
	1054
	1055	# tweak OPT based on compiler and platform, only if the user didn't set
	1056	# it on the command line
	1057	AC_SUBST(OPT)
	1058	if test "${OPT-unset}" = "unset"
	1059	then
	1060	case $GCC in
	1061	yes)
	1062	if test "$CC" != 'g++' ; then
	1063	STRICT_PROTO="-Wstrict-prototypes"
	1064	fi
	1065	# For gcc 4.x we need to use -fwrapv so lets check if its supported
	1066	if "$CC" -v --help 2>/dev/null \|grep -- -fwrapv > /dev/null; then
	1067	WRAP="-fwrapv"
	1068	fi
	1069
	1070	# Clang also needs -fwrapv
	1071	case $CC in
	1072	clang) WRAP="-fwrapv"
	1073	;;
	1074	esac
	1075
	1076	case $ac_cv_prog_cc_g in
	1077	yes)
	1078	if test "$Py_DEBUG" = 'true' ; then
	1079	# Optimization messes up debuggers, so turn it off for
	1080	# debug builds.
	1081	OPT="-g -O0 -Wall $STRICT_PROTO"
	1082	else
[560]	1083	OPT="-g $WRAP -O2 -Wall $STRICT_PROTO"
[388]	1084	fi
	1085	;;
	1086	*)
[560]	1087	OPT="-O2 -Wall $STRICT_PROTO"
[388]	1088	;;
	1089	esac
	1090	case $ac_sys_system in
	1091	SCO_SV*) OPT="$OPT -m486 -DSCO5"
	1092	;;
	1093	esac
	1094	;;
	1095
	1096	*)
	1097	OPT="-O"
	1098	;;
	1099	esac
	1100	fi
	1101
	1102	AC_SUBST(BASECFLAGS)
	1103
	1104	# The -arch flags for universal builds on OSX
	1105	UNIVERSAL_ARCH_FLAGS=
	1106	AC_SUBST(UNIVERSAL_ARCH_FLAGS)
	1107
	1108	# tweak BASECFLAGS based on compiler and platform
	1109	case $GCC in
	1110	yes)
	1111	# Python violates C99 rules, by casting between incompatible
	1112	# pointer types. GCC may generate bad code as a result of that,
	1113	# so use -fno-strict-aliasing if supported.
	1114	AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
	1115	ac_save_cc="$CC"
	1116	CC="$CC -fno-strict-aliasing"
	1117	AC_CACHE_VAL(ac_cv_no_strict_aliasing_ok,
	1118	AC_COMPILE_IFELSE(
	1119	[AC_LANG_PROGRAM([[]], [[]])],
	1120	[ac_cv_no_strict_aliasing_ok=yes],
	1121	[ac_cv_no_strict_aliasing_ok=no]))
	1122	CC="$ac_save_cc"
	1123	AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
	1124	if test $ac_cv_no_strict_aliasing_ok = yes
	1125	then
	1126	BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
	1127	fi
	1128
	1129	# if using gcc on alpha, use -mieee to get (near) full IEEE 754
	1130	# support. Without this, treatment of subnormals doesn't follow
	1131	# the standard.
	1132	case $host in
	1133	alpha*)
	1134	BASECFLAGS="$BASECFLAGS -mieee"
	1135	;;
	1136	esac
	1137
	1138	case $ac_sys_system in
	1139	SCO_SV*)
	1140	BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
	1141	;;
	1142	# is there any other compiler on Darwin besides gcc?
	1143	Darwin*)
	1144	# -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
	1145	# used to be here, but non-Apple gcc doesn't accept them.
	1146	if test "${CC}" = gcc
	1147	then
	1148	AC_MSG_CHECKING(which compiler should be used)
	1149	case "${UNIVERSALSDK}" in
	1150	*/MacOSX10.4u.sdk)
	1151	# Build using 10.4 SDK, force usage of gcc when the
	1152	# compiler is gcc, otherwise the user will get very
	1153	# confusing error messages when building on OSX 10.6
	1154	CC=gcc-4.0
	1155	CPP=cpp-4.0
	1156	;;
	1157	esac
	1158	AC_MSG_RESULT($CC)
	1159	fi
	1160
	1161	# Calculate the right deployment target for this build.
	1162	#
	1163	cur_target=`sw_vers -productVersion \| sed 's/$10\.[[0-9]]$./\1/'`
	1164	if test ${cur_target} '>' 10.2; then
	1165	cur_target=10.3
	1166	if test ${enable_universalsdk}; then
	1167	if test "${UNIVERSAL_ARCHS}" = "all"; then
	1168	# Ensure that the default platform for a
	1169	# 4-way universal build is OSX 10.5,
	1170	# that's the first OS release where
	1171	# 4-way builds make sense.
	1172	cur_target='10.5'
	1173
	1174	elif test "${UNIVERSAL_ARCHS}" = "3-way"; then
	1175	cur_target='10.5'
	1176
	1177	elif test "${UNIVERSAL_ARCHS}" = "intel"; then
	1178	cur_target='10.5'
	1179
	1180	elif test "${UNIVERSAL_ARCHS}" = "64-bit"; then
	1181	cur_target='10.5'
	1182	fi
	1183	else
	1184	if test `/usr/bin/arch` = "i386"; then
	1185	# On Intel macs default to a deployment
	1186	# target of 10.4, that's the first OSX
	1187	# release with Intel support.
	1188	cur_target="10.4"
	1189	fi
	1190	fi
	1191	fi
	1192	CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
	1193
	1194	# Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
	1195	# environment with a value that is the same as what we'll use
	1196	# in the Makefile to ensure that we'll get the same compiler
	1197	# environment during configure and build time.
	1198	MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
	1199	export MACOSX_DEPLOYMENT_TARGET
	1200	EXPORT_MACOSX_DEPLOYMENT_TARGET=''
	1201
	1202	if test "${enable_universalsdk}"; then
	1203	UNIVERSAL_ARCH_FLAGS=""
	1204	if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
	1205	UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
	1206	ARCH_RUN_32BIT=""
	1207	LIPO_32BIT_FLAGS=""
	1208
	1209	elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
	1210	UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
	1211	LIPO_32BIT_FLAGS=""
	1212	ARCH_RUN_32BIT="true"
	1213
	1214	elif test "$UNIVERSAL_ARCHS" = "all" ; then
	1215	UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
	1216	LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
	1217	ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
	1218
	1219	elif test "$UNIVERSAL_ARCHS" = "intel" ; then
	1220	UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
	1221	LIPO_32BIT_FLAGS="-extract i386"
	1222	ARCH_RUN_32BIT="/usr/bin/arch -i386"
	1223
	1224	elif test "$UNIVERSAL_ARCHS" = "3-way" ; then
	1225	UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
	1226	LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
	1227	ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
	1228
	1229	else
	1230	AC_MSG_ERROR([proper usage is --with-universal-arch=32-bit\|64-bit\|all\|intel\|3-way])
	1231
	1232	fi
	1233
	1234
	1235	CFLAGS="${UNIVERSAL_ARCH_FLAGS} ${CFLAGS}"
	1236	if test "${UNIVERSALSDK}" != "/"
	1237	then
	1238	CPPFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}"
	1239	LDFLAGS="-isysroot ${UNIVERSALSDK} ${LDFLAGS}"
	1240	CFLAGS="-isysroot ${UNIVERSALSDK} ${CFLAGS}"
	1241	fi
	1242
	1243	fi
	1244
	1245
	1246	;;
	1247	OSF*)
	1248	BASECFLAGS="$BASECFLAGS -mieee"
	1249	;;
	1250	esac
	1251	;;
	1252
	1253	*)
	1254	case $ac_sys_system in
	1255	OpenUNIX\|UnixWare)
	1256	BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
	1257	;;
	1258	OSF*)
	1259	BASECFLAGS="$BASECFLAGS -ieee -std"
	1260	;;
	1261	SCO_SV*)
	1262	BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
	1263	;;
	1264	esac
	1265	;;
	1266	esac
	1267
	1268	if test "$Py_DEBUG" = 'true'; then
	1269	:
	1270	else
	1271	OPT="-DNDEBUG $OPT"
	1272	fi
	1273
	1274	if test "$ac_arch_flags"
	1275	then
	1276	BASECFLAGS="$BASECFLAGS $ac_arch_flags"
	1277	fi
	1278
	1279	# disable check for icc since it seems to pass, but generates a warning
	1280	if test "$CC" = icc
	1281	then
	1282	ac_cv_opt_olimit_ok=no
	1283	fi
	1284
	1285	AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
	1286	AC_CACHE_VAL(ac_cv_opt_olimit_ok,
	1287	[ac_save_cc="$CC"
	1288	CC="$CC -OPT:Olimit=0"
	1289	AC_COMPILE_IFELSE(
	1290	[AC_LANG_PROGRAM([[]], [[]])],
	1291	[ac_cv_opt_olimit_ok=yes],
	1292	[ac_cv_opt_olimit_ok=no]
	1293	)
	1294	CC="$ac_save_cc"])
	1295	AC_MSG_RESULT($ac_cv_opt_olimit_ok)
	1296	if test $ac_cv_opt_olimit_ok = yes; then
	1297	case $ac_sys_system in
	1298	# XXX is this branch needed? On MacOSX 10.2.2 the result of the
	1299	# olimit_ok test is "no". Is it "yes" in some other Darwin-esque
	1300	# environment?
	1301	Darwin*)
	1302	;;
	1303	# XXX thankfully this useless troublemaker of a flag has been
	1304	# eradicated in the 3.x line. For now, make sure it isn't picked
	1305	# up by any of our other platforms that use CC.
	1306	AIX\|SunOS\|HP-UX\|IRIX)
	1307	;;
	1308	*)
	1309	BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
	1310	;;
	1311	esac
	1312	else
	1313	AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
	1314	AC_CACHE_VAL(ac_cv_olimit_ok,
	1315	[ac_save_cc="$CC"
	1316	CC="$CC -Olimit 1500"
	1317	AC_COMPILE_IFELSE(
	1318	[AC_LANG_PROGRAM([[]], [[]])],
	1319	[ac_cv_olimit_ok=yes],
	1320	[ac_cv_olimit_ok=no]
	1321	)
	1322	CC="$ac_save_cc"])
	1323	AC_MSG_RESULT($ac_cv_olimit_ok)
	1324	if test $ac_cv_olimit_ok = yes; then
	1325	case $ac_sys_system in
	1326	# Issue #16534: On HP-UX ac_cv_olimit_ok=yes is a false positive.
	1327	HP-UX*)
	1328	;;
	1329	*)
	1330	BASECFLAGS="$BASECFLAGS -Olimit 1500"
	1331	;;
	1332	esac
	1333	fi
	1334	fi
	1335
	1336	# Check whether GCC supports PyArg_ParseTuple format
	1337	if test "$GCC" = "yes"
	1338	then
	1339	AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
	1340	save_CFLAGS=$CFLAGS
	1341	CFLAGS="$CFLAGS -Werror -Wformat"
	1342	AC_COMPILE_IFELSE([
	1343	AC_LANG_PROGRAM([[void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));]], [[]])
	1344	],[
	1345	AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1,
	1346	[Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
	1347	AC_MSG_RESULT(yes)
	1348	],[
	1349	AC_MSG_RESULT(no)
	1350	])
	1351	CFLAGS=$save_CFLAGS
	1352	fi
	1353
	1354	# On some compilers, pthreads are available without further options
	1355	# (e.g. MacOS X). On some of these systems, the compiler will not
	1356	# complain if unaccepted options are passed (e.g. gcc on Mac OS X).
	1357	# So we have to see first whether pthreads are available without
	1358	# options before we can check whether -Kpthread improves anything.
	1359	AC_MSG_CHECKING(whether pthreads are available without options)
	1360	AC_CACHE_VAL(ac_cv_pthread_is_default,
	1361	[AC_RUN_IFELSE([AC_LANG_SOURCE([[
	1362	#include <stdio.h>
	1363	#include <pthread.h>
	1364
	1365	void* routine(void* p){return NULL;}
	1366
	1367	int main(){
	1368	pthread_t p;
	1369	if(pthread_create(&p,NULL,routine,NULL)!=0)
	1370	return 1;
	1371	(void)pthread_detach(p);
	1372	return 0;
	1373	}
	1374	]])],[
	1375	ac_cv_pthread_is_default=yes
	1376	ac_cv_kthread=no
	1377	ac_cv_pthread=no
	1378	],[ac_cv_pthread_is_default=no],[ac_cv_pthread_is_default=no])
	1379	])
	1380	AC_MSG_RESULT($ac_cv_pthread_is_default)
	1381
	1382
	1383	if test $ac_cv_pthread_is_default = yes
	1384	then
	1385	ac_cv_kpthread=no
	1386	else
	1387	# -Kpthread, if available, provides the right #defines
	1388	# and linker options to make pthread_create available
	1389	# Some compilers won't report that they do not support -Kpthread,
	1390	# so we need to run a program to see whether it really made the
	1391	# function available.
	1392	AC_MSG_CHECKING(whether $CC accepts -Kpthread)
	1393	AC_CACHE_VAL(ac_cv_kpthread,
	1394	[ac_save_cc="$CC"
	1395	CC="$CC -Kpthread"
	1396	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	1397	#include <stdio.h>
	1398	#include <pthread.h>
	1399
	1400	void* routine(void* p){return NULL;}
	1401
	1402	int main(){
	1403	pthread_t p;
	1404	if(pthread_create(&p,NULL,routine,NULL)!=0)
	1405	return 1;
	1406	(void)pthread_detach(p);
	1407	return 0;
	1408	}
	1409	]])],[ac_cv_kpthread=yes],[ac_cv_kpthread=no],[ac_cv_kpthread=no])
	1410	CC="$ac_save_cc"])
	1411	AC_MSG_RESULT($ac_cv_kpthread)
	1412	fi
	1413
	1414	if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
	1415	then
	1416	# -Kthread, if available, provides the right #defines
	1417	# and linker options to make pthread_create available
	1418	# Some compilers won't report that they do not support -Kthread,
	1419	# so we need to run a program to see whether it really made the
	1420	# function available.
	1421	AC_MSG_CHECKING(whether $CC accepts -Kthread)
	1422	AC_CACHE_VAL(ac_cv_kthread,
	1423	[ac_save_cc="$CC"
	1424	CC="$CC -Kthread"
	1425	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	1426	#include <stdio.h>
	1427	#include <pthread.h>
	1428
	1429	void* routine(void* p){return NULL;}
	1430
	1431	int main(){
	1432	pthread_t p;
	1433	if(pthread_create(&p,NULL,routine,NULL)!=0)
	1434	return 1;
	1435	(void)pthread_detach(p);
	1436	return 0;
	1437	}
	1438	]])],[ac_cv_kthread=yes],[ac_cv_kthread=no],[ac_cv_kthread=no])
	1439	CC="$ac_save_cc"])
	1440	AC_MSG_RESULT($ac_cv_kthread)
	1441	fi
	1442
	1443	if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
	1444	then
	1445	# -pthread, if available, provides the right #defines
	1446	# and linker options to make pthread_create available
	1447	# Some compilers won't report that they do not support -pthread,
	1448	# so we need to run a program to see whether it really made the
	1449	# function available.
	1450	AC_MSG_CHECKING(whether $CC accepts -pthread)
	1451	AC_CACHE_VAL(ac_cv_pthread,
	1452	[ac_save_cc="$CC"
	1453	CC="$CC -pthread"
	1454	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	1455	#include <stdio.h>
	1456	#include <pthread.h>
	1457
	1458	void* routine(void* p){return NULL;}
	1459
	1460	int main(){
	1461	pthread_t p;
	1462	if(pthread_create(&p,NULL,routine,NULL)!=0)
	1463	return 1;
	1464	(void)pthread_detach(p);
	1465	return 0;
	1466	}
	1467	]])],[ac_cv_pthread=yes],[ac_cv_pthread=no],[ac_cv_pthread=no])
	1468	CC="$ac_save_cc"])
	1469	AC_MSG_RESULT($ac_cv_pthread)
	1470	fi
	1471
	1472	# If we have set a CC compiler flag for thread support then
	1473	# check if it works for CXX, too.
	1474	ac_cv_cxx_thread=no
	1475	if test ! -z "$CXX"
	1476	then
	1477	AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
	1478	ac_save_cxx="$CXX"
	1479
	1480	if test "$ac_cv_kpthread" = "yes"
	1481	then
	1482	CXX="$CXX -Kpthread"
	1483	ac_cv_cxx_thread=yes
	1484	elif test "$ac_cv_kthread" = "yes"
	1485	then
	1486	CXX="$CXX -Kthread"
	1487	ac_cv_cxx_thread=yes
	1488	elif test "$ac_cv_pthread" = "yes"
	1489	then
	1490	CXX="$CXX -pthread"
	1491	ac_cv_cxx_thread=yes
	1492	fi
	1493
	1494	if test $ac_cv_cxx_thread = yes
	1495	then
	1496	echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
	1497	$CXX -c conftest.$ac_ext 2>&5
	1498	if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
	1499	&& test -s conftest$ac_exeext && ./conftest$ac_exeext
	1500	then
	1501	ac_cv_cxx_thread=yes
	1502	else
	1503	ac_cv_cxx_thread=no
	1504	fi
	1505	rm -fr conftest*
	1506	fi
	1507	AC_MSG_RESULT($ac_cv_cxx_thread)
	1508	fi
	1509	CXX="$ac_save_cxx"
	1510
	1511	dnl # check for ANSI or K&R ("traditional") preprocessor
	1512	dnl AC_MSG_CHECKING(for C preprocessor type)
	1513	dnl AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	1514	dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
	1515	dnl int foo;
	1516	dnl struct {char name; int addr; char *doc;} desc = spam(foo, "something");
	1517	dnl ]], [[;]])],[cpp_type=ansi],[AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional])
	1518	dnl AC_MSG_RESULT($cpp_type)
	1519
	1520	# checks for header files
	1521	AC_HEADER_STDC
	1522	AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
	1523	fcntl.h grp.h \
	1524	ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
	1525	shadow.h signal.h stdint.h stropts.h termios.h thread.h \
	1526	unistd.h utime.h \
	1527	sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
	1528	sys/lock.h sys/mkdev.h sys/modem.h \
	1529	sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
	1530	sys/termio.h sys/time.h \
	1531	sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
	1532	sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
	1533	bluetooth/bluetooth.h linux/tipc.h spawn.h util.h alloca.h)
	1534	AC_HEADER_DIRENT
	1535	AC_HEADER_MAJOR
	1536
	1537	# On Solaris, term.h requires curses.h
	1538	AC_CHECK_HEADERS(term.h,,,[
	1539	#ifdef HAVE_CURSES_H
	1540	#include <curses.h>
	1541	#endif
	1542	])
	1543
	1544	# On Linux, netlink.h requires asm/types.h
	1545	AC_CHECK_HEADERS(linux/netlink.h,,,[
	1546	#ifdef HAVE_ASM_TYPES_H
	1547	#include <asm/types.h>
	1548	#endif
	1549	#ifdef HAVE_SYS_SOCKET_H
	1550	#include <sys/socket.h>
	1551	#endif
	1552	])
	1553
	1554	# checks for typedefs
	1555	was_it_defined=no
	1556	AC_MSG_CHECKING(for clock_t in time.h)
	1557	AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
	1558	AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
	1559	])
	1560	AC_MSG_RESULT($was_it_defined)
	1561
	1562	# Check whether using makedev requires defining _OSF_SOURCE
	1563	AC_MSG_CHECKING(for makedev)
	1564	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	1565	#if defined(MAJOR_IN_MKDEV)
	1566	#include <sys/mkdev.h>
	1567	#elif defined(MAJOR_IN_SYSMACROS)
	1568	#include <sys/sysmacros.h>
	1569	#else
	1570	#include <sys/types.h>
	1571	#endif ]], [[ makedev(0, 0) ]])],
	1572	[ac_cv_has_makedev=yes],
	1573	[ac_cv_has_makedev=no])
	1574	if test "$ac_cv_has_makedev" = "no"; then
	1575	# we didn't link, try if _OSF_SOURCE will allow us to link
	1576	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	1577	#define _OSF_SOURCE 1
	1578	#include <sys/types.h>
	1579	]], [[ makedev(0, 0) ]])],
	1580	[ac_cv_has_makedev=yes],
	1581	[ac_cv_has_makedev=no])
	1582	if test "$ac_cv_has_makedev" = "yes"; then
	1583	AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
	1584	fi
	1585	fi
	1586	AC_MSG_RESULT($ac_cv_has_makedev)
	1587	if test "$ac_cv_has_makedev" = "yes"; then
	1588	AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
	1589	fi
	1590
	1591	# Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
	1592	# the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
	1593	# defined, but the compiler does not support pragma redefine_extname,
	1594	# and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
	1595	# structures (such as rlimit64) without declaring them. As a
	1596	# work-around, disable LFS on such configurations
	1597
	1598	use_lfs=yes
	1599	AC_MSG_CHECKING(Solaris LFS bug)
	1600	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	1601	#define _LARGEFILE_SOURCE 1
	1602	#define _FILE_OFFSET_BITS 64
	1603	#include <sys/resource.h>
	1604	]], [[struct rlimit foo;]])],[sol_lfs_bug=no],[sol_lfs_bug=yes])
	1605	AC_MSG_RESULT($sol_lfs_bug)
	1606	if test "$sol_lfs_bug" = "yes"; then
	1607	use_lfs=no
	1608	fi
	1609
	1610	if test "$use_lfs" = "yes"; then
	1611	# Two defines needed to enable largefile support on various platforms
	1612	# These may affect some typedefs
	1613	case $ac_sys_system/$ac_sys_release in
	1614	AIX*)
	1615	AC_DEFINE(_LARGE_FILES, 1,
	1616	[This must be defined on AIX systems to enable large file support.])
	1617	;;
	1618	esac
	1619	AC_DEFINE(_LARGEFILE_SOURCE, 1,
	1620	[This must be defined on some systems to enable large file support.])
	1621	AC_DEFINE(_FILE_OFFSET_BITS, 64,
	1622	[This must be set to 64 on some systems to enable large file support.])
	1623	fi
	1624
	1625	# Add some code to confdefs.h so that the test for off_t works on SCO
	1626	cat >> confdefs.h <<\EOF
	1627	#if defined(SCO_DS)
	1628	#undef _OFF_T
	1629	#endif
	1630	EOF
	1631
	1632	# Type availability checks
	1633	AC_TYPE_MODE_T
	1634	AC_TYPE_OFF_T
	1635	AC_TYPE_PID_T
	1636	AC_DEFINE_UNQUOTED([RETSIGTYPE],[void],[assume C89 semantics that RETSIGTYPE is always void])
	1637	AC_TYPE_SIZE_T
	1638	AC_TYPE_UID_T
	1639
	1640	# There are two separate checks for each of the exact-width integer types we
	1641	# need. First we check whether the type is available using the usual
	1642	# AC_CHECK_TYPE macro with the default includes (which includes <inttypes.h>
	1643	# and <stdint.h> where available). We then also use the special type checks of
	1644	# the form AC_TYPE_UINT32_T, which in the case that uint32_t is not available
	1645	# directly, #define's uint32_t to be a suitable type.
	1646
	1647	AC_CHECK_TYPE(uint32_t,
	1648	AC_DEFINE(HAVE_UINT32_T, 1, [Define if your compiler provides uint32_t.]),,)
	1649	AC_TYPE_UINT32_T
	1650
	1651	AC_CHECK_TYPE(uint64_t,
	1652	AC_DEFINE(HAVE_UINT64_T, 1, [Define if your compiler provides uint64_t.]),,)
	1653	AC_TYPE_UINT64_T
	1654
	1655	AC_CHECK_TYPE(int32_t,
	1656	AC_DEFINE(HAVE_INT32_T, 1, [Define if your compiler provides int32_t.]),,)
	1657	AC_TYPE_INT32_T
	1658
	1659	AC_CHECK_TYPE(int64_t,
	1660	AC_DEFINE(HAVE_INT64_T, 1, [Define if your compiler provides int64_t.]),,)
	1661	AC_TYPE_INT64_T
	1662
	1663	AC_CHECK_TYPE(ssize_t,
	1664	AC_DEFINE(HAVE_SSIZE_T, 1, [Define if your compiler provides ssize_t]),,)
	1665
	1666	# Sizes of various common basic types
	1667	# ANSI C requires sizeof(char) == 1, so no need to check it
	1668	AC_CHECK_SIZEOF(int, 4)
	1669	AC_CHECK_SIZEOF(long, 4)
	1670	AC_CHECK_SIZEOF(void *, 4)
	1671	AC_CHECK_SIZEOF(short, 2)
	1672	AC_CHECK_SIZEOF(float, 4)
	1673	AC_CHECK_SIZEOF(double, 8)
	1674	AC_CHECK_SIZEOF(fpos_t, 4)
	1675	AC_CHECK_SIZEOF(size_t, 4)
	1676	AC_CHECK_SIZEOF(pid_t, 4)
	1677
	1678	AC_MSG_CHECKING(for long long support)
	1679	have_long_long=no
	1680	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[long long x; x = (long long)0;]])],[
	1681	AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
	1682	have_long_long=yes
	1683	],[])
	1684	AC_MSG_RESULT($have_long_long)
	1685	if test "$have_long_long" = yes ; then
	1686	AC_CHECK_SIZEOF(long long, 8)
	1687	fi
	1688
	1689	AC_MSG_CHECKING(for long double support)
	1690	have_long_double=no
	1691	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[long double x; x = (long double)0;]])],[
	1692	AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
	1693	have_long_double=yes
	1694	],[])
	1695	AC_MSG_RESULT($have_long_double)
	1696	if test "$have_long_double" = yes ; then
	1697	AC_CHECK_SIZEOF(long double, 12)
	1698	fi
	1699
	1700	AC_MSG_CHECKING(for _Bool support)
	1701	have_c99_bool=no
	1702	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[_Bool x; x = (_Bool)0;]])],[
	1703	AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
	1704	have_c99_bool=yes
	1705	],[])
	1706	AC_MSG_RESULT($have_c99_bool)
	1707	if test "$have_c99_bool" = yes ; then
	1708	AC_CHECK_SIZEOF(_Bool, 1)
	1709	fi
	1710
	1711	AC_CHECK_TYPES(uintptr_t,
	1712	[AC_CHECK_SIZEOF(uintptr_t, 4)],
	1713	[], [#ifdef HAVE_STDINT_H
	1714	#include <stdint.h>
	1715	#endif
	1716	#ifdef HAVE_INTTYPES_H
	1717	#include <inttypes.h>
	1718	#endif])
	1719
	1720	AC_CHECK_SIZEOF(off_t, [], [
	1721	#ifdef HAVE_SYS_TYPES_H
	1722	#include <sys/types.h>
	1723	#endif
	1724	])
	1725
	1726	AC_MSG_CHECKING(whether to enable large file support)
	1727	if test "$have_long_long" = yes
	1728	then
	1729	if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
	1730	"$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
	1731	AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
	1732	[Defined to enable large file support when an off_t is bigger than a long
	1733	and long long is available and at least as big as an off_t. You may need
	1734	to add some flags for configuration and compilation to enable this mode.
	1735	(For Solaris and Linux, the necessary defines are already defined.)])
	1736	AC_MSG_RESULT(yes)
	1737	else
	1738	AC_MSG_RESULT(no)
	1739	fi
	1740	else
	1741	AC_MSG_RESULT(no)
	1742	fi
	1743
	1744	AC_CHECK_SIZEOF(time_t, [], [
	1745	#ifdef HAVE_SYS_TYPES_H
	1746	#include <sys/types.h>
	1747	#endif
	1748	#ifdef HAVE_TIME_H
	1749	#include <time.h>
	1750	#endif
	1751	])
	1752
	1753	# if have pthread_t then define SIZEOF_PTHREAD_T
	1754	ac_save_cc="$CC"
	1755	if test "$ac_cv_kpthread" = "yes"
	1756	then CC="$CC -Kpthread"
	1757	elif test "$ac_cv_kthread" = "yes"
	1758	then CC="$CC -Kthread"
	1759	elif test "$ac_cv_pthread" = "yes"
	1760	then CC="$CC -pthread"
	1761	fi
	1762	AC_MSG_CHECKING(for pthread_t)
	1763	have_pthread_t=no
	1764	AC_COMPILE_IFELSE([
	1765	AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = (pthread_t)0;]])
	1766	],[have_pthread_t=yes],[])
	1767	AC_MSG_RESULT($have_pthread_t)
	1768	if test "$have_pthread_t" = yes ; then
	1769	AC_CHECK_SIZEOF(pthread_t, [], [
	1770	#ifdef HAVE_PTHREAD_H
	1771	#include <pthread.h>
	1772	#endif
	1773	])
	1774	fi
	1775	CC="$ac_save_cc"
	1776
	1777	AC_MSG_CHECKING(for --enable-toolbox-glue)
	1778	AC_ARG_ENABLE(toolbox-glue,
	1779	AS_HELP_STRING([--enable-toolbox-glue], [disable/enable MacOSX glue code for extensions]))
	1780
	1781	if test -z "$enable_toolbox_glue"
	1782	then
	1783	case $ac_sys_system/$ac_sys_release in
	1784	Darwin/*)
	1785	enable_toolbox_glue="yes";;
	1786	*)
	1787	enable_toolbox_glue="no";;
	1788	esac
	1789	fi
	1790	case "$enable_toolbox_glue" in
	1791	yes)
	1792	extra_machdep_objs="Python/mactoolboxglue.o"
	1793	extra_undefs="-u _PyMac_Error"
	1794	AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
	1795	[Define if you want to use MacPython modules on MacOSX in unix-Python.])
	1796	;;
	1797	*)
	1798	extra_machdep_objs=""
	1799	extra_undefs=""
	1800	;;
	1801	esac
	1802	AC_MSG_RESULT($enable_toolbox_glue)
	1803
	1804
	1805	AC_SUBST(OTHER_LIBTOOL_OPT)
	1806	case $ac_sys_system/$ac_sys_release in
	1807	Darwin/@<:@01567@:>@\..*)
	1808	OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
	1809	;;
	1810	Darwin/*)
	1811	OTHER_LIBTOOL_OPT=""
	1812	;;
	1813	esac
	1814
	1815
	1816	AC_SUBST(LIBTOOL_CRUFT)
	1817	case $ac_sys_system/$ac_sys_release in
	1818	Darwin/@<:@01567@:>@\..*)
	1819	LIBTOOL_CRUFT="-framework System -lcc_dynamic"
	1820	if test "${enable_universalsdk}"; then
	1821	:
	1822	else
	1823	LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `/usr/bin/arch`"
	1824	fi
	1825	LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	1826	LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
	1827	Darwin/*)
	1828	gcc_version=`gcc -dumpversion`
	1829	if test ${gcc_version} '<' 4.0
	1830	then
	1831	LIBTOOL_CRUFT="-lcc_dynamic"
	1832	else
	1833	LIBTOOL_CRUFT=""
	1834	fi
	1835	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	1836	#include <unistd.h>
	1837	int main(int argc, char*argv[])
	1838	{
	1839	if (sizeof(long) == 4) {
	1840	return 0;
	1841	} else {
	1842	return 1;
	1843	}
	1844	}
	1845	]])],[ac_osx_32bit=yes],[ac_osx_32bit=no],[ac_osx_32bit=yes])
	1846
	1847	if test "${ac_osx_32bit}" = "yes"; then
	1848	case `/usr/bin/arch` in
	1849	i386)
	1850	MACOSX_DEFAULT_ARCH="i386"
	1851	;;
	1852	ppc)
	1853	MACOSX_DEFAULT_ARCH="ppc"
	1854	;;
	1855	*)
	1856	AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
	1857	;;
	1858	esac
	1859	else
	1860	case `/usr/bin/arch` in
	1861	i386)
	1862	MACOSX_DEFAULT_ARCH="x86_64"
	1863	;;
	1864	ppc)
	1865	MACOSX_DEFAULT_ARCH="ppc64"
	1866	;;
	1867	*)
	1868	AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
	1869	;;
	1870	esac
	1871
	1872	#ARCH_RUN_32BIT="true"
	1873	fi
	1874
	1875	LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
	1876	LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	1877	LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
	1878	esac
	1879
	1880	AC_MSG_CHECKING(for --enable-framework)
	1881	if test "$enable_framework"
	1882	then
	1883	BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
	1884	# -F. is needed to allow linking to the framework while
	1885	# in the build location.
	1886	AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
	1887	[Define if you want to produce an OpenStep/Rhapsody framework
	1888	(shared library plus accessory files).])
	1889	AC_MSG_RESULT(yes)
	1890	if test $enable_shared = "yes"
	1891	then
	1892	AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead. See Mac/README.])
	1893	fi
	1894	else
	1895	AC_MSG_RESULT(no)
	1896	fi
	1897
	1898	AC_MSG_CHECKING(for dyld)
	1899	case $ac_sys_system/$ac_sys_release in
	1900	Darwin/*)
	1901	AC_DEFINE(WITH_DYLD, 1,
	1902	[Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
	1903	dynamic linker (dyld) instead of the old-style (NextStep) dynamic
	1904	linker (rld). Dyld is necessary to support frameworks.])
	1905	AC_MSG_RESULT(always on for Darwin)
	1906	;;
	1907	*)
	1908	AC_MSG_RESULT(no)
	1909	;;
	1910	esac
	1911
	1912	# Set info about shared libraries.
	1913	AC_SUBST(SO)
	1914	AC_SUBST(LDSHARED)
	1915	AC_SUBST(LDCXXSHARED)
	1916	AC_SUBST(BLDSHARED)
	1917	AC_SUBST(CCSHARED)
	1918	AC_SUBST(LINKFORSHARED)
	1919	# SO is the extension of shared libraries `(including the dot!)
[400]	1920	# -- usually .so, .sl on HP-UX, .dll on Cygwin and OS/2
[388]	1921	AC_MSG_CHECKING(SO)
	1922	if test -z "$SO"
	1923	then
	1924	case $ac_sys_system in
	1925	hp\|HP)
	1926	case `uname -m` in
	1927	ia64) SO=.so;;
	1928	*) SO=.sl;;
	1929	esac
	1930	;;
	1931	CYGWIN*) SO=.dll;;
[400]	1932	OS/2\|os2\|emx) SO=.dll;;
[388]	1933	*) SO=.so;;
	1934	esac
	1935	else
	1936	# this might also be a termcap variable, see #610332
	1937	echo
	1938	echo '====================================================================='
	1939	echo '+ +'
	1940	echo '+ WARNING: You have set SO in your environment. +'
	1941	echo '+ Do you really mean to change the extension for shared libraries? +'
	1942	echo '+ Continuing in 10 seconds to let you to ponder. +'
	1943	echo '+ +'
	1944	echo '====================================================================='
	1945	sleep 10
	1946	fi
	1947	AC_MSG_RESULT($SO)
	1948
	1949	AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
	1950	# LDSHARED is the ld command used to create shared library
	1951	# -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
	1952	# (Shared libraries in this instance are shared modules to be loaded into
	1953	# Python, as opposed to building Python itself as a shared library.)
	1954	AC_MSG_CHECKING(LDSHARED)
	1955	if test -z "$LDSHARED"
	1956	then
	1957	case $ac_sys_system/$ac_sys_release in
	1958	AIX*)
	1959	BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:\$(srcdir)/Modules/python.exp"
	1960	LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
	1961	;;
	1962	BeOS*)
	1963	BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
	1964	LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
	1965	;;
	1966	IRIX/5*) LDSHARED="ld -shared";;
	1967	IRIX/6) LDSHARED="ld ${SGI_ABI} -shared -all";;
	1968	SunOS/5*)
	1969	if test "$GCC" = "yes" ; then
	1970	LDSHARED='$(CC) -shared'
	1971	LDCXXSHARED='$(CXX) -shared'
	1972	else
	1973	LDSHARED='$(CC) -G'
	1974	LDCXXSHARED='$(CXX) -G'
	1975	fi ;;
	1976	hp\|HP)
	1977	if test "$GCC" = "yes" ; then
	1978	LDSHARED='$(CC) -shared'
	1979	LDCXXSHARED='$(CXX) -shared'
	1980	else
	1981	LDSHARED='ld -b'
	1982	fi ;;
	1983	OSF) LDSHARED="ld -shared -expect_unresolved \"\"";;
	1984	Darwin/1.3*)
	1985	LDSHARED='$(CC) -bundle'
	1986	LDCXXSHARED='$(CXX) -bundle'
	1987	if test "$enable_framework" ; then
	1988	# Link against the framework. All externals should be defined.
	1989	BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	1990	LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	1991	LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	1992	else
	1993	# No framework. Ignore undefined symbols, assuming they come from Python
	1994	LDSHARED="$LDSHARED -undefined suppress"
	1995	LDCXXSHARED="$LDCXXSHARED -undefined suppress"
	1996	fi ;;
	1997	Darwin/1.4\|Darwin/5.\|Darwin/6.*)
	1998	LDSHARED='$(CC) -bundle'
	1999	LDCXXSHARED='$(CXX) -bundle'
	2000	if test "$enable_framework" ; then
	2001	# Link against the framework. All externals should be defined.
	2002	BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2003	LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2004	LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2005	else
	2006	# No framework, use the Python app as bundle-loader
	2007	BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
	2008	LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
	2009	LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
	2010	fi ;;
	2011	Darwin/*)
	2012	# Use -undefined dynamic_lookup whenever possible (10.3 and later).
	2013	# This allows an extension to be used in any Python
	2014
	2015	if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
	2016	then
	2017	if test "${enable_universalsdk}"; then
	2018	LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
	2019	fi
	2020	LDSHARED='$(CC) -bundle -undefined dynamic_lookup'
	2021	LDCXXSHARED='$(CXX) -bundle -undefined dynamic_lookup'
	2022	BLDSHARED="$LDSHARED"
	2023	else
	2024	LDSHARED='$(CC) -bundle'
	2025	LDCXXSHARED='$(CXX) -bundle'
	2026	if test "$enable_framework" ; then
	2027	# Link against the framework. All externals should be defined.
	2028	BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2029	LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2030	LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2031	else
	2032	# No framework, use the Python app as bundle-loader
	2033	BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
	2034	LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
	2035	LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
	2036	fi
	2037	fi
	2038	;;
	2039	Linux\|GNU\|QNX*)
	2040	LDSHARED='$(CC) -shared'
	2041	LDCXXSHARED='$(CXX) -shared';;
	2042	BSD/OS/4)
	2043	LDSHARED="gcc -shared"
	2044	LDCXXSHARED="g++ -shared";;
	2045	FreeBSD*)
	2046	if [[ "`$CC -dM -E - </dev/null \| grep __ELF__`" != "" ]]
	2047	then
	2048	LDSHARED='$(CC) -shared'
	2049	LDCXXSHARED='$(CXX) -shared'
	2050	else
	2051	LDSHARED="ld -Bshareable"
	2052	fi;;
	2053	OpenBSD*)
	2054	if [[ "`$CC -dM -E - </dev/null \| grep __ELF__`" != "" ]]
	2055	then
	2056	LDSHARED='$(CC) -shared $(CCSHARED)'
	2057	LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
	2058	else
	2059	case `uname -r` in
	2060	[[01]].* \| 2.[[0-7]] \| 2.[[0-7]].*)
	2061	LDSHARED="ld -Bshareable ${LDFLAGS}"
	2062	;;
	2063	*)
	2064	LDSHARED='$(CC) -shared $(CCSHARED)'
	2065	LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
	2066	;;
	2067	esac
	2068	fi;;
	2069	NetBSD\|DragonFly)
	2070	LDSHARED='$(CC) -shared'
	2071	LDCXXSHARED='$(CXX) -shared';;
	2072	OpenUNIX\|UnixWare)
	2073	if test "$GCC" = "yes" ; then
	2074	LDSHARED='$(CC) -shared'
	2075	LDCXXSHARED='$(CXX) -shared'
	2076	else
	2077	LDSHARED='$(CC) -G'
	2078	LDCXXSHARED='$(CXX) -G'
	2079	fi;;
	2080	SCO_SV*)
	2081	LDSHARED='$(CC) -Wl,-G,-Bexport'
	2082	LDCXXSHARED='$(CXX) -Wl,-G,-Bexport';;
	2083	CYGWIN*)
	2084	LDSHARED="gcc -shared -Wl,--enable-auto-image-base"
	2085	LDCXXSHARED="g++ -shared -Wl,--enable-auto-image-base";;
	2086	atheos*)
	2087	LDSHARED="gcc -shared"
	2088	LDCXXSHARED="g++ -shared";;
[400]	2089	OS/2\|os2\|emx)
[1150]	2090	LDSHARED='$(CC) -Zdll'
	2091	LDCXXSHARED='$(CXX) -Zdll';;
[388]	2092	*) LDSHARED="ld";;
	2093	esac
	2094	fi
	2095	AC_MSG_RESULT($LDSHARED)
	2096	LDCXXSHARED=${LDCXXSHARED-$LDSHARED}
	2097	BLDSHARED=${BLDSHARED-$LDSHARED}
	2098	# CCSHARED are the C flags used to create objects to go into a shared
	2099	# library (module) -- this is only needed for a few systems
	2100	AC_MSG_CHECKING(CCSHARED)
	2101	if test -z "$CCSHARED"
	2102	then
	2103	case $ac_sys_system/$ac_sys_release in
	2104	SunOS*) if test "$GCC" = yes;
	2105	then CCSHARED="-fPIC";
	2106	elif test `uname -p` = sparc;
	2107	then CCSHARED="-xcode=pic32";
	2108	else CCSHARED="-Kpic";
	2109	fi;;
	2110	hp\|HP) if test "$GCC" = yes;
	2111	then CCSHARED="-fPIC";
	2112	else CCSHARED="+z";
	2113	fi;;
	2114	Linux\|GNU) CCSHARED="-fPIC";;
	2115	BSD/OS/4) CCSHARED="-fpic";;
	2116	FreeBSD\|NetBSD\|OpenBSD\|DragonFly) CCSHARED="-fPIC";;
	2117	OpenUNIX\|UnixWare)
	2118	if test "$GCC" = "yes"
	2119	then CCSHARED="-fPIC"
	2120	else CCSHARED="-KPIC"
	2121	fi;;
	2122	SCO_SV*)
	2123	if test "$GCC" = "yes"
	2124	then CCSHARED="-fPIC"
	2125	else CCSHARED="-Kpic -belf"
	2126	fi;;
	2127	IRIX/6) case $CC in
	2128	gcc) CCSHARED="-shared";;
	2129	*) CCSHARED="";;
	2130	esac;;
	2131	atheos*) CCSHARED="-fPIC";;
	2132	esac
	2133	fi
	2134	AC_MSG_RESULT($CCSHARED)
	2135	# LINKFORSHARED are the flags passed to the $(CC) command that links
	2136	# the python executable -- this is only needed for a few systems
	2137	AC_MSG_CHECKING(LINKFORSHARED)
	2138	if test -z "$LINKFORSHARED"
	2139	then
	2140	case $ac_sys_system/$ac_sys_release in
	2141	AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
	2142	hp\|HP)
	2143	LINKFORSHARED="-Wl,-E -Wl,+s";;
	2144	# LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
	2145	BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
	2146	Linux\|GNU) LINKFORSHARED="-Xlinker -export-dynamic";;
	2147	# -u libsys_s pulls in all symbols in libsys
	2148	Darwin/*)
	2149	# -u _PyMac_Error is needed to pull in the mac toolbox glue,
	2150	# which is
	2151	# not used by the core itself but which needs to be in the core so
	2152	# that dynamically loaded extension modules have access to it.
	2153	# -prebind is no longer used, because it actually seems to give a
	2154	# slowdown in stead of a speedup, maybe due to the large number of
	2155	# dynamic loads Python does.
	2156
	2157	LINKFORSHARED="$extra_undefs"
	2158	if test "$enable_framework"
	2159	then
	2160	LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
	2161	fi
	2162	LINKFORSHARED="$LINKFORSHARED";;
	2163	OpenUNIX\|UnixWare) LINKFORSHARED="-Wl,-Bexport";;
	2164	SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
	2165	ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
	2166	FreeBSD\|NetBSD\|OpenBSD\|DragonFly)
	2167	if [[ "`$CC -dM -E - </dev/null \| grep __ELF__`" != "" ]]
	2168	then
	2169	LINKFORSHARED="-Wl,--export-dynamic"
	2170	fi;;
	2171	SunOS/5*) case $CC in
	2172	gcc)
	2173	if $CC -Xlinker --help 2>&1 \| grep export-dynamic >/dev/null
	2174	then
	2175	LINKFORSHARED="-Xlinker --export-dynamic"
	2176	fi;;
	2177	esac;;
	2178	CYGWIN*)
	2179	if test $enable_shared = "no"
	2180	then
	2181	LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
	2182	fi;;
	2183	QNX*)
	2184	# -Wl,-E causes the symbols to be added to the dynamic
	2185	# symbol table so that they can be found when a module
	2186	# is loaded. -N 2048K causes the stack size to be set
	2187	# to 2048 kilobytes so that the stack doesn't overflow
	2188	# when running test_compile.py.
	2189	LINKFORSHARED='-Wl,-E -N 2048K';;
	2190	esac
	2191	fi
	2192	AC_MSG_RESULT($LINKFORSHARED)
	2193
	2194
	2195	AC_SUBST(CFLAGSFORSHARED)
	2196	AC_MSG_CHECKING(CFLAGSFORSHARED)
	2197	if test ! "$LIBRARY" = "$LDLIBRARY"
	2198	then
	2199	case $ac_sys_system in
	2200	CYGWIN*)
	2201	# Cygwin needs CCSHARED when building extension DLLs
	2202	# but not when building the interpreter DLL.
	2203	CFLAGSFORSHARED='';;
	2204	*)
	2205	CFLAGSFORSHARED='$(CCSHARED)'
	2206	esac
	2207	fi
	2208	AC_MSG_RESULT($CFLAGSFORSHARED)
	2209
	2210	# SHLIBS are libraries (except -lc and -lm) to link to the python shared
	2211	# library (with --enable-shared).
	2212	# For platforms on which shared libraries are not allowed to have unresolved
	2213	# symbols, this must be set to $(LIBS) (expanded by make). We do this even
	2214	# if it is not required, since it creates a dependency of the shared library
	2215	# to LIBS. This, in turn, means that applications linking the shared libpython
	2216	# don't need to link LIBS explicitly. The default should be only changed
	2217	# on systems where this approach causes problems.
	2218	AC_SUBST(SHLIBS)
	2219	AC_MSG_CHECKING(SHLIBS)
	2220	case "$ac_sys_system" in
	2221	*)
	2222	SHLIBS='$(LIBS)';;
	2223	esac
	2224	AC_MSG_RESULT($SHLIBS)
	2225
	2226
	2227	# checks for libraries
	2228	AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
	2229	AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
	2230
	2231	# only check for sem_init if thread support is requested
	2232	if test "$with_threads" = "yes" -o -z "$with_threads"; then
	2233	AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
	2234	# posix4 on Solaris 2.6
	2235	# pthread (first!) on Linux
	2236	fi
	2237
	2238	# check if we need libintl for locale functions
	2239	AC_CHECK_LIB(intl, textdomain,
	2240	AC_DEFINE(WITH_LIBINTL, 1,
	2241	[Define to 1 if libintl is needed for locale functions.]))
	2242
	2243	# checks for system dependent C++ extensions support
	2244	case "$ac_sys_system" in
	2245	AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
	2246	AC_LINK_IFELSE([
	2247	AC_LANG_PROGRAM([[#include <load.h>]],
	2248	[[loadAndInit("", 0, "")]])
	2249	],[
	2250	AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
	2251	[Define for AIX if your compiler is a genuine IBM xlC/xlC_r
	2252	and you want support for AIX C++ shared extension modules.])
	2253	AC_MSG_RESULT(yes)
	2254	],[
	2255	AC_MSG_RESULT(no)
	2256	]);;
	2257	*) ;;
	2258	esac
	2259
	2260	# Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
	2261	# BeOS' sockets are stashed in libnet.
	2262	AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
	2263	AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
	2264
	2265	case "$ac_sys_system" in
	2266	BeOS*)
	2267	AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
	2268	;;
	2269	esac
	2270
	2271	AC_MSG_CHECKING(for --with-libs)
	2272	AC_ARG_WITH(libs,
	2273	AS_HELP_STRING([--with-libs='lib1 ...'], [link against additional libs]),
	2274	[
	2275	AC_MSG_RESULT($withval)
	2276	LIBS="$withval $LIBS"
	2277	],
	2278	[AC_MSG_RESULT(no)])
	2279
	2280	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
	2281
	2282	# Check for use of the system expat library
	2283	AC_MSG_CHECKING(for --with-system-expat)
	2284	AC_ARG_WITH(system_expat,
	2285	AS_HELP_STRING([--with-system-expat], [build pyexpat module using an installed expat library]),
	2286	[],
	2287	[with_system_expat="no"])
	2288
	2289	AC_MSG_RESULT($with_system_expat)
	2290
	2291	# Check for use of the system libffi library
	2292	AC_MSG_CHECKING(for --with-system-ffi)
	2293	AC_ARG_WITH(system_ffi,
	2294	AS_HELP_STRING([--with-system-ffi], [build _ctypes module using an installed ffi library]),
	2295	[],
	2296	[with_system_ffi="no"])
	2297
	2298	if test "$with_system_ffi" = "yes" && test -n "$PKG_CONFIG"; then
	2299	LIBFFI_INCLUDEDIR="`"$PKG_CONFIG" libffi --cflags-only-I 2>/dev/null \| sed -e 's/^-I//;s/ *$//'`"
	2300	else
	2301	LIBFFI_INCLUDEDIR=""
	2302	fi
	2303	AC_SUBST(LIBFFI_INCLUDEDIR)
	2304
	2305	AC_MSG_RESULT($with_system_ffi)
	2306
	2307	# Check for --with-tcltk-includes=path and --with-tcltk-libs=path
	2308	AC_SUBST(TCLTK_INCLUDES)
	2309	AC_SUBST(TCLTK_LIBS)
	2310	AC_MSG_CHECKING(for --with-tcltk-includes)
	2311	AC_ARG_WITH(tcltk-includes,
	2312	AS_HELP_STRING([--with-tcltk-includes='-I...'], [override search for Tcl and Tk include files]),
	2313	[],
	2314	[with_tcltk_includes="default"])
	2315	AC_MSG_RESULT($with_tcltk_includes)
	2316	AC_MSG_CHECKING(for --with-tcltk-libs)
	2317	AC_ARG_WITH(tcltk-libs,
	2318	AS_HELP_STRING([--with-tcltk-libs='-L...'], [override search for Tcl and Tk libs]),
	2319	[],
	2320	[with_tcltk_libs="default"])
	2321	AC_MSG_RESULT($with_tcltk_libs)
	2322	if test "x$with_tcltk_includes" = xdefault \|\| test "x$with_tcltk_libs" = xdefault
	2323	then
	2324	if test "x$with_tcltk_includes" != "x$with_tcltk_libs"
	2325	then
	2326	AC_MSG_ERROR([use both --with-tcltk-includes='...' and --with-tcltk-libs='...' or neither])
	2327	fi
	2328	TCLTK_INCLUDES=""
	2329	TCLTK_LIBS=""
	2330	else
	2331	TCLTK_INCLUDES="$with_tcltk_includes"
	2332	TCLTK_LIBS="$with_tcltk_libs"
	2333	fi
	2334
	2335	# Check for --with-dbmliborder
	2336	AC_MSG_CHECKING(for --with-dbmliborder)
	2337	AC_ARG_WITH(dbmliborder,
	2338	AS_HELP_STRING([--with-dbmliborder=db1:db2:...], [order to check db backends for dbm. Valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]),
	2339	[
	2340	if test x$with_dbmliborder = xyes
	2341	then
	2342	AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
	2343	else
	2344	for db in `echo $with_dbmliborder \| sed 's/:/ /g'`; do
	2345	if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
	2346	then
	2347	AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
	2348	fi
	2349	done
	2350	fi])
	2351	AC_MSG_RESULT($with_dbmliborder)
	2352
	2353	# Determine if signalmodule should be used.
	2354	AC_SUBST(USE_SIGNAL_MODULE)
	2355	AC_SUBST(SIGNAL_OBJS)
	2356	AC_MSG_CHECKING(for --with-signal-module)
	2357	AC_ARG_WITH(signal-module,
	2358	AS_HELP_STRING([--with-signal-module], [disable/enable signal module]))
	2359
	2360	if test -z "$with_signal_module"
	2361	then with_signal_module="yes"
	2362	fi
	2363	AC_MSG_RESULT($with_signal_module)
	2364
	2365	if test "${with_signal_module}" = "yes"; then
	2366	USE_SIGNAL_MODULE=""
	2367	SIGNAL_OBJS=""
	2368	else
	2369	USE_SIGNAL_MODULE="#"
	2370	SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
	2371	fi
	2372
	2373	# This is used to generate Setup.config
	2374	AC_SUBST(USE_THREAD_MODULE)
	2375	USE_THREAD_MODULE=""
	2376
	2377	AC_MSG_CHECKING(for --with-dec-threads)
	2378	AC_SUBST(LDLAST)
	2379	AC_ARG_WITH(dec-threads,
	2380	AS_HELP_STRING([--with-dec-threads], [use DEC Alpha/OSF1 thread-safe libraries]),
	2381	[
	2382	AC_MSG_RESULT($withval)
	2383	LDLAST=-threads
	2384	if test "${with_thread+set}" != set; then
	2385	with_thread="$withval";
	2386	fi],
	2387	[AC_MSG_RESULT(no)])
	2388
	2389	# Templates for things AC_DEFINEd more than once.
	2390	# For a single AC_DEFINE, no template is needed.
	2391	AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
	2392	AH_TEMPLATE(_REENTRANT,
	2393	[Define to force use of thread-safe errno, h_errno, and other functions])
	2394	AH_TEMPLATE(WITH_THREAD,
	2395	[Define if you want to compile in rudimentary thread support])
	2396
	2397	AC_MSG_CHECKING(for --with-threads)
	2398	dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
	2399	AC_ARG_WITH(threads,
	2400	AS_HELP_STRING([--with(out)-threads@<:@=DIRECTORY@:>@], [disable/enable thread support]))
	2401
	2402	# --with-thread is deprecated, but check for it anyway
	2403	dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
	2404	AC_ARG_WITH(thread,
	2405	AS_HELP_STRING([--with(out)-thread@<:@=DIRECTORY@:>@], [deprecated; use --with(out)-threads]),
	2406	[with_threads=$with_thread])
	2407
	2408	if test -z "$with_threads"
	2409	then with_threads="yes"
	2410	fi
	2411	AC_MSG_RESULT($with_threads)
	2412
	2413	AC_SUBST(THREADOBJ)
	2414	if test "$with_threads" = "no"
	2415	then
	2416	USE_THREAD_MODULE="#"
	2417	elif test "$ac_cv_pthread_is_default" = yes
	2418	then
	2419	AC_DEFINE(WITH_THREAD)
	2420	# Defining _REENTRANT on system with POSIX threads should not hurt.
	2421	AC_DEFINE(_REENTRANT)
	2422	posix_threads=yes
	2423	THREADOBJ="Python/thread.o"
	2424	elif test "$ac_cv_kpthread" = "yes"
	2425	then
	2426	CC="$CC -Kpthread"
	2427	if test "$ac_cv_cxx_thread" = "yes"; then
	2428	CXX="$CXX -Kpthread"
	2429	fi
	2430	AC_DEFINE(WITH_THREAD)
	2431	posix_threads=yes
	2432	THREADOBJ="Python/thread.o"
	2433	elif test "$ac_cv_kthread" = "yes"
	2434	then
	2435	CC="$CC -Kthread"
	2436	if test "$ac_cv_cxx_thread" = "yes"; then
	2437	CXX="$CXX -Kthread"
	2438	fi
	2439	AC_DEFINE(WITH_THREAD)
	2440	posix_threads=yes
	2441	THREADOBJ="Python/thread.o"
	2442	elif test "$ac_cv_pthread" = "yes"
	2443	then
	2444	CC="$CC -pthread"
	2445	if test "$ac_cv_cxx_thread" = "yes"; then
	2446	CXX="$CXX -pthread"
	2447	fi
	2448	AC_DEFINE(WITH_THREAD)
	2449	posix_threads=yes
	2450	THREADOBJ="Python/thread.o"
	2451	else
	2452	if test ! -z "$with_threads" -a -d "$with_threads"
	2453	then LDFLAGS="$LDFLAGS -L$with_threads"
	2454	fi
	2455	if test ! -z "$withval" -a -d "$withval"
	2456	then LDFLAGS="$LDFLAGS -L$withval"
	2457	fi
	2458
	2459	# According to the POSIX spec, a pthreads implementation must
	2460	# define _POSIX_THREADS in unistd.h. Some apparently don't
	2461	# (e.g. gnu pth with pthread emulation)
	2462	AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
	2463	AC_EGREP_CPP(yes,
	2464	[
	2465	#include <unistd.h>
	2466	#ifdef _POSIX_THREADS
	2467	yes
	2468	#endif
	2469	], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
	2470	AC_MSG_RESULT($unistd_defines_pthreads)
	2471
	2472	AC_DEFINE(_REENTRANT)
	2473	AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
	2474	AC_DEFINE(C_THREADS)
	2475	AC_DEFINE(HURD_C_THREADS, 1,
	2476	[Define if you are using Mach cthreads directly under /include])
	2477	LIBS="$LIBS -lthreads"
	2478	THREADOBJ="Python/thread.o"],[
	2479	AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
	2480	AC_DEFINE(C_THREADS)
	2481	AC_DEFINE(MACH_C_THREADS, 1,
	2482	[Define if you are using Mach cthreads under mach /])
	2483	THREADOBJ="Python/thread.o"],[
	2484	AC_MSG_CHECKING(for --with-pth)
	2485	AC_ARG_WITH([pth],
	2486	AS_HELP_STRING([--with-pth], [use GNU pth threading libraries]),
	2487	[AC_MSG_RESULT($withval)
	2488	AC_DEFINE([WITH_THREAD])
	2489	AC_DEFINE([HAVE_PTH], 1,
	2490	[Define if you have GNU PTH threads.])
	2491	LIBS="-lpth $LIBS"
	2492	THREADOBJ="Python/thread.o"],
	2493	[AC_MSG_RESULT(no)
	2494
	2495	# Just looking for pthread_create in libpthread is not enough:
	2496	# on HP/UX, pthread.h renames pthread_create to a different symbol name.
	2497	# So we really have to include pthread.h, and then link.
	2498	_libs=$LIBS
	2499	LIBS="$LIBS -lpthread"
	2500	AC_MSG_CHECKING([for pthread_create in -lpthread])
	2501	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	2502	#include <stdio.h>
	2503	#include <pthread.h>
	2504
	2505	void * start_routine (void *arg) { exit (0); }]], [[
	2506	pthread_create (NULL, NULL, start_routine, NULL)]])],[
	2507	AC_MSG_RESULT(yes)
	2508	AC_DEFINE(WITH_THREAD)
	2509	posix_threads=yes
	2510	THREADOBJ="Python/thread.o"],[
	2511	LIBS=$_libs
	2512	AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
	2513	posix_threads=yes
	2514	THREADOBJ="Python/thread.o"],[
	2515	AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
	2516	AC_DEFINE(ATHEOS_THREADS, 1,
	2517	[Define this if you have AtheOS threads.])
	2518	THREADOBJ="Python/thread.o"],[
	2519	AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
	2520	AC_DEFINE(BEOS_THREADS, 1,
	2521	[Define this if you have BeOS threads.])
	2522	THREADOBJ="Python/thread.o"],[
	2523	AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
	2524	posix_threads=yes
	2525	LIBS="$LIBS -lpthreads"
	2526	THREADOBJ="Python/thread.o"], [
	2527	AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
	2528	posix_threads=yes
	2529	LIBS="$LIBS -lc_r"
	2530	THREADOBJ="Python/thread.o"], [
	2531	AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
	2532	posix_threads=yes
	2533	LIBS="$LIBS -lpthread"
	2534	THREADOBJ="Python/thread.o"], [
	2535	AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
	2536	posix_threads=yes
	2537	LIBS="$LIBS -lcma"
	2538	THREADOBJ="Python/thread.o"],[
	2539	USE_THREAD_MODULE="#"])
	2540	])])])])])])])])])])
	2541
	2542	AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
	2543	LIBS="$LIBS -lmpc"
	2544	THREADOBJ="Python/thread.o"
	2545	USE_THREAD_MODULE=""])
	2546
	2547	if test "$posix_threads" != "yes"; then
	2548	AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
	2549	LIBS="$LIBS -lthread"
	2550	THREADOBJ="Python/thread.o"
	2551	USE_THREAD_MODULE=""])
	2552	fi
	2553
	2554	if test "$USE_THREAD_MODULE" != "#"
	2555	then
	2556	# If the above checks didn't disable threads, (at least) OSF1
	2557	# needs this '-threads' argument during linking.
	2558	case $ac_sys_system in
	2559	OSF1) LDLAST=-threads;;
	2560	esac
	2561	fi
	2562	fi
	2563
	2564	if test "$posix_threads" = "yes"; then
	2565	if test "$unistd_defines_pthreads" = "no"; then
	2566	AC_DEFINE(_POSIX_THREADS, 1,
	2567	[Define if you have POSIX threads,
	2568	and your system does not define that.])
	2569	fi
	2570
	2571	# Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
	2572	case $ac_sys_system/$ac_sys_release in
	2573	SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
	2574	[Defined for Solaris 2.6 bug in pthread header.])
	2575	;;
	2576	SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
	2577	[Define if the Posix semaphores do not work on your system])
	2578	;;
	2579	AIX/*) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
	2580	[Define if the Posix semaphores do not work on your system])
	2581	;;
	2582	esac
	2583
	2584	AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
	2585	AC_CACHE_VAL(ac_cv_pthread_system_supported,
	2586	[AC_RUN_IFELSE([AC_LANG_SOURCE([[
	2587	#include <stdio.h>
	2588	#include <pthread.h>
	2589	void foo(void parm) {
	2590	return NULL;
	2591	}
	2592	main() {
	2593	pthread_attr_t attr;
	2594	pthread_t id;
	2595	if (pthread_attr_init(&attr)) exit(-1);
	2596	if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
	2597	if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
	2598	exit(0);
	2599	}]])],
	2600	[ac_cv_pthread_system_supported=yes],
	2601	[ac_cv_pthread_system_supported=no],
	2602	[ac_cv_pthread_system_supported=no])
	2603	])
	2604	AC_MSG_RESULT($ac_cv_pthread_system_supported)
	2605	if test "$ac_cv_pthread_system_supported" = "yes"; then
	2606	AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
	2607	fi
	2608	AC_CHECK_FUNCS(pthread_sigmask,
	2609	[case $ac_sys_system in
	2610	CYGWIN*)
	2611	AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
	2612	[Define if pthread_sigmask() does not work on your system.])
	2613	;;
	2614	esac])
	2615	AC_CHECK_FUNCS(pthread_atfork)
	2616	fi
	2617
	2618
	2619	# Check for enable-ipv6
	2620	AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
	2621	AC_MSG_CHECKING([if --enable-ipv6 is specified])
	2622	AC_ARG_ENABLE(ipv6,
	2623	[ --enable-ipv6 Enable ipv6 (with ipv4) support
	2624	--disable-ipv6 Disable ipv6 support],
	2625	[ case "$enableval" in
	2626	no)
	2627	AC_MSG_RESULT(no)
	2628	ipv6=no
	2629	;;
	2630	*) AC_MSG_RESULT(yes)
	2631	AC_DEFINE(ENABLE_IPV6)
	2632	ipv6=yes
	2633	;;
	2634	esac ],
	2635
	2636	[
	2637	dnl the check does not work on cross compilation case...
	2638	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* AF_INET6 available check */
	2639	#include <sys/types.h>
	2640	#include <sys/socket.h>]],
	2641	[[int domain = AF_INET6;]])],[
	2642	AC_MSG_RESULT(yes)
	2643	ipv6=yes
	2644	],[
	2645	AC_MSG_RESULT(no)
	2646	ipv6=no
	2647	])
	2648
	2649	if test "$ipv6" = "yes"; then
	2650	AC_MSG_CHECKING(if RFC2553 API is available)
	2651	AC_COMPILE_IFELSE([
	2652	AC_LANG_PROGRAM([[#include <sys/types.h>
	2653	#include <netinet/in.h>]],
	2654	[[struct sockaddr_in6 x;
	2655	x.sin6_scope_id;]])
	2656	],[
	2657	AC_MSG_RESULT(yes)
	2658	ipv6=yes
	2659	],[
	2660	AC_MSG_RESULT(no, IPv6 disabled)
	2661	ipv6=no
	2662	])
	2663	fi
	2664
	2665	if test "$ipv6" = "yes"; then
	2666	AC_DEFINE(ENABLE_IPV6)
	2667	fi
	2668	])
	2669
	2670	ipv6type=unknown
	2671	ipv6lib=none
	2672	ipv6trylibc=no
	2673
	2674	if test "$ipv6" = "yes"; then
	2675	AC_MSG_CHECKING([ipv6 stack type])
	2676	for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
	2677	do
	2678	case $i in
	2679	inria)
	2680	dnl http://www.kame.net/
	2681	AC_EGREP_CPP(yes, [
	2682	#include <netinet/in.h>
	2683	#ifdef IPV6_INRIA_VERSION
	2684	yes
	2685	#endif],
	2686	[ipv6type=$i])
	2687	;;
	2688	kame)
	2689	dnl http://www.kame.net/
	2690	AC_EGREP_CPP(yes, [
	2691	#include <netinet/in.h>
	2692	#ifdef __KAME__
	2693	yes
	2694	#endif],
	2695	[ipv6type=$i;
	2696	ipv6lib=inet6
	2697	ipv6libdir=/usr/local/v6/lib
	2698	ipv6trylibc=yes])
	2699	;;
	2700	linux-glibc)
	2701	dnl http://www.v6.linux.or.jp/
	2702	AC_EGREP_CPP(yes, [
	2703	#include <features.h>
	2704	#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) \|\| (__GLIBC__ > 2))
	2705	yes
	2706	#endif],
	2707	[ipv6type=$i;
	2708	ipv6trylibc=yes])
	2709	;;
	2710	linux-inet6)
	2711	dnl http://www.v6.linux.or.jp/
	2712	if test -d /usr/inet6; then
	2713	ipv6type=$i
	2714	ipv6lib=inet6
	2715	ipv6libdir=/usr/inet6/lib
	2716	BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
	2717	fi
	2718	;;
	2719	solaris)
	2720	if test -f /etc/netconfig; then
	2721	if $GREP -q tcp6 /etc/netconfig; then
	2722	ipv6type=$i
	2723	ipv6trylibc=yes
	2724	fi
	2725	fi
	2726	;;
	2727	toshiba)
	2728	AC_EGREP_CPP(yes, [
	2729	#include <sys/param.h>
	2730	#ifdef _TOSHIBA_INET6
	2731	yes
	2732	#endif],
	2733	[ipv6type=$i;
	2734	ipv6lib=inet6;
	2735	ipv6libdir=/usr/local/v6/lib])
	2736	;;
	2737	v6d)
	2738	AC_EGREP_CPP(yes, [
	2739	#include </usr/local/v6/include/sys/v6config.h>
	2740	#ifdef __V6D__
	2741	yes
	2742	#endif],
	2743	[ipv6type=$i;
	2744	ipv6lib=v6;
	2745	ipv6libdir=/usr/local/v6/lib;
	2746	BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
	2747	;;
	2748	zeta)
	2749	AC_EGREP_CPP(yes, [
	2750	#include <sys/param.h>
	2751	#ifdef _ZETA_MINAMI_INET6
	2752	yes
	2753	#endif],
	2754	[ipv6type=$i;
	2755	ipv6lib=inet6;
	2756	ipv6libdir=/usr/local/v6/lib])
	2757	;;
	2758	esac
	2759	if test "$ipv6type" != "unknown"; then
	2760	break
	2761	fi
	2762	done
	2763	AC_MSG_RESULT($ipv6type)
	2764	fi
	2765
	2766	if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
	2767	if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
	2768	LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
	2769	echo "using lib$ipv6lib"
	2770	else
	2771	if test $ipv6trylibc = "yes"; then
	2772	echo "using libc"
	2773	else
	2774	echo 'Fatal: no $ipv6lib library found. cannot continue.'
	2775	echo "You need to fetch lib$ipv6lib.a from appropriate"
	2776	echo 'ipv6 kit and compile beforehand.'
	2777	exit 1
	2778	fi
	2779	fi
	2780	fi
	2781
	2782	AC_MSG_CHECKING(for OSX 10.5 SDK or later)
	2783	AC_COMPILE_IFELSE([
	2784	AC_LANG_PROGRAM([[#include <Carbon/Carbon.h>]], [[FSIORefNum fRef = 0]])
	2785	],[
	2786	AC_DEFINE(HAVE_OSX105_SDK, 1, [Define if compiling using MacOS X 10.5 SDK or later.])
	2787	AC_MSG_RESULT(yes)
	2788	],[
	2789	AC_MSG_RESULT(no)
	2790	])
	2791
	2792	# Check for --with-doc-strings
	2793	AC_MSG_CHECKING(for --with-doc-strings)
	2794	AC_ARG_WITH(doc-strings,
	2795	AS_HELP_STRING([--with(out)-doc-strings], [disable/enable documentation strings]))
	2796
	2797	if test -z "$with_doc_strings"
	2798	then with_doc_strings="yes"
	2799	fi
	2800	if test "$with_doc_strings" != "no"
	2801	then
	2802	AC_DEFINE(WITH_DOC_STRINGS, 1,
	2803	[Define if you want documentation strings in extension modules])
	2804	fi
	2805	AC_MSG_RESULT($with_doc_strings)
	2806
	2807	# Check for Python-specific malloc support
	2808	AC_MSG_CHECKING(for --with-tsc)
	2809	AC_ARG_WITH(tsc,
	2810	AS_HELP_STRING([--with(out)-tsc],[enable/disable timestamp counter profile]),[
	2811	if test "$withval" != no
	2812	then
	2813	AC_DEFINE(WITH_TSC, 1,
	2814	[Define to profile with the Pentium timestamp counter])
	2815	AC_MSG_RESULT(yes)
	2816	else AC_MSG_RESULT(no)
	2817	fi],
	2818	[AC_MSG_RESULT(no)])
	2819
	2820	# Check for Python-specific malloc support
	2821	AC_MSG_CHECKING(for --with-pymalloc)
	2822	AC_ARG_WITH(pymalloc,
	2823	AS_HELP_STRING([--with(out)-pymalloc], [disable/enable specialized mallocs]))
	2824
	2825	if test -z "$with_pymalloc"
	2826	then with_pymalloc="yes"
	2827	fi
	2828	if test "$with_pymalloc" != "no"
	2829	then
	2830	AC_DEFINE(WITH_PYMALLOC, 1,
	2831	[Define if you want to compile in Python-specific mallocs])
	2832	fi
	2833	AC_MSG_RESULT($with_pymalloc)
	2834
	2835	# Check for Valgrind support
	2836	AC_MSG_CHECKING([for --with-valgrind])
	2837	AC_ARG_WITH([valgrind],
	2838	AS_HELP_STRING([--with-valgrind], [Enable Valgrind support]),,
	2839	with_valgrind=no)
	2840	AC_MSG_RESULT([$with_valgrind])
	2841	if test "$with_valgrind" != no; then
	2842	AC_CHECK_HEADER([valgrind/valgrind.h],
	2843	[AC_DEFINE([WITH_VALGRIND], 1, [Define if you want pymalloc to be disabled when running under valgrind])],
	2844	[AC_MSG_ERROR([Valgrind support requested but headers not available])]
	2845	)
	2846	fi
	2847
	2848	# Check for --with-wctype-functions
	2849	AC_MSG_CHECKING(for --with-wctype-functions)
	2850	AC_ARG_WITH(wctype-functions,
	2851	AS_HELP_STRING([--with-wctype-functions], [use wctype.h functions]),
	2852	[
	2853	if test "$withval" != no
	2854	then
	2855	AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
	2856	[Define if you want wctype.h functions to be used instead of the
	2857	one supplied by Python itself. (see Include/unicodectype.h).])
	2858	AC_MSG_RESULT(yes)
	2859	else AC_MSG_RESULT(no)
	2860	fi],
	2861	[AC_MSG_RESULT(no)])
	2862
	2863	# -I${DLINCLDIR} is added to the compile rule for importdl.o
	2864	AC_SUBST(DLINCLDIR)
	2865	DLINCLDIR=.
	2866
	2867	# the dlopen() function means we might want to use dynload_shlib.o. some
	2868	# platforms, such as AIX, have dlopen(), but don't want to use it.
	2869	AC_CHECK_FUNCS(dlopen)
	2870
	2871	# DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
	2872	# loading of modules.
	2873	AC_SUBST(DYNLOADFILE)
	2874	AC_MSG_CHECKING(DYNLOADFILE)
	2875	if test -z "$DYNLOADFILE"
	2876	then
	2877	case $ac_sys_system/$ac_sys_release in
	2878	AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
	2879	if test "$ac_cv_func_dlopen" = yes
	2880	then DYNLOADFILE="dynload_shlib.o"
	2881	else DYNLOADFILE="dynload_aix.o"
	2882	fi
	2883	;;
	2884	BeOS*) DYNLOADFILE="dynload_beos.o";;
	2885	hp\|HP) DYNLOADFILE="dynload_hpux.o";;
	2886	# Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
	2887	Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
	2888	atheos*) DYNLOADFILE="dynload_atheos.o";;
	2889	*)
	2890	# use dynload_shlib.c and dlopen() if we have it; otherwise stub
	2891	# out any dynamic loading
	2892	if test "$ac_cv_func_dlopen" = yes
	2893	then DYNLOADFILE="dynload_shlib.o"
	2894	else DYNLOADFILE="dynload_stub.o"
	2895	fi
	2896	;;
	2897	esac
	2898	fi
	2899	AC_MSG_RESULT($DYNLOADFILE)
	2900	if test "$DYNLOADFILE" != "dynload_stub.o"
	2901	then
	2902	AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
	2903	[Defined when any dynamic module loading is enabled.])
	2904	fi
	2905
	2906	# MACHDEP_OBJS can be set to platform-specific object files needed by Python
	2907
	2908	AC_SUBST(MACHDEP_OBJS)
	2909	AC_MSG_CHECKING(MACHDEP_OBJS)
	2910	if test -z "$MACHDEP_OBJS"
	2911	then
	2912	MACHDEP_OBJS=$extra_machdep_objs
	2913	else
	2914	MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
	2915	fi
	2916	AC_MSG_RESULT(MACHDEP_OBJS)
	2917
	2918	# checks for library functions
	2919	AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
	2920	clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
	2921	gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
	2922	getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
	2923	initgroups kill killpg lchmod lchown lstat mkfifo mknod mktime \
	2924	mremap nice pathconf pause plock poll pthread_init \
	2925	putenv readlink realpath \
	2926	select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
	2927	setgid \
	2928	setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
	2929	setlocale setregid setreuid setresuid setresgid \
	2930	setsid setpgid setpgrp setuid setvbuf snprintf \
	2931	sigaction siginterrupt sigrelse strftime \
	2932	sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
	2933	truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
	2934
	2935	# For some functions, having a definition is not sufficient, since
	2936	# we want to take their address.
	2937	AC_MSG_CHECKING(for chroot)
	2938	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=chroot]])],
	2939	[AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
	2940	AC_MSG_RESULT(yes)],
	2941	[AC_MSG_RESULT(no)
	2942	])
	2943	AC_MSG_CHECKING(for link)
	2944	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=link]])],
	2945	[AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
	2946	AC_MSG_RESULT(yes)],
	2947	[AC_MSG_RESULT(no)
	2948	])
	2949	AC_MSG_CHECKING(for symlink)
	2950	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=symlink]])],
	2951	[AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
	2952	AC_MSG_RESULT(yes)],
	2953	[AC_MSG_RESULT(no)
	2954	])
	2955	AC_MSG_CHECKING(for fchdir)
	2956	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fchdir]])],
	2957	[AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
	2958	AC_MSG_RESULT(yes)],
	2959	[AC_MSG_RESULT(no)
	2960	])
	2961	AC_MSG_CHECKING(for fsync)
	2962	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fsync]])],
	2963	[AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
	2964	AC_MSG_RESULT(yes)],
	2965	[AC_MSG_RESULT(no)
	2966	])
	2967	AC_MSG_CHECKING(for fdatasync)
	2968	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fdatasync]])],
	2969	[AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
	2970	AC_MSG_RESULT(yes)],
	2971	[AC_MSG_RESULT(no)
	2972	])
	2973	AC_MSG_CHECKING(for epoll)
	2974	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create]])],
	2975	[AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
	2976	AC_MSG_RESULT(yes)],
	2977	[AC_MSG_RESULT(no)
	2978	])
	2979	AC_MSG_CHECKING(for kqueue)
	2980	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	2981	#include <sys/types.h>
	2982	#include <sys/event.h>
	2983	]], [[int x=kqueue()]])],
	2984	[AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
	2985	AC_MSG_RESULT(yes)],
	2986	[AC_MSG_RESULT(no)
	2987	])
	2988	# On some systems (eg. FreeBSD 5), we would find a definition of the
	2989	# functions ctermid_r, setgroups in the library, but no prototype
	2990	# (e.g. because we use _XOPEN_SOURCE). See whether we can take their
	2991	# address to avoid compiler warnings and potential miscompilations
	2992	# because of the missing prototypes.
	2993
	2994	AC_MSG_CHECKING(for ctermid_r)
	2995	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	2996	#include <stdio.h>
	2997	]], [[void* p = ctermid_r]])],
	2998	[AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
	2999	AC_MSG_RESULT(yes)],
	3000	[AC_MSG_RESULT(no)
	3001	])
	3002
	3003	AC_CACHE_CHECK([for flock declaration], [ac_cv_flock_decl],
	3004	[AC_COMPILE_IFELSE(
	3005	[AC_LANG_PROGRAM(
	3006	[#include <sys/file.h>],
	3007	[void* p = flock]
	3008	)],
	3009	[ac_cv_flock_decl=yes],
	3010	[ac_cv_flock_decl=no]
	3011	)
	3012	])
	3013	if test "x${ac_cv_flock_decl}" = xyes; then
	3014	AC_CHECK_FUNCS(flock,,
	3015	AC_CHECK_LIB(bsd,flock,
	3016	[AC_DEFINE(HAVE_FLOCK)
	3017	AC_DEFINE(FLOCK_NEEDS_LIBBSD, 1, Define if flock needs to be linked with bsd library.)
	3018	])
	3019	)
	3020	fi
	3021
	3022	AC_MSG_CHECKING(for getpagesize)
	3023	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3024	#include <unistd.h>
	3025	]], [[void* p = getpagesize]])],
	3026	[AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
	3027	AC_MSG_RESULT(yes)],
	3028	[AC_MSG_RESULT(no)
	3029	])
	3030
	3031	AC_MSG_CHECKING(for broken unsetenv)
	3032	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3033	#include <stdlib.h>
	3034	]], [[int res = unsetenv("DUMMY")]])],
	3035	[AC_MSG_RESULT(no)],
	3036	[AC_DEFINE(HAVE_BROKEN_UNSETENV, 1, Define if `unsetenv` does not return an int.)
	3037	AC_MSG_RESULT(yes)
	3038	])
	3039
	3040	dnl check for true
	3041	AC_CHECK_PROGS(TRUE, true, /bin/true)
	3042
	3043	dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
	3044	dnl On others, they are in the C library, so we to take no action
	3045	AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
	3046	AC_CHECK_LIB(resolv, inet_aton)
	3047	)
	3048
	3049	# On Tru64, chflags seems to be present, but calling it will
	3050	# exit Python
	3051	AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl
	3052	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3053	#include <sys/stat.h>
	3054	#include <unistd.h>
	3055	int main(int argc, char*argv[])
	3056	{
	3057	if(chflags(argv[0], 0) != 0)
	3058	return 1;
	3059	return 0;
	3060	}
	3061	]])],
	3062	[ac_cv_have_chflags=yes],
	3063	[ac_cv_have_chflags=no],
	3064	[ac_cv_have_chflags=cross])
	3065	])
	3066	if test "$ac_cv_have_chflags" = cross ; then
	3067	AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"])
	3068	fi
	3069	if test "$ac_cv_have_chflags" = yes ; then
	3070	AC_DEFINE(HAVE_CHFLAGS, 1, [Define to 1 if you have the 'chflags' function.])
	3071	fi
	3072
	3073	AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl
	3074	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3075	#include <sys/stat.h>
	3076	#include <unistd.h>
	3077	int main(int argc, char*argv[])
	3078	{
	3079	if(lchflags(argv[0], 0) != 0)
	3080	return 1;
	3081	return 0;
	3082	}
	3083	]])],[ac_cv_have_lchflags=yes],[ac_cv_have_lchflags=no],[ac_cv_have_lchflags=cross])
	3084	])
	3085	if test "$ac_cv_have_lchflags" = cross ; then
	3086	AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"])
	3087	fi
	3088	if test "$ac_cv_have_lchflags" = yes ; then
	3089	AC_DEFINE(HAVE_LCHFLAGS, 1, [Define to 1 if you have the 'lchflags' function.])
	3090	fi
	3091
	3092	dnl Check if system zlib has *Copy() functions
	3093	dnl
	3094	dnl On MacOSX the linker will search for dylibs on the entire linker path
	3095	dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
	3096	dnl to revert to a more traditional unix behaviour and make it possible to
	3097	dnl override the system libz with a local static library of libz. Temporarily
	3098	dnl add that flag to our CFLAGS as well to ensure that we check the version
	3099	dnl of libz that will be used by setup.py.
	3100	dnl The -L/usr/local/lib is needed as wel to get the same compilation
	3101	dnl environment as setup.py (and leaving it out can cause configure to use the
	3102	dnl wrong version of the library)
	3103	case $ac_sys_system/$ac_sys_release in
	3104	Darwin/*)
	3105	_CUR_CFLAGS="${CFLAGS}"
	3106	_CUR_LDFLAGS="${LDFLAGS}"
	3107	CFLAGS="${CFLAGS} -Wl,-search_paths_first"
	3108	LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
	3109	;;
	3110	esac
	3111
	3112	AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, [Define if the zlib library has inflateCopy]))
	3113
	3114	case $ac_sys_system/$ac_sys_release in
	3115	Darwin/*)
	3116	CFLAGS="${_CUR_CFLAGS}"
	3117	LDFLAGS="${_CUR_LDFLAGS}"
	3118	;;
	3119	esac
	3120
	3121	AC_MSG_CHECKING(for hstrerror)
	3122	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	3123	#include <netdb.h>
	3124	]], [[void* p = hstrerror; hstrerror(0)]])],
	3125	[AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
	3126	AC_MSG_RESULT(yes)],
	3127	[AC_MSG_RESULT(no)
	3128	])
	3129
	3130	AC_MSG_CHECKING(for inet_aton)
	3131	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	3132	#include <sys/types.h>
	3133	#include <sys/socket.h>
	3134	#include <netinet/in.h>
	3135	#include <arpa/inet.h>
	3136	]], [[void* p = inet_aton;inet_aton(0,0)]])],
	3137	[AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
	3138	AC_MSG_RESULT(yes)],
	3139	[AC_MSG_RESULT(no)
	3140	])
	3141
	3142	AC_MSG_CHECKING(for inet_pton)
	3143	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3144	#include <sys/types.h>
	3145	#include <sys/socket.h>
	3146	#include <netinet/in.h>
	3147	#include <arpa/inet.h>
	3148	]], [[void* p = inet_pton]])],
	3149	[AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
	3150	AC_MSG_RESULT(yes)],
	3151	[AC_MSG_RESULT(no)
	3152	])
	3153
	3154	# On some systems, setgroups is in unistd.h, on others, in grp.h
	3155	AC_MSG_CHECKING(for setgroups)
	3156	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3157	#include <unistd.h>
	3158	#ifdef HAVE_GRP_H
	3159	#include <grp.h>
	3160	#endif
	3161	]], [[void* p = setgroups]])],
	3162	[AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
	3163	AC_MSG_RESULT(yes)],
	3164	[AC_MSG_RESULT(no)
	3165	])
	3166
	3167	# check for openpty and forkpty
	3168
	3169	AC_CHECK_FUNCS(openpty,,
	3170	AC_CHECK_LIB(util,openpty,
	3171	[AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
	3172	AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
	3173	)
	3174	)
	3175	AC_CHECK_FUNCS(forkpty,,
	3176	AC_CHECK_LIB(util,forkpty,
	3177	[AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
	3178	AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
	3179	)
	3180	)
	3181
	3182	# Stuff for expat.
	3183	AC_CHECK_FUNCS(memmove)
	3184
	3185	# check for long file support functions
	3186	AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
	3187
	3188	AC_REPLACE_FUNCS(dup2 getcwd strdup)
	3189	AC_CHECK_FUNCS(getpgrp,
	3190	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[getpgrp(0);]])],
	3191	[AC_DEFINE(GETPGRP_HAVE_ARG, 1, [Define if getpgrp() must be called as getpgrp(0).])],
	3192	[])
	3193	)
	3194	AC_CHECK_FUNCS(setpgrp,
	3195	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[setpgrp(0,0);]])],
	3196	[AC_DEFINE(SETPGRP_HAVE_ARG, 1, [Define if setpgrp() must be called as setpgrp(0, 0).])],
	3197	[])
	3198	)
	3199	AC_CHECK_FUNCS(gettimeofday,
	3200	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/time.h>]],
	3201	[[gettimeofday((struct timeval)0,(struct timezone)0);]])],
	3202	[],
	3203	[AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
	3204	[Define if gettimeofday() does not have second (timezone) argument
	3205	This is the case on Motorola V4 (R40V4.2)])
	3206	])
	3207	)
	3208
	3209	AC_MSG_CHECKING(for major, minor, and makedev)
	3210	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	3211	#if defined(MAJOR_IN_MKDEV)
	3212	#include <sys/mkdev.h>
	3213	#elif defined(MAJOR_IN_SYSMACROS)
	3214	#include <sys/sysmacros.h>
	3215	#else
	3216	#include <sys/types.h>
	3217	#endif
	3218	]], [[
	3219	makedev(major(0),minor(0));
	3220	]])],[
	3221	AC_DEFINE(HAVE_DEVICE_MACROS, 1,
	3222	[Define to 1 if you have the device macros.])
	3223	AC_MSG_RESULT(yes)
	3224	],[
	3225	AC_MSG_RESULT(no)
	3226	])
	3227
	3228	# On OSF/1 V5.1, getaddrinfo is available, but a define
	3229	# for [no]getaddrinfo in netdb.h.
	3230	AC_MSG_CHECKING(for getaddrinfo)
	3231	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	3232	#include <sys/types.h>
	3233	#include <sys/socket.h>
	3234	#include <netdb.h>
	3235	#include <stdio.h>
	3236	]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])],
	3237	[have_getaddrinfo=yes],
	3238	[have_getaddrinfo=no])
	3239	AC_MSG_RESULT($have_getaddrinfo)
	3240	if test $have_getaddrinfo = yes
	3241	then
	3242	AC_MSG_CHECKING(getaddrinfo bug)
	3243	AC_CACHE_VAL(ac_cv_buggy_getaddrinfo,
	3244	AC_RUN_IFELSE([AC_LANG_SOURCE([[[
	3245	#include <stdio.h>
	3246	#include <sys/types.h>
	3247	#include <netdb.h>
	3248	#include <string.h>
	3249	#include <sys/socket.h>
	3250	#include <netinet/in.h>
	3251
	3252	int main()
	3253	{
	3254	int passive, gaierr, inet4 = 0, inet6 = 0;
	3255	struct addrinfo hints, ai, aitop;
	3256	char straddr[INET6_ADDRSTRLEN], strport[16];
	3257
	3258	for (passive = 0; passive <= 1; passive++) {
	3259	memset(&hints, 0, sizeof(hints));
	3260	hints.ai_family = AF_UNSPEC;
	3261	hints.ai_flags = passive ? AI_PASSIVE : 0;
	3262	hints.ai_socktype = SOCK_STREAM;
	3263	hints.ai_protocol = IPPROTO_TCP;
	3264	if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
	3265	(void)gai_strerror(gaierr);
	3266	goto bad;
	3267	}
	3268	for (ai = aitop; ai; ai = ai->ai_next) {
	3269	if (ai->ai_addr == NULL \|\|
	3270	ai->ai_addrlen == 0 \|\|
	3271	getnameinfo(ai->ai_addr, ai->ai_addrlen,
	3272	straddr, sizeof(straddr), strport, sizeof(strport),
	3273	NI_NUMERICHOST\|NI_NUMERICSERV) != 0) {
	3274	goto bad;
	3275	}
	3276	switch (ai->ai_family) {
	3277	case AF_INET:
	3278	if (strcmp(strport, "54321") != 0) {
	3279	goto bad;
	3280	}
	3281	if (passive) {
	3282	if (strcmp(straddr, "0.0.0.0") != 0) {
	3283	goto bad;
	3284	}
	3285	} else {
	3286	if (strcmp(straddr, "127.0.0.1") != 0) {
	3287	goto bad;
	3288	}
	3289	}
	3290	inet4++;
	3291	break;
	3292	case AF_INET6:
	3293	if (strcmp(strport, "54321") != 0) {
	3294	goto bad;
	3295	}
	3296	if (passive) {
	3297	if (strcmp(straddr, "::") != 0) {
	3298	goto bad;
	3299	}
	3300	} else {
	3301	if (strcmp(straddr, "::1") != 0) {
	3302	goto bad;
	3303	}
	3304	}
	3305	inet6++;
	3306	break;
	3307	case AF_UNSPEC:
	3308	goto bad;
	3309	break;
	3310	default:
	3311	/* another family support? */
	3312	break;
	3313	}
	3314	}
	3315	}
	3316
	3317	if (!(inet4 == 0 \|\| inet4 == 2))
	3318	goto bad;
	3319	if (!(inet6 == 0 \|\| inet6 == 2))
	3320	goto bad;
	3321
	3322	if (aitop)
	3323	freeaddrinfo(aitop);
	3324	return 0;
	3325
	3326	bad:
	3327	if (aitop)
	3328	freeaddrinfo(aitop);
	3329	return 1;
	3330	}
	3331	]]])],
	3332	[ac_cv_buggy_getaddrinfo=no],
	3333	[ac_cv_buggy_getaddrinfo=yes],
	3334	[
	3335	if test "${enable_ipv6+set}" = set; then
	3336	ac_cv_buggy_getaddrinfo="no -- configured with --(en\|dis)able-ipv6"
	3337	else
	3338	ac_cv_buggy_getaddrinfo=yes
	3339	fi]))
	3340	fi
	3341
	3342	AC_MSG_RESULT($ac_cv_buggy_getaddrinfo)
	3343
	3344	if test $have_getaddrinfo = no -o "$ac_cv_buggy_getaddrinfo" = yes
	3345	then
	3346	if test $ipv6 = yes
	3347	then
	3348	echo 'Fatal: You must get working getaddrinfo() function.'
	3349	echo ' or you can specify "--disable-ipv6"'.
	3350	exit 1
	3351	fi
	3352	else
	3353	AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
	3354	fi
	3355
	3356	AC_CHECK_FUNCS(getnameinfo)
	3357
	3358	# checks for structures
	3359	AC_HEADER_TIME
	3360	AC_STRUCT_TM
	3361	AC_STRUCT_TIMEZONE
	3362	AC_CHECK_MEMBERS([struct stat.st_rdev])
	3363	AC_CHECK_MEMBERS([struct stat.st_blksize])
	3364	AC_CHECK_MEMBERS([struct stat.st_flags])
	3365	AC_CHECK_MEMBERS([struct stat.st_gen])
	3366	AC_CHECK_MEMBERS([struct stat.st_birthtime])
	3367	AC_STRUCT_ST_BLOCKS
	3368
	3369	AC_MSG_CHECKING(for time.h that defines altzone)
	3370	AC_CACHE_VAL(ac_cv_header_time_altzone,[
	3371	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[return altzone;]])],
	3372	[ac_cv_header_time_altzone=yes],
	3373	[ac_cv_header_time_altzone=no])
	3374	])
	3375	AC_MSG_RESULT($ac_cv_header_time_altzone)
	3376	if test $ac_cv_header_time_altzone = yes; then
	3377	AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
	3378	fi
	3379
	3380	was_it_defined=no
	3381	AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
	3382	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3383	#include <sys/types.h>
	3384	#include <sys/select.h>
	3385	#include <sys/time.h>
	3386	]], [[;]])],[
	3387	AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
	3388	[Define if you can safely include both <sys/select.h> and <sys/time.h>
	3389	(which you can't on SCO ODT 3.0).])
	3390	was_it_defined=yes
	3391	],[])
	3392	AC_MSG_RESULT($was_it_defined)
	3393
	3394	AC_MSG_CHECKING(for addrinfo)
	3395	AC_CACHE_VAL(ac_cv_struct_addrinfo,
	3396	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[struct addrinfo a]])],
	3397	[ac_cv_struct_addrinfo=yes],
	3398	[ac_cv_struct_addrinfo=no]))
	3399	AC_MSG_RESULT($ac_cv_struct_addrinfo)
	3400	if test $ac_cv_struct_addrinfo = yes; then
	3401	AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
	3402	fi
	3403
	3404	AC_MSG_CHECKING(for sockaddr_storage)
	3405	AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
	3406	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3407	# include <sys/types.h>
	3408	# include <sys/socket.h>]], [[struct sockaddr_storage s]])],
	3409	[ac_cv_struct_sockaddr_storage=yes],
	3410	[ac_cv_struct_sockaddr_storage=no]))
	3411	AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
	3412	if test $ac_cv_struct_sockaddr_storage = yes; then
	3413	AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
	3414	fi
	3415
	3416	# checks for compiler characteristics
	3417
	3418	AC_C_CHAR_UNSIGNED
	3419	AC_C_CONST
	3420
	3421	works=no
	3422	AC_MSG_CHECKING(for working volatile)
	3423	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[volatile int x; x = 0;]])],
	3424	[works=yes],
	3425	[AC_DEFINE(volatile, , [Define to empty if the keyword does not work.])]
	3426	)
	3427	AC_MSG_RESULT($works)
	3428
	3429	works=no
	3430	AC_MSG_CHECKING(for working signed char)
	3431	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char c;]])],
	3432	[works=yes],
	3433	[AC_DEFINE(signed, , [Define to empty if the keyword does not work.])]
	3434	)
	3435	AC_MSG_RESULT($works)
	3436
	3437	have_prototypes=no
	3438	AC_MSG_CHECKING(for prototypes)
	3439	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int foo(int x) { return 0; }]], [[return foo(10);]])],
	3440	[AC_DEFINE(HAVE_PROTOTYPES, 1,
	3441	[Define if your compiler supports function prototype])
	3442	have_prototypes=yes],
	3443	[]
	3444	)
	3445	AC_MSG_RESULT($have_prototypes)
	3446
	3447	works=no
	3448	AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
	3449	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3450	#include <stdarg.h>
	3451	int foo(int x, ...) {
	3452	va_list va;
	3453	va_start(va, x);
	3454	va_arg(va, int);
	3455	va_arg(va, char *);
	3456	va_arg(va, double);
	3457	return 0;
	3458	}
	3459	]], [[return foo(10, "", 3.14);]])],[
	3460	AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
	3461	[Define if your compiler supports variable length function prototypes
	3462	(e.g. void fprintf(FILE , char , ...);) and <stdarg.h>])
	3463	works=yes
	3464	],[])
	3465	AC_MSG_RESULT($works)
	3466
	3467	# check for socketpair
	3468	AC_MSG_CHECKING(for socketpair)
	3469	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3470	#include <sys/types.h>
	3471	#include <sys/socket.h>
	3472	]], [[void *x=socketpair]])],
	3473	[AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define if you have the 'socketpair' function.])
	3474	AC_MSG_RESULT(yes)],
	3475	[AC_MSG_RESULT(no)]
	3476	)
	3477
	3478	# check if sockaddr has sa_len member
	3479	AC_MSG_CHECKING(if sockaddr has sa_len member)
	3480	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
	3481	#include <sys/socket.h>]], [[struct sockaddr x;
	3482	x.sa_len = 0;]])],
	3483	[AC_MSG_RESULT(yes)
	3484	AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member])],
	3485	[AC_MSG_RESULT(no)]
	3486	)
	3487
	3488	va_list_is_array=no
	3489	AC_MSG_CHECKING(whether va_list is an array)
	3490	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3491	#ifdef HAVE_STDARG_PROTOTYPES
	3492	#include <stdarg.h>
	3493	#else
	3494	#include <varargs.h>
	3495	#endif
	3496	]], [[va_list list1, list2; list1 = list2;]])],[],[
	3497	AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
	3498	va_list_is_array=yes
	3499	])
	3500	AC_MSG_RESULT($va_list_is_array)
	3501
	3502	# sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
	3503	AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
	3504	[Define this if you have some version of gethostbyname_r()])
	3505
	3506	AC_CHECK_FUNC(gethostbyname_r, [
	3507	AC_DEFINE(HAVE_GETHOSTBYNAME_R)
	3508	AC_MSG_CHECKING([gethostbyname_r with 6 args])
	3509	OLD_CFLAGS=$CFLAGS
	3510	CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
	3511	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3512	# include <netdb.h>
	3513	]], [[
	3514	char *name;
	3515	struct hostent he, res;
	3516	char buffer[2048];
	3517	int buflen = 2048;
	3518	int h_errnop;
	3519
	3520	(void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
	3521	]])],[
	3522	AC_DEFINE(HAVE_GETHOSTBYNAME_R)
	3523	AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
	3524	[Define this if you have the 6-arg version of gethostbyname_r().])
	3525	AC_MSG_RESULT(yes)
	3526	],[
	3527	AC_MSG_RESULT(no)
	3528	AC_MSG_CHECKING([gethostbyname_r with 5 args])
	3529	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3530	# include <netdb.h>
	3531	]], [[
	3532	char *name;
	3533	struct hostent *he;
	3534	char buffer[2048];
	3535	int buflen = 2048;
	3536	int h_errnop;
	3537
	3538	(void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
	3539	]])],
	3540	[
	3541	AC_DEFINE(HAVE_GETHOSTBYNAME_R)
	3542	AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
	3543	[Define this if you have the 5-arg version of gethostbyname_r().])
	3544	AC_MSG_RESULT(yes)
	3545	], [
	3546	AC_MSG_RESULT(no)
	3547	AC_MSG_CHECKING([gethostbyname_r with 3 args])
	3548	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3549	# include <netdb.h>
	3550	]], [[
	3551	char *name;
	3552	struct hostent *he;
	3553	struct hostent_data data;
	3554
	3555	(void) gethostbyname_r(name, he, &data);
	3556	]])],
	3557	[
	3558	AC_DEFINE(HAVE_GETHOSTBYNAME_R)
	3559	AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
	3560	[Define this if you have the 3-arg version of gethostbyname_r().])
	3561	AC_MSG_RESULT(yes)
	3562	], [
	3563	AC_MSG_RESULT(no)
	3564	])
	3565	])
	3566	])
	3567	CFLAGS=$OLD_CFLAGS
	3568	], [
	3569	AC_CHECK_FUNCS(gethostbyname)
	3570	])
	3571	AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
	3572	AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
	3573	AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
	3574	AC_SUBST(HAVE_GETHOSTBYNAME_R)
	3575	AC_SUBST(HAVE_GETHOSTBYNAME)
	3576
	3577	# checks for system services
	3578	# (none yet)
	3579
	3580	# Linux requires this for correct f.p. operations
	3581	AC_CHECK_FUNC(__fpu_control,
	3582	[],
	3583	[AC_CHECK_LIB(ieee, __fpu_control)
	3584	])
	3585
	3586	# Check for --with-fpectl
	3587	AC_MSG_CHECKING(for --with-fpectl)
	3588	AC_ARG_WITH(fpectl,
	3589	AS_HELP_STRING([--with-fpectl], [enable SIGFPE catching]),
	3590	[
	3591	if test "$withval" != no
	3592	then
	3593	AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
	3594	[Define if you want SIGFPE handled (see Include/pyfpe.h).])
	3595	AC_MSG_RESULT(yes)
	3596	else AC_MSG_RESULT(no)
	3597	fi],
	3598	[AC_MSG_RESULT(no)])
	3599
	3600	# check for --with-libm=...
	3601	AC_SUBST(LIBM)
	3602	case $ac_sys_system in
	3603	Darwin) ;;
	3604	BeOS) ;;
	3605	*) LIBM=-lm
	3606	esac
	3607	AC_MSG_CHECKING(for --with-libm=STRING)
	3608	AC_ARG_WITH(libm,
	3609	AS_HELP_STRING([--with-libm=STRING], [math library]),
	3610	[
	3611	if test "$withval" = no
	3612	then LIBM=
	3613	AC_MSG_RESULT(force LIBM empty)
	3614	elif test "$withval" != yes
	3615	then LIBM=$withval
	3616	AC_MSG_RESULT(set LIBM="$withval")
	3617	else AC_MSG_ERROR([proper usage is --with-libm=STRING])
	3618	fi],
	3619	[AC_MSG_RESULT(default LIBM="$LIBM")])
	3620
	3621	# check for --with-libc=...
	3622	AC_SUBST(LIBC)
	3623	AC_MSG_CHECKING(for --with-libc=STRING)
	3624	AC_ARG_WITH(libc,
	3625	AS_HELP_STRING([--with-libc=STRING], [C library]),
	3626	[
	3627	if test "$withval" = no
	3628	then LIBC=
	3629	AC_MSG_RESULT(force LIBC empty)
	3630	elif test "$withval" != yes
	3631	then LIBC=$withval
	3632	AC_MSG_RESULT(set LIBC="$withval")
	3633	else AC_MSG_ERROR([proper usage is --with-libc=STRING])
	3634	fi],
	3635	[AC_MSG_RESULT(default LIBC="$LIBC")])
	3636
	3637	# **************************************************
	3638	# * Check for various properties of floating point *
	3639	# **************************************************
	3640
	3641	AC_MSG_CHECKING(whether C doubles are little-endian IEEE 754 binary64)
	3642	AC_CACHE_VAL(ac_cv_little_endian_double, [
	3643	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3644	#include <string.h>
	3645	int main() {
	3646	double x = 9006104071832581.0;
	3647	if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
	3648	return 0;
	3649	else
	3650	return 1;
	3651	}
	3652	]])],
	3653	[ac_cv_little_endian_double=yes],
	3654	[ac_cv_little_endian_double=no],
	3655	[ac_cv_little_endian_double=no])])
	3656	AC_MSG_RESULT($ac_cv_little_endian_double)
	3657	if test "$ac_cv_little_endian_double" = yes
	3658	then
	3659	AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1,
	3660	[Define if C doubles are 64-bit IEEE 754 binary format, stored
	3661	with the least significant byte first])
	3662	fi
	3663
	3664	AC_MSG_CHECKING(whether C doubles are big-endian IEEE 754 binary64)
	3665	AC_CACHE_VAL(ac_cv_big_endian_double, [
	3666	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3667	#include <string.h>
	3668	int main() {
	3669	double x = 9006104071832581.0;
	3670	if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
	3671	return 0;
	3672	else
	3673	return 1;
	3674	}
	3675	]])],
	3676	[ac_cv_big_endian_double=yes],
	3677	[ac_cv_big_endian_double=no],
	3678	[ac_cv_big_endian_double=no])])
	3679	AC_MSG_RESULT($ac_cv_big_endian_double)
	3680	if test "$ac_cv_big_endian_double" = yes
	3681	then
	3682	AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1,
	3683	[Define if C doubles are 64-bit IEEE 754 binary format, stored
	3684	with the most significant byte first])
	3685	fi
	3686
	3687	# Some ARM platforms use a mixed-endian representation for doubles.
	3688	# While Python doesn't currently have full support for these platforms
	3689	# (see e.g., issue 1762561), we can at least make sure that float <-> string
	3690	# conversions work.
	3691	AC_MSG_CHECKING(whether C doubles are ARM mixed-endian IEEE 754 binary64)
	3692	AC_CACHE_VAL(ac_cv_mixed_endian_double, [
	3693	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3694	#include <string.h>
	3695	int main() {
	3696	double x = 9006104071832581.0;
	3697	if (memcmp(&x, "\x01\xff\x3f\x43\x05\x04\x03\x02", 8) == 0)
	3698	return 0;
	3699	else
	3700	return 1;
	3701	}
	3702	]])],
	3703	[ac_cv_mixed_endian_double=yes],
	3704	[ac_cv_mixed_endian_double=no],
	3705	[ac_cv_mixed_endian_double=no])])
	3706	AC_MSG_RESULT($ac_cv_mixed_endian_double)
	3707	if test "$ac_cv_mixed_endian_double" = yes
	3708	then
	3709	AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1,
	3710	[Define if C doubles are 64-bit IEEE 754 binary format, stored
	3711	in ARM mixed-endian order (byte order 45670123)])
	3712	fi
	3713
	3714	# The short float repr introduced in Python 3.1 requires the
	3715	# correctly-rounded string <-> double conversion functions from
	3716	# Python/dtoa.c, which in turn require that the FPU uses 53-bit
	3717	# rounding; this is a problem on x86, where the x87 FPU has a default
	3718	# rounding precision of 64 bits. For gcc/x86, we can fix this by
	3719	# using inline assembler to get and set the x87 FPU control word.
	3720
	3721	# This inline assembler syntax may also work for suncc and icc,
	3722	# so we try it on all platforms.
	3723
	3724	AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word)
	3725	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
	3726	unsigned short cw;
	3727	__asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
	3728	__asm__ __volatile__ ("fldcw %0" : : "m" (cw));
	3729	]])],[have_gcc_asm_for_x87=yes],[have_gcc_asm_for_x87=no])
	3730	AC_MSG_RESULT($have_gcc_asm_for_x87)
	3731	if test "$have_gcc_asm_for_x87" = yes
	3732	then
	3733	AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1,
	3734	[Define if we can use gcc inline assembler to get and set x87 control word])
	3735	fi
	3736
	3737	# Detect whether system arithmetic is subject to x87-style double
	3738	# rounding issues. The result of this test has little meaning on non
	3739	# IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
	3740	# mode is round-to-nearest and double rounding issues are present, and
	3741	# 0 otherwise. See http://bugs.python.org/issue2937 for more info.
	3742	AC_MSG_CHECKING(for x87-style double rounding)
	3743	# $BASECFLAGS may affect the result
	3744	ac_save_cc="$CC"
	3745	CC="$CC $BASECFLAGS"
	3746	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3747	#include <stdlib.h>
	3748	#include <math.h>
	3749	int main() {
	3750	volatile double x, y, z;
	3751	/* 1./(1-2-53) -> 1+2-52 (correct), 1.0 (double rounding) */
	3752	x = 0.99999999999999989; /* 1-2*-53 /
	3753	y = 1./x;
	3754	if (y != 1.)
	3755	exit(0);
	3756	/* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
	3757	x = 1e16;
	3758	y = 2.99999;
	3759	z = x + y;
	3760	if (z != 1e16+4.)
	3761	exit(0);
	3762	/* both tests show evidence of double rounding */
	3763	exit(1);
	3764	}
	3765	]])],
	3766	[ac_cv_x87_double_rounding=no],
	3767	[ac_cv_x87_double_rounding=yes],
	3768	[ac_cv_x87_double_rounding=no])
	3769	CC="$ac_save_cc"
	3770	AC_MSG_RESULT($ac_cv_x87_double_rounding)
	3771	if test "$ac_cv_x87_double_rounding" = yes
	3772	then
	3773	AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
	3774	[Define if arithmetic is subject to x87-style double rounding issue])
	3775	fi
	3776
	3777	# ************************************
	3778	# * Check for mathematical functions *
	3779	# ************************************
	3780
	3781	LIBS_SAVE=$LIBS
	3782	LIBS="$LIBS $LIBM"
	3783
	3784	# On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
	3785	# -0. on some architectures.
	3786	AC_MSG_CHECKING(whether tanh preserves the sign of zero)
	3787	AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
	3788	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3789	#include <math.h>
	3790	#include <stdlib.h>
	3791	int main() {
	3792	/* return 0 if either negative zeros don't exist
	3793	on this platform or if negative zeros exist
	3794	and tanh(-0.) == -0. */
	3795	if (atan2(0., -1.) == atan2(-0., -1.) \|\|
	3796	atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
	3797	else exit(1);
	3798	}
	3799	]])],
	3800	[ac_cv_tanh_preserves_zero_sign=yes],
	3801	[ac_cv_tanh_preserves_zero_sign=no],
	3802	[ac_cv_tanh_preserves_zero_sign=no])])
	3803	AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
	3804	if test "$ac_cv_tanh_preserves_zero_sign" = yes
	3805	then
	3806	AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
	3807	[Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
	3808	fi
	3809
	3810	AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma])
	3811	AC_CHECK_FUNCS([hypot lgamma log1p round tgamma])
	3812	AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
	3813
	3814	LIBS=$LIBS_SAVE
	3815
	3816	# For multiprocessing module, check that sem_open
	3817	# actually works. For FreeBSD versions <= 7.2,
	3818	# the kernel module that provides POSIX semaphores
	3819	# isn't loaded by default, so an attempt to call
	3820	# sem_open results in a 'Signal 12' error.
	3821	AC_MSG_CHECKING(whether POSIX semaphores are enabled)
	3822	AC_CACHE_VAL(ac_cv_posix_semaphores_enabled,
	3823	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3824	#include <unistd.h>
	3825	#include <fcntl.h>
	3826	#include <stdio.h>
	3827	#include <semaphore.h>
	3828	#include <sys/stat.h>
	3829
	3830	int main(void) {
	3831	sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR\|S_IWUSR, 0);
	3832	if (a == SEM_FAILED) {
	3833	perror("sem_open");
	3834	return 1;
	3835	}
	3836	sem_close(a);
	3837	sem_unlink("/autoconf");
	3838	return 0;
	3839	}
	3840	]])],
	3841	[ac_cv_posix_semaphores_enabled=yes],
	3842	[ac_cv_posix_semaphores_enabled=no],
	3843	[ac_cv_posix_semaphores_enabled=yes])
	3844	)
	3845	AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
	3846	if test $ac_cv_posix_semaphores_enabled = no
	3847	then
	3848	AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1,
	3849	[Define if POSIX semaphores aren't enabled on your system])
	3850	fi
	3851
	3852	# Multiprocessing check for broken sem_getvalue
	3853	AC_MSG_CHECKING(for broken sem_getvalue)
	3854	AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
	3855	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3856	#include <unistd.h>
	3857	#include <fcntl.h>
	3858	#include <stdio.h>
	3859	#include <semaphore.h>
	3860	#include <sys/stat.h>
	3861
	3862	int main(void){
	3863	sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR\|S_IWUSR, 0);
	3864	int count;
	3865	int res;
	3866	if(a==SEM_FAILED){
	3867	perror("sem_open");
	3868	return 1;
	3869
	3870	}
	3871	res = sem_getvalue(a, &count);
	3872	sem_close(a);
	3873	sem_unlink("/autocftw");
	3874	return res==-1 ? 1 : 0;
	3875	}
	3876	]])],
	3877	[ac_cv_broken_sem_getvalue=no],
	3878	[ac_cv_broken_sem_getvalue=yes],
	3879	[ac_cv_broken_sem_getvalue=yes])
	3880	)
	3881	AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
	3882	if test $ac_cv_broken_sem_getvalue = yes
	3883	then
	3884	AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
	3885	[define to 1 if your sem_getvalue is broken.])
	3886	fi
	3887
	3888	# determine what size digit to use for Python's longs
	3889	AC_MSG_CHECKING([digit size for Python's longs])
	3890	AC_ARG_ENABLE(big-digits,
	3891	AS_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
	3892	[case $enable_big_digits in
	3893	yes)
	3894	enable_big_digits=30 ;;
	3895	no)
	3896	enable_big_digits=15 ;;
	3897	[15\|30])
	3898	;;
	3899	*)
	3900	AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
	3901	esac
	3902	AC_MSG_RESULT($enable_big_digits)
	3903	AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
	3904	],
	3905	[AC_MSG_RESULT(no value specified)])
	3906
	3907	# check for wchar.h
	3908	AC_CHECK_HEADER(wchar.h, [
	3909	AC_DEFINE(HAVE_WCHAR_H, 1,
	3910	[Define if the compiler provides a wchar.h header file.])
	3911	wchar_h="yes"
	3912	],
	3913	wchar_h="no"
	3914	)
	3915
	3916	# determine wchar_t size
	3917	if test "$wchar_h" = yes
	3918	then
	3919	AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
	3920	fi
	3921
	3922	AC_MSG_CHECKING(for UCS-4 tcl)
	3923	have_ucs4_tcl=no
	3924	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	3925	#include <tcl.h>
	3926	#if TCL_UTF_MAX != 6
	3927	# error "NOT UCS4_TCL"
	3928	#endif]], [[]])],[
	3929	AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
	3930	have_ucs4_tcl=yes
	3931	],[])
	3932	AC_MSG_RESULT($have_ucs4_tcl)
	3933
	3934	# check whether wchar_t is signed or not
	3935	if test "$wchar_h" = yes
	3936	then
	3937	# check whether wchar_t is signed or not
	3938	AC_MSG_CHECKING(whether wchar_t is signed)
	3939	AC_CACHE_VAL(ac_cv_wchar_t_signed, [
	3940	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	3941	#include <wchar.h>
	3942	int main()
	3943	{
	3944	/* Success: exit code 0 */
	3945	exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
	3946	}
	3947	]])],
	3948	[ac_cv_wchar_t_signed=yes],
	3949	[ac_cv_wchar_t_signed=no],
	3950	[ac_cv_wchar_t_signed=yes])])
	3951	AC_MSG_RESULT($ac_cv_wchar_t_signed)
	3952	fi
	3953
	3954	AC_MSG_CHECKING(what type to use for unicode)
	3955	dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
	3956	AC_ARG_ENABLE(unicode,
	3957	AS_HELP_STRING([--enable-unicode@<:@=ucs@<:@24@:>@@:>@], [Enable Unicode strings (default is ucs2)]),
	3958	[],
	3959	[enable_unicode=yes])
	3960
	3961	if test $enable_unicode = yes
	3962	then
	3963	# Without any arguments, Py_UNICODE defaults to two-byte mode
	3964	case "$have_ucs4_tcl" in
	3965	yes) enable_unicode="ucs4"
	3966	;;
	3967	*) enable_unicode="ucs2"
	3968	;;
	3969	esac
	3970	fi
	3971
	3972	AH_TEMPLATE(Py_UNICODE_SIZE,
	3973	[Define as the size of the unicode type.])
	3974	case "$enable_unicode" in
	3975	ucs2) unicode_size="2"
	3976	AC_DEFINE(Py_UNICODE_SIZE,2)
	3977	;;
	3978	ucs4) unicode_size="4"
	3979	AC_DEFINE(Py_UNICODE_SIZE,4)
	3980	;;
	3981	no) ;; # To allow --disable-unicode
	3982	*) AC_MSG_ERROR([invalid value for --enable-unicode. Use either ucs2 or ucs4 (lowercase).]) ;;
	3983	esac
	3984
	3985	AH_TEMPLATE(PY_UNICODE_TYPE,
	3986	[Define as the integral type used for Unicode representation.])
	3987
	3988	AC_SUBST(UNICODE_OBJS)
	3989	if test "$enable_unicode" = "no"
	3990	then
	3991	UNICODE_OBJS=""
	3992	AC_MSG_RESULT(not used)
	3993	else
	3994	UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
	3995	AC_DEFINE(Py_USING_UNICODE, 1,
	3996	[Define if you want to have a Unicode type.])
	3997
	3998	# wchar_t is only usable if it maps to an unsigned type
	3999	if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
	4000	-a "$ac_cv_wchar_t_signed" = "no"
	4001	then
	4002	PY_UNICODE_TYPE="wchar_t"
	4003	AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
	4004	[Define if you have a useable wchar_t type defined in wchar.h; useable
	4005	means wchar_t must be an unsigned type with at least 16 bits. (see
	4006	Include/unicodeobject.h).])
	4007	AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
	4008	elif test "$ac_cv_sizeof_short" = "$unicode_size"
	4009	then
	4010	PY_UNICODE_TYPE="unsigned short"
	4011	AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
	4012	elif test "$ac_cv_sizeof_long" = "$unicode_size"
	4013	then
	4014	PY_UNICODE_TYPE="unsigned long"
	4015	AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
	4016	else
	4017	PY_UNICODE_TYPE="no type found"
	4018	fi
	4019	AC_MSG_RESULT($PY_UNICODE_TYPE)
	4020	fi
	4021
	4022	# check for endianness
	4023	AC_C_BIGENDIAN
	4024
	4025	# Check whether right shifting a negative integer extends the sign bit
	4026	# or fills with zeros (like the Cray J90, according to Tim Peters).
	4027	AC_MSG_CHECKING(whether right shift extends the sign bit)
	4028	AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
	4029	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	4030	int main()
	4031	{
	4032	exit(((-1)>>3 == -1) ? 0 : 1);
	4033	}
	4034	]])],
	4035	[ac_cv_rshift_extends_sign=yes],
	4036	[ac_cv_rshift_extends_sign=no],
	4037	[ac_cv_rshift_extends_sign=yes])])
	4038	AC_MSG_RESULT($ac_cv_rshift_extends_sign)
	4039	if test "$ac_cv_rshift_extends_sign" = no
	4040	then
	4041	AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
	4042	[Define if i>>j for signed int i does not extend the sign bit
	4043	when i < 0])
	4044	fi
	4045
	4046	# check for getc_unlocked and related locking functions
	4047	AC_MSG_CHECKING(for getc_unlocked() and friends)
	4048	AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
	4049	AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[
	4050	FILE *f = fopen("/dev/null", "r");
	4051	flockfile(f);
	4052	getc_unlocked(f);
	4053	funlockfile(f);
	4054	]])],[ac_cv_have_getc_unlocked=yes],[ac_cv_have_getc_unlocked=no])])
	4055	AC_MSG_RESULT($ac_cv_have_getc_unlocked)
	4056	if test "$ac_cv_have_getc_unlocked" = yes
	4057	then
	4058	AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
	4059	[Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
	4060	fi
	4061
	4062	# check where readline lives
	4063	# save the value of LIBS so we don't actually link Python with readline
	4064	LIBS_no_readline=$LIBS
	4065
	4066	# On some systems we need to link readline to a termcap compatible
	4067	# library. NOTE: Keep the precedence of listed libraries synchronised
	4068	# with setup.py.
	4069	py_cv_lib_readline=no
	4070	AC_MSG_CHECKING([how to link readline libs])
	4071	for py_libtermcap in "" ncursesw ncurses curses termcap; do
	4072	if test -z "$py_libtermcap"; then
	4073	READLINE_LIBS="-lreadline"
	4074	else
	4075	READLINE_LIBS="-lreadline -l$py_libtermcap"
	4076	fi
	4077	LIBS="$READLINE_LIBS $LIBS_no_readline"
	4078	AC_LINK_IFELSE(
	4079	[AC_LANG_CALL([],[readline])],
	4080	[py_cv_lib_readline=yes])
	4081	if test $py_cv_lib_readline = yes; then
	4082	break
	4083	fi
	4084	done
	4085	# Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
	4086	#AC_SUBST([READLINE_LIBS])
	4087	if test $py_cv_lib_readline = no; then
	4088	AC_MSG_RESULT([none])
	4089	else
	4090	AC_MSG_RESULT([$READLINE_LIBS])
	4091	AC_DEFINE(HAVE_LIBREADLINE, 1,
	4092	[Define if you have the readline library (-lreadline).])
	4093	fi
	4094
	4095	# check for readline 2.1
	4096	AC_CHECK_LIB(readline, rl_callback_handler_install,
	4097	AC_DEFINE(HAVE_RL_CALLBACK, 1,
	4098	[Define if you have readline 2.1]), ,$READLINE_LIBS)
	4099
	4100	# check for readline 2.2
	4101	AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
	4102	[have_readline=yes],
	4103	[have_readline=no]
	4104	)
	4105	if test $have_readline = yes
	4106	then
	4107	AC_EGREP_HEADER([extern int rl_completion_append_character;],
	4108	[readline/readline.h],
	4109	AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
	4110	[Define if you have readline 2.2]), )
	4111	AC_EGREP_HEADER([extern int rl_completion_suppress_append;],
	4112	[readline/readline.h],
	4113	AC_DEFINE(HAVE_RL_COMPLETION_SUPPRESS_APPEND, 1,
	4114	[Define if you have rl_completion_suppress_append]), )
	4115	fi
	4116
	4117	# check for readline 4.0
	4118	AC_CHECK_LIB(readline, rl_pre_input_hook,
	4119	AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
	4120	[Define if you have readline 4.0]), ,$READLINE_LIBS)
	4121
	4122	# also in 4.0
	4123	AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
	4124	AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
	4125	[Define if you have readline 4.0]), ,$READLINE_LIBS)
	4126
	4127	# check for readline 4.2
	4128	AC_CHECK_LIB(readline, rl_completion_matches,
	4129	AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
	4130	[Define if you have readline 4.2]), ,$READLINE_LIBS)
	4131
	4132	# also in readline 4.2
	4133	AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
	4134	[have_readline=yes],
	4135	[have_readline=no]
	4136	)
	4137	if test $have_readline = yes
	4138	then
	4139	AC_EGREP_HEADER([extern int rl_catch_signals;],
	4140	[readline/readline.h],
	4141	AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
	4142	[Define if you can turn off readline's signal handling.]), )
	4143	fi
	4144
	4145	# End of readline checks: restore LIBS
	4146	LIBS=$LIBS_no_readline
	4147
	4148	AC_MSG_CHECKING(for broken nice())
	4149	AC_CACHE_VAL(ac_cv_broken_nice, [
	4150	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	4151	int main()
	4152	{
	4153	int val1 = nice(1);
	4154	if (val1 != -1 && val1 == nice(2))
	4155	exit(0);
	4156	exit(1);
	4157	}
	4158	]])],
	4159	[ac_cv_broken_nice=yes],
	4160	[ac_cv_broken_nice=no],
	4161	[ac_cv_broken_nice=no])])
	4162	AC_MSG_RESULT($ac_cv_broken_nice)
	4163	if test "$ac_cv_broken_nice" = yes
	4164	then
	4165	AC_DEFINE(HAVE_BROKEN_NICE, 1,
	4166	[Define if nice() returns success/failure instead of the new priority.])
	4167	fi
	4168
	4169	AC_MSG_CHECKING(for broken poll())
	4170	AC_CACHE_VAL(ac_cv_broken_poll,
	4171	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	4172	#include <poll.h>
	4173
	4174	int main()
	4175	{
	4176	struct pollfd poll_struct = { 42, POLLIN\|POLLPRI\|POLLOUT, 0 };
	4177	int poll_test;
	4178
	4179	close (42);
	4180
	4181	poll_test = poll(&poll_struct, 1, 0);
	4182	if (poll_test < 0)
	4183	return 0;
	4184	else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
	4185	return 0;
	4186	else
	4187	return 1;
	4188	}
	4189	]])],
	4190	[ac_cv_broken_poll=yes],
	4191	[ac_cv_broken_poll=no],
	4192	[ac_cv_broken_poll=no]))
	4193	AC_MSG_RESULT($ac_cv_broken_poll)
	4194	if test "$ac_cv_broken_poll" = yes
	4195	then
	4196	AC_DEFINE(HAVE_BROKEN_POLL, 1,
	4197	[Define if poll() sets errno on invalid file descriptors.])
	4198	fi
	4199
	4200	# Before we can test tzset, we need to check if struct tm has a tm_zone
	4201	# (which is not required by ISO C or UNIX spec) and/or if we support
	4202	# tzname[]
	4203	AC_STRUCT_TIMEZONE
	4204
	4205	# check tzset(3) exists and works like we expect it to
	4206	AC_MSG_CHECKING(for working tzset())
	4207	AC_CACHE_VAL(ac_cv_working_tzset, [
	4208	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	4209	#include <stdlib.h>
	4210	#include <time.h>
	4211	#include <string.h>
	4212
	4213	#if HAVE_TZNAME
	4214	extern char *tzname[];
	4215	#endif
	4216
	4217	int main()
	4218	{
	4219	/* Note that we need to ensure that not only does tzset(3)
	4220	do 'something' with localtime, but it works as documented
	4221	in the library reference and as expected by the test suite.
	4222	This includes making sure that tzname is set properly if
	4223	tm->tm_zone does not exist since it is the alternative way
	4224	of getting timezone info.
	4225
	4226	Red Hat 6.2 doesn't understand the southern hemisphere
	4227	after New Year's Day.
	4228	*/
	4229
	4230	time_t groundhogday = 1044144000; /* GMT-based */
	4231	time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
	4232
	4233	putenv("TZ=UTC+0");
	4234	tzset();
	4235	if (localtime(&groundhogday)->tm_hour != 0)
	4236	exit(1);
	4237	#if HAVE_TZNAME
	4238	/* For UTC, tzname[1] is sometimes "", sometimes " " */
	4239	if (strcmp(tzname[0], "UTC") \|\|
	4240	(tzname[1][0] != 0 && tzname[1][0] != ' '))
	4241	exit(1);
	4242	#endif
	4243
	4244	putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
	4245	tzset();
	4246	if (localtime(&groundhogday)->tm_hour != 19)
	4247	exit(1);
	4248	#if HAVE_TZNAME
	4249	if (strcmp(tzname[0], "EST") \|\| strcmp(tzname[1], "EDT"))
	4250	exit(1);
	4251	#endif
	4252
	4253	putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
	4254	tzset();
	4255	if (localtime(&groundhogday)->tm_hour != 11)
	4256	exit(1);
	4257	#if HAVE_TZNAME
	4258	if (strcmp(tzname[0], "AEST") \|\| strcmp(tzname[1], "AEDT"))
	4259	exit(1);
	4260	#endif
	4261
	4262	#if HAVE_STRUCT_TM_TM_ZONE
	4263	if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
	4264	exit(1);
	4265	if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
	4266	exit(1);
	4267	#endif
	4268
	4269	exit(0);
	4270	}
	4271	]])],
	4272	[ac_cv_working_tzset=yes],
	4273	[ac_cv_working_tzset=no],
	4274	[ac_cv_working_tzset=no])])
	4275	AC_MSG_RESULT($ac_cv_working_tzset)
	4276	if test "$ac_cv_working_tzset" = yes
	4277	then
	4278	AC_DEFINE(HAVE_WORKING_TZSET, 1,
	4279	[Define if tzset() actually switches the local timezone in a meaningful way.])
	4280	fi
	4281
	4282	# Look for subsecond timestamps in struct stat
	4283	AC_MSG_CHECKING(for tv_nsec in struct stat)
	4284	AC_CACHE_VAL(ac_cv_stat_tv_nsec,
	4285	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
	4286	struct stat st;
	4287	st.st_mtim.tv_nsec = 1;
	4288	]])],
	4289	[ac_cv_stat_tv_nsec=yes],
	4290	[ac_cv_stat_tv_nsec=no]))
	4291	AC_MSG_RESULT($ac_cv_stat_tv_nsec)
	4292	if test "$ac_cv_stat_tv_nsec" = yes
	4293	then
	4294	AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
	4295	[Define if you have struct stat.st_mtim.tv_nsec])
	4296	fi
	4297
	4298	# Look for BSD style subsecond timestamps in struct stat
	4299	AC_MSG_CHECKING(for tv_nsec2 in struct stat)
	4300	AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
	4301	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
	4302	struct stat st;
	4303	st.st_mtimespec.tv_nsec = 1;
	4304	]])],
	4305	[ac_cv_stat_tv_nsec2=yes],
	4306	[ac_cv_stat_tv_nsec2=no]))
	4307	AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
	4308	if test "$ac_cv_stat_tv_nsec2" = yes
	4309	then
	4310	AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
	4311	[Define if you have struct stat.st_mtimensec])
	4312	fi
	4313
	4314	# On HP/UX 11.0, mvwdelch is a block with a return statement
	4315	AC_MSG_CHECKING(whether mvwdelch is an expression)
	4316	AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
	4317	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
	4318	int rtn;
	4319	rtn = mvwdelch(0,0,0);
	4320	]])],
	4321	[ac_cv_mvwdelch_is_expression=yes],
	4322	[ac_cv_mvwdelch_is_expression=no]))
	4323	AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
	4324
	4325	if test "$ac_cv_mvwdelch_is_expression" = yes
	4326	then
	4327	AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
	4328	[Define if mvwdelch in curses.h is an expression.])
	4329	fi
	4330
	4331	AC_MSG_CHECKING(whether WINDOW has _flags)
	4332	AC_CACHE_VAL(ac_cv_window_has_flags,
	4333	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
	4334	WINDOW *w;
	4335	w->_flags = 0;
	4336	]])],
	4337	[ac_cv_window_has_flags=yes],
	4338	[ac_cv_window_has_flags=no]))
	4339	AC_MSG_RESULT($ac_cv_window_has_flags)
	4340
	4341
	4342	if test "$ac_cv_window_has_flags" = yes
	4343	then
	4344	AC_DEFINE(WINDOW_HAS_FLAGS, 1,
	4345	[Define if WINDOW in curses.h offers a field _flags.])
	4346	fi
	4347
	4348	AC_MSG_CHECKING(for is_term_resized)
	4349	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=is_term_resized]])],
	4350	[AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
	4351	AC_MSG_RESULT(yes)],
	4352	[AC_MSG_RESULT(no)]
	4353	)
	4354
	4355	AC_MSG_CHECKING(for resize_term)
	4356	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resize_term]])],
	4357	[AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
	4358	AC_MSG_RESULT(yes)],
	4359	[AC_MSG_RESULT(no)]
	4360	)
	4361
	4362	AC_MSG_CHECKING(for resizeterm)
	4363	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resizeterm]])],
	4364	[AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
	4365	AC_MSG_RESULT(yes)],
	4366	[AC_MSG_RESULT(no)]
	4367	)
	4368
	4369	AC_MSG_NOTICE([checking for device files])
	4370
	4371	dnl NOTE: Inform user how to proceed with files when cross compiling.
	4372	if test "x$cross_compiling" = xyes; then
	4373	if test "${ac_cv_file__dev_ptmx+set}" != set; then
	4374	AC_MSG_CHECKING([for /dev/ptmx])
	4375	AC_MSG_RESULT([not set])
	4376	AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling])
	4377	fi
	4378	if test "${ac_cv_file__dev_ptc+set}" != set; then
	4379	AC_MSG_CHECKING([for /dev/ptc])
	4380	AC_MSG_RESULT([not set])
	4381	AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling])
	4382	fi
	4383	fi
	4384
	4385	AC_CHECK_FILE(/dev/ptmx, [], [])
	4386	if test "x$ac_cv_file__dev_ptmx" = xyes; then
	4387	AC_DEFINE(HAVE_DEV_PTMX, 1,
	4388	[Define to 1 if you have the /dev/ptmx device file.])
	4389	fi
	4390	AC_CHECK_FILE(/dev/ptc, [], [])
	4391	if test "x$ac_cv_file__dev_ptc" = xyes; then
	4392	AC_DEFINE(HAVE_DEV_PTC, 1,
	4393	[Define to 1 if you have the /dev/ptc device file.])
	4394	fi
	4395
	4396	if test "$have_long_long" = yes
	4397	then
	4398	AC_MSG_CHECKING(for %lld and %llu printf() format support)
	4399	AC_CACHE_VAL(ac_cv_have_long_long_format,
	4400	AC_RUN_IFELSE([AC_LANG_SOURCE([[[
	4401	#include <stdio.h>
	4402	#include <stddef.h>
	4403	#include <string.h>
	4404
	4405	#ifdef HAVE_SYS_TYPES_H
	4406	#include <sys/types.h>
	4407	#endif
	4408
	4409	int main()
	4410	{
	4411	char buffer[256];
	4412
	4413	if (sprintf(buffer, "%lld", (long long)123) < 0)
	4414	return 1;
	4415	if (strcmp(buffer, "123"))
	4416	return 1;
	4417
	4418	if (sprintf(buffer, "%lld", (long long)-123) < 0)
	4419	return 1;
	4420	if (strcmp(buffer, "-123"))
	4421	return 1;
	4422
	4423	if (sprintf(buffer, "%llu", (unsigned long long)123) < 0)
	4424	return 1;
	4425	if (strcmp(buffer, "123"))
	4426	return 1;
	4427
	4428	return 0;
	4429	}
	4430	]]])],
	4431	[ac_cv_have_long_long_format=yes],
	4432	[ac_cv_have_long_long_format=no],
	4433	[ac_cv_have_long_long_format="cross -- assuming no"
	4434	if test x$GCC = xyes; then
	4435	save_CFLAGS=$CFLAGS
	4436	CFLAGS="$CFLAGS -Werror -Wformat"
	4437	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	4438	#include <stdio.h>
	4439	#include <stddef.h>
	4440	]], [[
	4441	char *buffer;
	4442	sprintf(buffer, "%lld", (long long)123);
	4443	sprintf(buffer, "%lld", (long long)-123);
	4444	sprintf(buffer, "%llu", (unsigned long long)123);
	4445	]])],
	4446	ac_cv_have_long_long_format=yes
	4447	)
	4448	CFLAGS=$save_CFLAGS
	4449	fi])
	4450	)
	4451	AC_MSG_RESULT($ac_cv_have_long_long_format)
	4452	fi
	4453
	4454	if test "$ac_cv_have_long_long_format" = yes
	4455	then
	4456	AC_DEFINE(PY_FORMAT_LONG_LONG, "ll",
	4457	[Define to printf format modifier for long long type])
	4458	fi
	4459
	4460	if test $ac_sys_system = Darwin
	4461	then
	4462	LIBS="$LIBS -framework CoreFoundation"
	4463	fi
	4464
	4465
	4466	AC_CACHE_CHECK([for %zd printf() format support], ac_cv_have_size_t_format, [dnl
	4467	AC_RUN_IFELSE([AC_LANG_SOURCE([[
	4468	#include <stdio.h>
	4469	#include <stddef.h>
	4470	#include <string.h>
	4471
	4472	#ifdef HAVE_SYS_TYPES_H
	4473	#include <sys/types.h>
	4474	#endif
	4475
	4476	#ifdef HAVE_SSIZE_T
	4477	typedef ssize_t Py_ssize_t;
	4478	#elif SIZEOF_VOID_P == SIZEOF_LONG
	4479	typedef long Py_ssize_t;
	4480	#else
	4481	typedef int Py_ssize_t;
	4482	#endif
	4483
	4484	int main()
	4485	{
	4486	char buffer[256];
	4487
	4488	if(sprintf(buffer, "%zd", (size_t)123) < 0)
	4489	return 1;
	4490
	4491	if (strcmp(buffer, "123"))
	4492	return 1;
	4493
	4494	if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
	4495	return 1;
	4496
	4497	if (strcmp(buffer, "-123"))
	4498	return 1;
	4499
	4500	return 0;
	4501	}
	4502	]])],
	4503	[ac_cv_have_size_t_format=yes],
	4504	[ac_cv_have_size_t_format=no],
	4505	[ac_cv_have_size_t_format="cross -- assuming yes"
	4506	])])
	4507	if test "$ac_cv_have_size_t_format" != no ; then
	4508	AC_DEFINE(PY_FORMAT_SIZE_T, "z",
	4509	[Define to printf format modifier for Py_ssize_t])
	4510	fi
	4511
	4512	AC_CHECK_TYPE(socklen_t,,
	4513	AC_DEFINE(socklen_t,int,
	4514	[Define to `int' if <sys/socket.h> does not define.]),[
	4515	#ifdef HAVE_SYS_TYPES_H
	4516	#include <sys/types.h>
	4517	#endif
	4518	#ifdef HAVE_SYS_SOCKET_H
	4519	#include <sys/socket.h>
	4520	#endif
	4521	])
	4522
	4523	case $ac_sys_system in
	4524	AIX*)
	4525	AC_DEFINE(HAVE_BROKEN_PIPE_BUF, 1, [Define if the system reports an invalid PIPE_BUF value.]) ;;
	4526	esac
	4527
[605]	4528	case $host_os in
	4529	os2-emx)
	4530	AC_DEFINE(PYOS_OS2, 1, [Define to 1 when building on OS/2.])
	4531	AC_DEFINE(PYCC_GCC, 1, [Define to 1 when building on OS/2 with GCC.])
	4532	;;
	4533	esac
[388]	4534
	4535	AC_SUBST(THREADHEADERS)
	4536
	4537	for h in `(cd $srcdir;echo Python/thread_*.h)`
	4538	do
	4539	THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
	4540	done
	4541
	4542	AC_SUBST(SRCDIRS)
	4543	SRCDIRS="Parser Grammar Objects Python Modules Mac"
	4544	AC_MSG_CHECKING(for build directories)
	4545	for dir in $SRCDIRS; do
	4546	if test ! -d $dir; then
	4547	mkdir $dir
	4548	fi
	4549	done
	4550	AC_MSG_RESULT(done)
	4551
	4552	# generate output files
	4553	AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
	4554	AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
	4555	AC_OUTPUT
	4556
	4557	echo "creating Modules/Setup"
	4558	if test ! -f Modules/Setup
	4559	then
	4560	cp $srcdir/Modules/Setup.dist Modules/Setup
	4561	fi
	4562
	4563	echo "creating Modules/Setup.local"
	4564	if test ! -f Modules/Setup.local
	4565	then
	4566	echo "# Edit this file for local setup changes" >Modules/Setup.local
	4567	fi
	4568
	4569	echo "creating Makefile"
	4570	$SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
	4571	-s Modules Modules/Setup.config \
	4572	Modules/Setup.local Modules/Setup
	4573
	4574	case $ac_sys_system in
	4575	BeOS)
	4576	AC_MSG_WARN([
	4577
	4578	Support for BeOS is deprecated as of Python 2.6.
	4579	See PEP 11 for the gory details.
	4580	])
	4581	;;
	4582	*) ;;
	4583	esac
	4584
	4585	mv config.c Modules

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

Download in other formats:

Original Format