Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

configure.in

Visit:

Last change on this file was 3402, checked in by bird, 18 years ago
os2emx -> os2knix.
File size: 94.8 KB

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

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

Download in other formats:

Original Format