Context Navigation

configure.ac

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

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

Download in other formats:

Original Format