Context Navigation

configure.in

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

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

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

Download in other formats:

Original Format