Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

configure.in@ 3285

Visit:

Last change on this file since 3285 was 3225, checked in by bird, 18 years ago
Python 2.5
File size: 94.1 KB

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

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

Download in other formats:

Original Format