Context Navigation

configure.in

Last change on this file was 2, checked in by Yuri Dario, 15 years ago
Initial import for vendor code.
Property svn:eol-style set to `native`
File size: 109.5 KB

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

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

Download in other formats:

Original Format